LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: decisiontree_falsepositive_count
int decisiontree_falsepositive_count(Decisionnodeptr node)
{
 /*!Last Changed 20.04.2008*/
 /*!Last Changed 30.09.2007*/
 int result = 0, i, fno;
 if (node->featureno == LEAF_NODE)
   return node->falsepositives;
 else
  {
   fno = node->featureno;
   if (fno >= 0 && (node->conditiontype != HYBRID_CONDITION) && current_dataset->features[fno].type == STRING)
     for (i = 0; i < current_dataset->features[fno].valuecount; i++)
       result += decisiontree_falsepositive_count(&(node->string[i]));
   else
    {
     result += decisiontree_falsepositive_count(node->left);
     result += decisiontree_falsepositive_count(node->right);
    }
   return result;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x28a9f
movq -0x10(%rbp), %rax
movl 0x88(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x28b6a
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x28b3f
movq -0x10(%rbp), %rax
cmpl $0x2, 0x98(%rax)
je 0x28b3f
leaq 0xdcd79(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x1c(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x28b3f
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
leaq 0xdcd4c(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
addq $0x30f08, %rcx          # imm = 0x30F08
movslq -0x1c(%rbp), %rdx
imulq $0x340, %rdx, %rdx      # imm = 0x340
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jge 0x28b3d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x18(%rbp), %rax
imulq $0x160, %rax, %rax      # imm = 0x160
addq %rax, %rdi
callq 0x28a70
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x28aea
jmp 0x28b64
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x28a70
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28a70
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: decisiontree_complexity_count
int decisiontree_complexity_count(Decisionnodeptr node)
{
 /*!Last Changed 24.11.2004*/
 if (node->featureno == LEAF_NODE)
   if (node->leaftype == LINEARLEAF)
     return current_dataset->multifeaturecount - 1;
   else
     return 0;
 else
   if (node->featureno >= 0)
     return 2 + decisiontree_complexity_count(node->left) + decisiontree_complexity_count(node->right);
   else
     if (node->featureno == LINEAR)
       return node->lineard + 1 + decisiontree_complexity_count(node->left) + decisiontree_complexity_count(node->right);
     else
       if (node->featureno == QUADRATIC)
         return node->quadraticd + 1 + decisiontree_complexity_count(node->left) + decisiontree_complexity_count(node->right);
       else
         return current_dataset->multifeaturecount + decisiontree_complexity_count(node->left) + decisiontree_complexity_count(node->right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x28bc7
movq -0x10(%rbp), %rax
cmpl $0x1, 0x60(%rax)
jne 0x28bbb
leaq 0xdcc99(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x28cd4
movl $0x0, -0x4(%rbp)
jmp 0x28cd4
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jl 0x28bff
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x28b80
addl $0x2, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28b80
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x28cd4
movq -0x10(%rbp), %rax
cmpl $-0x2, 0x30(%rax)
jne 0x28c4b
movq -0x10(%rbp), %rax
movl 0x90(%rax), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x28b80
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28b80
movl %eax, %ecx
movl -0x18(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x28cd4
movq -0x10(%rbp), %rax
cmpl $-0x3, 0x30(%rax)
jne 0x28c94
movq -0x10(%rbp), %rax
movl 0x94(%rax), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x28b80
movl %eax, %ecx
movl -0x24(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28b80
movl %eax, %ecx
movl -0x20(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x28cd4
leaq 0xdcba5(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x28b80
movl %eax, %ecx
movl -0x2c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28b80
movl %eax, %ecx
movl -0x28(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: decisiontree_leaf_count
int decisiontree_leaf_count(Decisionnodeptr node)
{
 /*!Last Changed 24.11.2004*/
 int fno, result = 0, i;
 if (node->featureno == LEAF_NODE)
   return 1;
 else
  {
   fno = node->featureno;
   if (fno >= 0 && (node->conditiontype != HYBRID_CONDITION) && current_dataset->features[fno].type == STRING)
     for (i = 0; i < current_dataset->features[fno].valuecount; i++)
       result += decisiontree_leaf_count(&(node->string[i]));
   else
    {
     result += decisiontree_leaf_count(node->left);
     result += decisiontree_leaf_count(node->right);
    }
   return result;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x28d09
movl $0x1, -0x4(%rbp)
jmp 0x28dd4
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x28da9
movq -0x10(%rbp), %rax
cmpl $0x2, 0x98(%rax)
je 0x28da9
leaq 0xdcb0f(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x14(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x28da9
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0xdcae2(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
addq $0x30f08, %rcx          # imm = 0x30F08
movslq -0x14(%rbp), %rdx
imulq $0x340, %rdx, %rdx      # imm = 0x340
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jge 0x28da7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x160, %rax, %rax      # imm = 0x160
addq %rax, %rdi
callq 0x28ce0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x28d54
jmp 0x28dce
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x28ce0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28ce0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: decisiontree_node_count
int decisiontree_node_count(Decisionnodeptr node)
{
 /*!Last Changed 24.11.2004*/
 int fno, result = 1, i;
 if (node->featureno == LEAF_NODE)
   return 0;
 else
  {
   fno = node->featureno;
   if (fno >= 0 && (node->conditiontype != HYBRID_CONDITION) && current_dataset->features[fno].type == STRING)
     for (i = 0; i < current_dataset->features[fno].valuecount; i++)
      {
       result += decisiontree_node_count(&(node->string[i]));
      }
   else
    {
     result += decisiontree_node_count(node->left);
     result += decisiontree_node_count(node->right);
    }
   return result;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x28e09
movl $0x0, -0x4(%rbp)
jmp 0x28ed4
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x28ea9
movq -0x10(%rbp), %rax
cmpl $0x2, 0x98(%rax)
je 0x28ea9
leaq 0xdca0f(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x14(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x28ea9
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0xdc9e2(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
addq $0x30f08, %rcx          # imm = 0x30F08
movslq -0x14(%rbp), %rdx
imulq $0x340, %rdx, %rdx      # imm = 0x340
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jge 0x28ea7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x160, %rax, %rax      # imm = 0x160
addq %rax, %rdi
callq 0x28de0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x28e54
jmp 0x28ece
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x28de0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28de0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: decisiontree_condition_count
int decisiontree_condition_count(Decisionnodeptr node)
{
 /*!Last Changed 23.09.2004 added hybridcondition*/
 /*!Last Changed 10.11.2003*/
 int result = 0, fno, i;
 if (node->featureno == LEAF_NODE)
   return node->conditioncount;
 else
  {
   fno = node->featureno;
   if (fno >= 0 && (node->conditiontype != HYBRID_CONDITION) && current_dataset->features[fno].type == STRING)
     for (i = 0; i < current_dataset->features[fno].valuecount; i++)
       result += decisiontree_condition_count(&(node->string[i]));
   else
    {
     result += decisiontree_condition_count(node->left);
     result += decisiontree_condition_count(node->right);
    }
   return result;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x28f0f
movq -0x10(%rbp), %rax
movl 0x80(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x28fda
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x28faf
movq -0x10(%rbp), %rax
cmpl $0x2, 0x98(%rax)
je 0x28faf
leaq 0xdc909(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x18(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x28faf
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0xdc8dc(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
addq $0x30f08, %rcx          # imm = 0x30F08
movslq -0x18(%rbp), %rdx
imulq $0x340, %rdx, %rdx      # imm = 0x340
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jge 0x28fad
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x160, %rax, %rax      # imm = 0x160
addq %rax, %rdi
callq 0x28ee0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x28f5a
jmp 0x28fd4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x28ee0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28ee0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: decisiontree_rule_count
int decisiontree_rule_count(Decisionnodeptr node)
{
 /*!Last Changed 23.09.2004 added hybridcondition*/
 /*!Last Changed 10.11.2003*/
 int result = 0, fno, i;
 if (node->featureno == LEAF_NODE)
   return 1;
 else
  {
   fno = node->featureno;
   if (fno >= 0 && (node->conditiontype != HYBRID_CONDITION) && current_dataset->features[fno].type == STRING)
     for (i = 0; i < current_dataset->features[fno].valuecount; i++)
       result += decisiontree_rule_count(&(node->string[i]));
   else
   {
    result += decisiontree_rule_count(node->left);
    result += decisiontree_rule_count(node->right);
   }
   return result;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x29019
movl $0x1, -0x4(%rbp)
jmp 0x290e4
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x290b9
movq -0x10(%rbp), %rax
cmpl $0x2, 0x98(%rax)
je 0x290b9
leaq 0xdc7ff(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x18(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x290b9
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0xdc7d2(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
addq $0x30f08, %rcx          # imm = 0x30F08
movslq -0x18(%rbp), %rdx
imulq $0x340, %rdx, %rdx      # imm = 0x340
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jge 0x290b7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x160, %rax, %rax      # imm = 0x160
addq %rax, %rdi
callq 0x28ff0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x29064
jmp 0x290de
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x28ff0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28ff0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: accumulate_instances_leaf
void accumulate_instances_leaf(Instanceptr* data, Decisionnodeptr leaf)
{
 /*!Last Changed 27.10.2003*/
 Instanceptr tmp;
 if ((*data) == NULL)
   *data = leaf->instances;
 else
  {
   tmp = *data;
   while (tmp->next != NULL)
     tmp = tmp->next;
   tmp->next = leaf->instances;
  }
 leaf->instances = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x29117
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2914b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2913b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x29122
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: accumulate_instances_tree
void accumulate_instances_tree(Instanceptr* data, Decisionnodeptr root)
{
 /*!Last Changed 28.05.2005 updated according to SVMTREE*/
 /*!Last Changed 24.11.2004 added hybridcondition*/
 /*!Last Changed 27.09.2004 updated to include multivariate nodes*/
 /*!Last Changed 27.10.2003*/
 int i, fno;
 if (root->featureno == LEAF_NODE)
   accumulate_instances_leaf(data, root);
 else
  {
   fno = root->featureno;
   if (fno < 0 || root->conditiontype == HYBRID_CONDITION)
    {
     accumulate_instances_tree(data, root->left);
     accumulate_instances_tree(data, root->right);
    }
   else
     switch (current_dataset->features[fno].type){
       case INTEGER:
       case REAL   :accumulate_instances_tree(data, root->left);
                    accumulate_instances_tree(data, root->right);
                    break;
       case STRING :for (i=0;i<current_dataset->features[fno].valuecount;i++)
                      accumulate_instances_tree(data, &(root->string[i]));
                    break; 
     }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x2918c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x290f0
jmp 0x29289
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x291a9
movq -0x10(%rbp), %rax
cmpl $0x2, 0x98(%rax)
jne 0x291cf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x29160
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x29160
jmp 0x29287
leaq 0xdc66a(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x29208
jmp 0x291f4
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x2922b
jmp 0x291fe
movl -0x1c(%rbp), %eax
subl $0x2, %eax
jne 0x29285
jmp 0x29208
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x29160
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x29160
jmp 0x29285
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0xdc604(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
addq $0x30f08, %rcx          # imm = 0x30F08
movslq -0x18(%rbp), %rdx
imulq $0x340, %rdx, %rdx      # imm = 0x340
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jge 0x29283
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0x14(%rbp), %rax
imulq $0x160, %rax, %rax      # imm = 0x160
addq %rax, %rsi
callq 0x29160
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x29232
jmp 0x29285
jmp 0x29287
jmp 0x29289
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: setup_node_properties
BOOLEAN setup_node_properties(Decisionnodeptr node)
{
 int maxcount, classno;
 node->counts = find_class_counts(node->instances);
 classno = all_in_one_class(node->instances, &maxcount);
 node->classno = classno / 10;
 node->covered = data_size(node->instances);
 node->falsepositives = node->covered - maxcount; 
 if (!(classno % 10))
   return BOOLEAN_FALSE;
 else
   return BOOLEAN_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x183a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x18420
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x449f0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x84(%rax)
movq -0x10(%rbp), %rax
movl 0x84(%rax), %ecx
subl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x88(%rax)
movl -0x18(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x29328
movl $0x0, -0x4(%rbp)
jmp 0x2932f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: can_be_divided
int can_be_divided(Decisionnodeptr node, C45_parameterptr p)
{
 /*!Last Changed 10.08.2005 parametre ile prunetype ile threshold kontrol ediliyor*/
 /*!Last Changed 12.04.2003 prepruning eklendi*/
 /*  node->classno = classno/10; satiri eklendi Last Changed 12.04.2003*/
 int size;
 if (!setup_node_properties(node))
  {
   make_leaf_node(node);
   return NO;
  }
 if (p && p->prunetype == PREPRUNING)
  {
   size = data_size(node->instances);
   if ((size + 0.0) / current_dataset->traincount < p->pruningthreshold)
    {
     make_leaf_node(node);
     return NO;
    }
  }
 return YES;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x29290
cmpl $0x0, %eax
jne 0x29370
movq -0x10(%rbp), %rdi
callq 0x28a30
movl $0x0, -0x4(%rbp)
jmp 0x293dc
cmpq $0x0, -0x18(%rbp)
je 0x293d5
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x293d5
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x449f0
movl %eax, -0x1c(%rbp)
cvtsi2sdl -0x1c(%rbp), %xmm1
xorps %xmm0, %xmm0
addsd %xmm0, %xmm1
leaq 0xdc49d(%rip), %rax     # 0x105840
movq (%rax), %rax
cvtsi2sdl 0x1407124(%rax), %xmm0
divsd %xmm0, %xmm1
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x293d3
movq -0x10(%rbp), %rdi
callq 0x28a30
movl $0x0, -0x4(%rbp)
jmp 0x293dc
jmp 0x293d5
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: is_smaller_discrete_order
int is_smaller_discrete_order(Instanceptr inst, Korderingsplit ksplit)
{
 int i, j, fvalue, fno;
 for (i = 0; i < ksplit.featurecount; i++)
  {
   fno = ksplit.featurelist[i];
   fvalue = inst->values[fno].stringindex;
   if (fvalue == ksplit.sortorder[i][ksplit.discretesplit[i]])
     continue;
   for (j = 0; j < ksplit.discretesplit[i]; j++)
     if (fvalue == ksplit.sortorder[i][j])
       return YES;
   return NO;
  }
 return YES;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0x29a5f
movq -0x28(%rbp), %rdx
movq 0x8(%rdx), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq 0x18(%rdx), %rcx
movslq -0x14(%rbp), %rsi
movq (%rcx,%rsi,8), %rcx
movq 0x10(%rdx), %rdx
movslq -0x14(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x299fb
jmp 0x29a51
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
movq 0x10(%rcx), %rcx
movslq -0x14(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x29a48
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
movq 0x18(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x18(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x29a3b
movl $0x1, -0x4(%rbp)
jmp 0x29a66
jmp 0x29a3d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x29a02
movl $0x0, -0x4(%rbp)
jmp 0x29a66
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x299a7
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: svm_split_value
double svm_split_value(Instanceptr inst, Svm_split s)
{
 /*!Last Changed 28.05.2005*/
 int i;
 double value = 0;
 Svm_nodeptr x;
 x = instance_to_svmnode(inst);
 for (i = 0; i < s.l; i++)
   value += s.sv_coef[i] * k_function(x, s.SV[i], s.param);
 value -= s.rho;
 safe_free(x);
 return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x42b00
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x28(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x58(%rcx), %eax
jge 0x29df7
movq -0x28(%rbp), %rcx
movq 0x68(%rcx), %rax
movslq -0xc(%rbp), %rdx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq 0x60(%rcx), %rax
movslq -0xc(%rbp), %rdx
movq (%rax,%rdx,8), %rsi
movq 0x50(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x50(%rax)
movups 0x40(%rcx), %xmm0
movups %xmm0, 0x40(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xcaa90
movaps %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x29d63
movq -0x28(%rbp), %rax
movsd 0x70(%rax), %xmm1
movsd -0x18(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x52e80
movsd -0x18(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: test_tree
int test_tree(Decisionnodeptr root, Instanceptr testingdata)
{
 /*!Last Changed 01.11.2005*/
 /*!Last Changed 26.09.2004*/
 /*!Last Changed 22.03.2002*/
 int i, performance = 0;
 Instanceptr test = testingdata;
 Decisionnodeptr currentnode;
 while (test)
  {
   currentnode = root;
   while (currentnode->featureno != LEAF_NODE)
     currentnode = next_node(currentnode, test); 
   i = give_classno(test);
   if (i == currentnode->classno)
     performance++;
   test = test->next;
  }
 return performance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x29eaa
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
je 0x29e7b
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x29a70
movq %rax, -0x28(%rbp)
jmp 0x29e5e
movq -0x20(%rbp), %rdi
callq 0x43530
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x34(%rcx), %eax
jne 0x29e9c
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x29e4f
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: deallocate_tree_rule
void deallocate_tree_rule(Decisionnodeptr node)
{
 /*!Last Changed 29.11.2004*/
 int i;
 if (node->rule)
  {
   for (i = 0; i < node->conditioncount; i++)
			 {
     if (in_list(node->rule[i].featureindex, 2, LINEARRULE, QUADRATICRULE))
       matrix_free(node->rule[i].w);
					if (node->rule[i].featureindex == DISCRETEMIX)
						 deallocate_korderingsplit(node->rule[i].ksplit);
				}
   safe_free(node->rule);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x29fb8
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x80(%rcx), %eax
jge 0x29fab
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %edi
movl $0x2, %esi
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0x29f45
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdi
movq 0x28(%rax), %rsi
callq 0x59ea0
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
cmpl $-0x5, (%rax)
jne 0x29f9b
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
addq $0x50, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x29fc0
jmp 0x29f9d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x29ee2
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x52e80
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: deallocate_korderingsplit
void deallocate_korderingsplit(Korderingsplit ksplit)
{
	int i;
 safe_free(ksplit.featurelist);
 safe_free(ksplit.discretesplit);
 for (i = 0; i < ksplit.featurecount; i++)
   safe_free(ksplit.sortorder[i]);
 safe_free(ksplit.sortorder);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x52e80
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x52e80
movl $0x0, -0x4(%rbp)
movq -0x10(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl (%rcx), %eax
jge 0x2a018
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x52e80
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x29fed
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: free_children
void free_children(Decisionnodeptr node)
{
 /*!Last Changed 20.04.2008*/
 /*!Last Changed 24.05.2006*/
 int i, fno = node->featureno;
 if (fno >= 0 && (node->conditiontype != HYBRID_CONDITION) && current_dataset->features[fno].type == STRING)
  {
   for (i = 0; i < current_dataset->features[fno].valuecount; i++)
     deallocate_tree(&(node->string[i]));
   safe_free(node->string);
   node->string = NULL;
  }
 else
  {
   deallocate_tree(node->left);
   safe_free(node->left);
   node->left = NULL;
   deallocate_tree(node->right);
   safe_free(node->right); 
   node->right = NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x2a313
movq -0x8(%rbp), %rax
cmpl $0x2, 0x98(%rax)
je 0x2a313
leaq 0xdb5b8(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x10(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x2a313
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0xdb58b(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
addq $0x30f08, %rcx          # imm = 0x30F08
movslq -0x10(%rbp), %rdx
imulq $0x340, %rdx, %rdx      # imm = 0x340
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jge 0x2a2f8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x160, %rax, %rax      # imm = 0x160
addq %rax, %rdi
callq 0x2a030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2a2ab
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x2a35c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2a030
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2a030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: entropy
double entropy(int* counts)
{
 double p, result = 0.0;
 int i, sum = 0;
 for (i = 0; i < current_dataset->classno; i++)
   sum += counts[i];
 for (i = 0; i < current_dataset->classno; i++)
   if (counts[i] > 0 && sum > 0)
    {
     p = counts[i] / (sum + 0.0);
     result -= p * log2(p);
    }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0xdb214(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x2a650
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2a622
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0xdb1df(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x2a6f8
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x2a6e8
cmpl $0x0, -0x20(%rbp)
jle 0x2a6e8
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
cvtsi2sdl -0x20(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x52ad0
movaps %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x2a6ea
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2a657
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: find_subtree_class_counts
void find_subtree_class_counts(Decisionnodeptr subtree, int* counts)
{
 /*!Last Changed 10.02.2005*/
 int* classcounts, i;
 if (subtree->featureno == LEAF_NODE)
  {
   classcounts = find_class_counts(subtree->instances);
   for (i = 0; i < current_dataset->classno; i++)
     counts[i] += classcounts[i];
   safe_free(classcounts);
  }
 else
  {
   find_subtree_class_counts(subtree->left, counts);
   find_subtree_class_counts(subtree->right, counts);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x2a9d3
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x183a0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0xdaea4(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x2a9c8
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2a992
movq -0x18(%rbp), %rdi
callq 0x52e80
jmp 0x2a9f4
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a960
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a960
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: subtree_covered_and_false_positives
void subtree_covered_and_false_positives(Decisionnodeptr root, int* C, int* fp)
{
 /*!Last Changed 10.02.2005*/
 if (root->featureno == LEAF_NODE)
  {
   *C += root->covered;
   *fp += root->falsepositives;
  }
 else
  {
   subtree_covered_and_false_positives(root->left, C, fp);
   subtree_covered_and_false_positives(root->right, C, fp);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x2aa44
movq -0x8(%rbp), %rax
movl 0x84(%rax), %ecx
movq -0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x2aa6d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2aa00
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2aa00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: decisiontree_loglikelihood
double decisiontree_loglikelihood(Decisionnodeptr root)
{
 /*!Last Changed 10.02.2005*/
 int* classcounts;
 double loglikelihood;
 if (root->featureno == LEAF_NODE)
  {
   classcounts = find_class_counts(root->instances);
   loglikelihood = log_likelihood_for_classification(classcounts);
   safe_free(classcounts);
   return loglikelihood;
  }
 else
   return decisiontree_loglikelihood(root->left) + decisiontree_loglikelihood(root->right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x2aaca
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x183a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2ab10
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x52e80
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2aaf9
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2aa80
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2aa80
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: log_likelihood_for_classification
double log_likelihood_for_classification(int classcounts[])
{
 /*!Last Changed 22.11.2004*/
 int i, sum = 0;
 double result = 0, p;
 for (i = 0; i < current_dataset->classno; i++)
   sum += classcounts[i];
 for (i = 0; i < current_dataset->classno; i++)
   if (classcounts[i] != 0)
    {
     p = classcounts[i] / (sum + 0.0);
     result += classcounts[i] * log2(p);
    }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0xdad04(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x2ab60
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ab32
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0xdaccf(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x2abef
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x2abdf
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
cvtsi2sdl -0x10(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x52ad0
movaps %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x2abe1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ab67
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: information_gain
double information_gain(int ratio[2][MAXCLASSES])
{
 int sum[2] = {0,0},i,j;
 double res[2] = {0,0},p;
 for (j = 0; j < 2; j++)
  {
   for (i = 0; i < current_dataset->classno; i++)
     sum[j] += ratio[j][i];
   if (sum[j] == 0)
     return ISELL;
   for (i = 0; i < current_dataset->classno; i++)
     if (ratio[j][i] > 0)
      {
       p = ratio[j][i] / (sum[j] + 0.0);
       res[j] -= p * log2(p);
      }
  }
 return (res[0] * sum[0] + res[1] * sum[1]) / (sum[0] + sum[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x4050
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x4050
movl $0x0, -0x20(%rbp)
cmpl $0x2, -0x20(%rbp)
jge 0x2ad80
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0xdabf2(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x2ac86
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movslq -0x20(%rbp), %rax
addl -0x18(%rbp,%rax,4), %ecx
movl %ecx, -0x18(%rbp,%rax,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2ac44
movslq -0x20(%rbp), %rax
cmpl $0x0, -0x18(%rbp,%rax,4)
jne 0x2aca3
movsd 0xb7cff(%rip), %xmm0    # 0xe2998
movsd %xmm0, -0x8(%rbp)
jmp 0x2adb3
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0xdab8c(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x2ad70
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x2ad60
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
movslq -0x20(%rbp), %rax
cvtsi2sdl -0x18(%rbp,%rax,4), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x52ad0
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movslq -0x20(%rbp), %rax
movsd -0x30(%rbp,%rax,8), %xmm1
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp,%rax,8)
jmp 0x2ad62
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2acaa
jmp 0x2ad72
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2ac33
movsd -0x30(%rbp), %xmm0
cvtsi2sdl -0x18(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
cvtsi2sdl -0x14(%rbp), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: get_empty_partition
Partition get_empty_partition(Instanceptr instances)
{
 /*!Last Changed 31.05.2005*/
 Partition result;
 int count;
 result.classes = get_classes(instances, &count);
 result.count = count;
 result.assignments = (int *)safecalloc(count, sizeof(int), "get_empty_partition", 5);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x46b70
movq -0x20(%rbp), %rdi
movq %rax, (%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x10(%rdi)
movslq -0xc(%rbp), %rdi
movl $0x4, %esi
leaq 0xb9690(%rip), %rdx     # 0xe450e
movl $0x5, %ecx
callq 0x52f40
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: get_initial_partition
Partition get_initial_partition(Instanceptr instances)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 26.01.2003*/
 Partition result;
 int i, count;
 result.classes = get_classes(instances, &count);
 result.count = count;
 result.assignments = (int *)safemalloc(count*sizeof(int), "get_initial_partition", 5);
 if (count == 2)
  {
   result.assignments[0] = LEFT;
   result.assignments[1] = RIGHT;
  }
 else
   for (i = 0; i < count; i++)
     result.assignments[i] = myrand() % 2;
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x46b70
movq -0x18(%rbp), %rdi
movq %rax, (%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0x10(%rdi)
movslq -0x10(%rbp), %rdi
shlq $0x2, %rdi
leaq 0xb9645(%rip), %rsi     # 0xe4522
movl $0x5, %edx
callq 0x52d70
movq -0x18(%rbp), %rdi
movq %rax, 0x8(%rdi)
cmpl $0x2, -0x10(%rbp)
jne 0x2af10
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x0, (%rcx)
movq 0x8(%rax), %rax
movl $0x1, 0x4(%rax)
jmp 0x2af4a
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2af48
movb $0x0, %al
callq 0x54550
movl $0x2, %ecx
cltd
idivl %ecx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2af17
jmp 0x2af4a
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: get_start_partition
Partition get_start_partition(Instanceptr instances, int leftclass)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 29.12.2003*/
 /*!Last Changed 04.02.2003*/
 Partition result;
 int i, count;
 result.classes = get_classes(instances, &count);
 result.count = count;
 result.assignments = (int *)safemalloc(count*sizeof(int), "get_start_partition", 5);
 for (i = 0; i < count; i++)
   result.assignments[i] = RIGHT;
 for (i = 0; i < count; i++)
   if (result.classes[i] == leftclass)
    {
     result.assignments[i] = LEFT;
     break;
    }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x46b70
movq -0x20(%rbp), %rdi
movq %rax, (%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x10(%rdi)
movslq -0x14(%rbp), %rdi
shlq $0x2, %rdi
leaq 0xb9598(%rip), %rsi     # 0xe4538
movl $0x5, %edx
callq 0x52d70
movq -0x20(%rbp), %rdi
movq %rax, 0x8(%rdi)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2afdf
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2afb9
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2b023
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
jne 0x2b016
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x2b023
jmp 0x2b018
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2afe6
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: depth_of_tree
int depth_of_tree(Decisionnodeptr node)
{
 /*!Last Changed 12.07.2006*/
 int i, maxdepth, depth, leftdepth, rightdepth;
 if (node->featureno == LEAF_NODE)
   return 1;
 else
  {
   if (node->featureno >= 0 && current_dataset->features[node->featureno].type == STRING)
    {
     maxdepth = -1;
     for (i = 0; i < current_dataset->features[node->featureno].valuecount; i++)
      { 
       depth = depth_of_tree(&(node->string[i]));
       if (depth > maxdepth)
         maxdepth = depth;
      }
     return maxdepth + 1;
    }
   else
    {
     leftdepth = depth_of_tree(node->left);
     rightdepth = depth_of_tree(node->right);
     if (leftdepth >= rightdepth)
       return leftdepth + 1;
     else
       return rightdepth + 1;     
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x2b212
movl $0x1, -0x4(%rbp)
jmp 0x2b2ff
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jl 0x2b2c4
leaq 0xda619(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movq -0x10(%rbp), %rcx
movslq 0x30(%rcx), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x2b2c4
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0xda5e1(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
addq $0x30f08, %rcx          # imm = 0x30F08
movq -0x10(%rbp), %rdx
movslq 0x30(%rdx), %rdx
imulq $0x340, %rdx, %rdx      # imm = 0x340
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jge 0x2b2b9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x160, %rax, %rax      # imm = 0x160
addq %rax, %rdi
callq 0x2b1f0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x2b2ac
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x2b2ae
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2b255
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2b2ff
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2b1f0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2b1f0
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl 0x2b2f6
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2b2ff
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)