LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/screen.c
// Function: print_one_independence
void print_one_independence(bayesiangraphptr mygraph)
{
/*Last Changed 04.02.2001*/
 int i, j, k, l = 0;
 for (i = 0; i < mygraph->nodecount; i++)
   for (j = 0; j < mygraph->nodecount; j++)
     for (k = 0; k < mygraph->nodecount; k++)
       if ((i != j) && (i != k) && (j != k))
        {
         fprintf(output, "%d %d %d %8.4f\n", i, j, k, mygraph->one_independence[i][j][k]);
         l++;
         if (l % 23 == 0)
          {
           fprintf(output, "Press any key to continue\n");
           getc(stdin);
          }
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0xbda11
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0xbda01
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0xbd9f1
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0xbd9e1
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0xbd9e1
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0xbd9e1
leaq 0x324715(%rip), %rax    # 0x3e2078
movq (%rax), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rsi
movq (%rax,%rsi,8), %rax
movslq -0x10(%rbp), %rsi
movq (%rax,%rsi,8), %rax
movslq -0x14(%rbp), %rsi
movsd (%rax,%rsi,8), %xmm0
leaq 0x3008d(%rip), %rsi     # 0xeda25
movb $0x1, %al
callq 0x4280
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl $0x17, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xbd9df
leaq 0x3246b9(%rip), %rax    # 0x3e2078
movq (%rax), %rdi
leaq 0x3006c(%rip), %rsi     # 0xeda35
movb $0x0, %al
callq 0x4280
movq 0x46611(%rip), %rax     # 0x103fe8
movq (%rax), %rdi
callq 0x42f0
jmp 0xbd9e1
jmp 0xbd9e3
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbd928
jmp 0xbd9f3
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xbd911
jmp 0xbda03
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbd8fa
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/screen.c
// Function: display_file
void display_file(char* file_name)
{
 FILE* infile;
 char line[READLINELENGTH];
 infile = fopen(file_name, "r");
 if (!infile)
  {
   printf(m1052);
   return;
  }
 while (fgets(line, READLINELENGTH, infile))
   printf("%s", line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a130, %rsp          # imm = 0x7A130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2a76c(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xbda5a
leaq 0x266a1(%rip), %rdi     # 0xe40f2
movb $0x0, %al
callq 0x4030
jmp 0xbda8e
jmp 0xbda5c
leaq -0x7a130(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x40f0
cmpq $0x0, %rax
je 0xbda8e
leaq -0x7a130(%rbp), %rsi
leaq 0x27013(%rip), %rdi     # 0xe4a98
movb $0x0, %al
callq 0x4030
jmp 0xbda5c
addq $0x7a130, %rsp          # imm = 0x7A130
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/screen.c
// Function: print_time
void print_time(double t)
{
 int tmp;
 if (t > SECONDS_IN_A_DAY)
  {
   tmp = (int)(t / SECONDS_IN_A_DAY);
   printf(m1310, tmp);
   t = t - tmp * SECONDS_IN_A_DAY;
  }
 if (t > SECONDS_IN_A_HOUR)
  {
   tmp = (int)(t / SECONDS_IN_A_HOUR);
   printf(m1311, tmp);
   t = t - tmp * SECONDS_IN_A_HOUR;
  }
 if (t > SECONDS_IN_A_MINUTE)
  {
   tmp = (int)(t / SECONDS_IN_A_MINUTE);
   printf(m1312, tmp);
   t = t - tmp * SECONDS_IN_A_MINUTE;
  }
 printf(m1313, t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x2fe96(%rip), %xmm1    # 0xed950
ucomisd %xmm1, %xmm0
jbe 0xbdb1d
movsd -0x8(%rbp), %xmm0
movsd 0x2fe93(%rip), %xmm1    # 0xed960
divsd %xmm1, %xmm0
movsd 0x2fe7f(%rip), %xmm1    # 0xed958
mulsd %xmm1, %xmm0
movsd 0x2fe73(%rip), %xmm1    # 0xed958
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0x2ff56(%rip), %rdi     # 0xeda50
movb $0x0, %al
callq 0x4030
movsd -0x8(%rbp), %xmm0
imull $0x18, -0xc(%rbp), %eax
imull $0x3c, %eax, %eax
imull $0x3c, %eax, %eax
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x2fe3e(%rip), %xmm1    # 0xed968
ucomisd %xmm1, %xmm0
jbe 0xbdb7e
movsd -0x8(%rbp), %xmm0
movsd 0x2fe1b(%rip), %xmm1    # 0xed958
divsd %xmm1, %xmm0
movsd 0x2fe0f(%rip), %xmm1    # 0xed958
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0x2fefa(%rip), %rdi     # 0xeda58
movb $0x0, %al
callq 0x4030
movsd -0x8(%rbp), %xmm0
imull $0x3c, -0xc(%rbp), %eax
imull $0x3c, %eax, %eax
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x2fdcd(%rip), %xmm1    # 0xed958
ucomisd %xmm1, %xmm0
jbe 0xbdbd0
movsd -0x8(%rbp), %xmm0
movsd 0x2fdba(%rip), %xmm1    # 0xed958
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0x2feae(%rip), %rdi     # 0xeda61
movb $0x0, %al
callq 0x4030
movsd -0x8(%rbp), %xmm0
imull $0x3c, -0xc(%rbp), %eax
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
leaq 0x2fe8d(%rip), %rdi     # 0xeda69
movb $0x1, %al
callq 0x4030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/softregtree.c
// Function: soft_regtree_output
double soft_regtree_output(Regressionnodeptr node, Instanceptr inst)
{
 if (node->featureno == LEAF_NODE)
   if (node->leaftype == CONSTANTLEAF)
     node->output = node->regressionvalue;
   else
     node->output = linear_fit_value(node->w, inst);
 else
  {
   node->left->weight = sigmoid(linear_fit_value(node->w, inst));
   node->right->weight = 1 - node->left->weight;
   node->output = node->left->weight * soft_regtree_output(node->left, inst) + node->right->weight * soft_regtree_output(node->right, inst);
  }
 return node->output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x68(%rax)
jne 0xbdc4b
movq -0x8(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
jne 0xbdc28
movq -0x8(%rbp), %rax
movsd 0x70(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x40(%rax)
jmp 0xbdc46
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0xa6aa0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x40(%rax)
jmp 0xbdd02
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0xa6aa0
callq 0x7aab0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd %xmm0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd 0x24398(%rip), %xmm0    # 0xe2018
subsd 0x48(%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsd %xmm0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd 0x48(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xbdbf0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsd 0x48(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xbdbf0
movsd -0x28(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x18(%rbp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x40(%rax)
movq -0x8(%rbp), %rax
movsd 0x40(%rax), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/softregtree.c
// Function: mse_error_of_soft_regression_tree
double mse_error_of_soft_regression_tree(Regressionnodeptr rootnode, Instanceptr list)
{
 int count = 0;
 double r, o, mse = 0.0;
 Instanceptr inst = list;
 while (inst)
  {
   r = give_regressionvalue(inst);
   o = soft_regtree_output(rootnode, inst);
   mse += (r - o) * (r - o);
   inst = inst->next;
   count++;
  }
 return mse / count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xbddab
movq -0x38(%rbp), %rdi
callq 0x43580
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xbdbf0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm2
subsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbdd47
movsd -0x30(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
divsd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/softregtree.c
// Function: free_soft_regtree_ws
void free_soft_regtree_ws(Regressionnodeptr node)
{
 matrix_free(node->w);
 if (node->leaftype != CONSTANTLEAF)
  {
   matrix_free(node->left->w);
   matrix_free(node->right->w);
  } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x59ea0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
je 0xbe440
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x59ea0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x59ea0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/softregtree.c
// Function: copy_soft_regtree_ws
void copy_soft_regtree_ws(Regressionnodeptr dest, Regressionnodeptr src)
{
 dest->w = matrix_copy(src->w);
 if (src->leaftype == CONSTANTLEAF)
  {
   dest->left->regressionvalue = src->left->regressionvalue;
   dest->right->regressionvalue = src->right->regressionvalue;
  }
 else
  {
   dest->left->w = matrix_copy(src->left->w);
   dest->right->w = matrix_copy(src->right->w);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x58550
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
jne 0xbe4d6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsd 0x70(%rax), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd %xmm0, 0x70(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsd 0x70(%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsd %xmm0, 0x70(%rax)
jmp 0xbe554
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x58550
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x58550
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x38(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/softregtree.c
// Function: soft_output_of_subregressiontree
double soft_output_of_subregressiontree(Regressionnodeptr subtree, double input)
{
 double weight, output, multiplier;
 Regressionnodeptr tmpnode;
 if (subtree->featureno == LEAF_NODE)
  {
   if (subtree->leaftype == CONSTANTLEAF)
     output = subtree->regressionvalue;    
   else
     output = subtree->w.values[0][0] + subtree->w.values[1][0] * input; 
   multiplier = 1.0;
   tmpnode = subtree;
   while (tmpnode->parent)
    {
     weight = sigmoid(tmpnode->parent->w.values[0][0] + tmpnode->parent->w.values[1][0] * input);
     if (tmpnode == tmpnode->parent->left)
       multiplier *= weight;
     else
       multiplier *= (1 - weight);
     tmpnode = tmpnode->parent;
    }
   return output * multiplier;   
  }
 else
   return soft_output_of_subregressiontree(subtree->left, input) + soft_output_of_subregressiontree(subtree->right, input);   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x68(%rax)
jne 0xbeb17
movq -0x10(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
jne 0xbea29
movq -0x10(%rbp), %rax
movsd 0x70(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0xbea5a
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movsd (%rax), %xmm1
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
movsd -0x18(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x235b6(%rip), %xmm0    # 0xe2018
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xbeb06
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movsd (%rax), %xmm1
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
movsd -0x18(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x7aab0
movsd %xmm0, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq (%rcx), %rax
jne 0xbeade
movsd -0x20(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0xbeaf5
movsd 0x23532(%rip), %xmm0    # 0xe2018
subsd -0x20(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xbea6f
movsd -0x28(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xbeb50
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movsd -0x18(%rbp), %xmm0
callq 0xbe9f0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movsd -0x18(%rbp), %xmm0
callq 0xbe9f0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/softregtree.c
// Function: create_softregtree
int create_softregtree(Regressionnodeptr rootnode, Regressionnodeptr node, Instanceptr cvdata, Softregtree_parameterptr param)
{
 node->cvinstances = NULL;
 if (node != rootnode)
   node->instances = NULL;
 if (find_best_soft_regtree_split(rootnode, node, cvdata, param))
  {
   create_softregtree(rootnode, node->left, cvdata, param);
   create_softregtree(rootnode, node->right, cvdata, param);
  }
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0xbeb9a
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xbe560
cmpl $0x0, %eax
je 0xbebe5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xbeb60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xbeb60
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/softtree.c
// Function: soft_tree_output_K_class
double* soft_tree_output_K_class(Decisionnodeptr node, Instanceptr inst)
{
 int i;
 double *left_output, *right_output;
 if (node->featureno == LEAF_NODE)
   memcpy(node->outputs, node->w0s, current_dataset->classno * sizeof(double));
 else
  {
   node->left->weight = sigmoid(linear_fit_value(node->w, inst));
   node->right->weight = 1 - node->left->weight;
   left_output = soft_tree_output_K_class(node->left, inst);
   right_output = soft_tree_output_K_class(node->right, inst);
   for (i = 0; i < current_dataset->classno; i++)
     node->outputs[i] = node->left->weight * left_output[i] + node->right->weight * right_output[i];
  }
 return node->outputs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0xbec36
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rsi
leaq 0x46c1f(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdx
shlq $0x3, %rdx
callq 0x42b0
jmp 0xbed18
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0xa6aa0
callq 0x7aab0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd %xmm0, 0x78(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd 0x233ad(%rip), %xmm0    # 0xe2018
subsd 0x78(%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsd %xmm0, 0x78(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xbebf0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xbebf0
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x46b89(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xbed16
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd 0x78(%rax), %xmm0
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsd 0x78(%rax), %xmm1
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbecad
jmp 0xbed18
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/softtree.c
// Function: soft_tree_output
double soft_tree_output(Decisionnodeptr node, Instanceptr inst)
{
 if (node->featureno == LEAF_NODE)
   if (node->leaftype == CONSTANTLEAF)
     node->output = node->w0;
   else
     node->output = linear_fit_value(node->w, inst);
 else
  {
   node->left->weight = sigmoid(linear_fit_value(node->w, inst));
   node->right->weight = 1 - node->left->weight;
   node->output = node->left->weight * soft_tree_output(node->left, inst) + node->right->weight * soft_tree_output(node->right, inst);
  }
 return node->output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0xbed8b
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0xbed68
movq -0x8(%rbp), %rax
movsd 0x48(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x68(%rax)
jmp 0xbed86
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0xa6aa0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x68(%rax)
jmp 0xbee42
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0xa6aa0
callq 0x7aab0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd %xmm0, 0x78(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd 0x23258(%rip), %xmm0    # 0xe2018
subsd 0x78(%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsd %xmm0, 0x78(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd 0x78(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xbed30
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsd 0x78(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xbed30
movsd -0x28(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x18(%rbp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x68(%rax)
movq -0x8(%rbp), %rax
movsd 0x68(%rax), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/softtree.c
// Function: error_of_soft_tree_K_class
int error_of_soft_tree_K_class(Decisionnodeptr rootnode, Instanceptr list)
{
 int count = 0, classno;
 double* o;
 Instanceptr inst = list;
 while (inst)
  {
   classno = give_classno(inst);
   o = soft_tree_output_K_class(rootnode, inst);
   if (find_max_in_list_double(o, current_dataset->classno) != classno)
     count++;
   inst = inst->next;
  }
 return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xbeed5
movq -0x28(%rbp), %rdi
callq 0x43530
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xbebf0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x46992(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x500d0
cmpl -0x18(%rbp), %eax
je 0xbeec7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xbee7f
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/softtree.c
// Function: error_of_soft_tree
int error_of_soft_tree(Decisionnodeptr rootnode, Instanceptr list)
{
 int count = 0, classno;
 double o;
 Instanceptr inst = list;
 while (inst)
  {
   classno = give_classno(inst);
   o = sigmoid(soft_tree_output(rootnode, inst));
   if ((o > 0.5 && classno == 0) || (o < 0.5 && classno == 1))
     count++;
   inst = inst->next;
  }
 return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xbef6e
movq -0x28(%rbp), %rdi
callq 0x43530
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xbed30
callq 0x7aab0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x23a82(%rip), %xmm1    # 0xe29b8
ucomisd %xmm1, %xmm0
jbe 0xbef42
cmpl $0x0, -0x18(%rbp)
je 0xbef57
movsd 0x23a6e(%rip), %xmm0    # 0xe29b8
ucomisd -0x20(%rbp), %xmm0
jbe 0xbef60
cmpl $0x1, -0x18(%rbp)
jne 0xbef60
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xbeeff
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/softtree.c
// Function: free_soft_tree_ws
void free_soft_tree_ws(Decisionnodeptr node)
{
 matrix_free(node->w);
 if (node->leaftype != CONSTANTLEAF)
  {
   matrix_free(node->left->w);
   matrix_free(node->right->w);
  } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x59ea0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0xbfc40
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x59ea0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x59ea0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/softtree.c
// Function: copy_soft_tree_ws
void copy_soft_tree_ws(Decisionnodeptr dest, Decisionnodeptr src)
{
 dest->w = matrix_copy(src->w);
 if (src->leaftype == CONSTANTLEAF)
  {
   dest->left->w0 = src->left->w0;
   dest->right->w0 = src->right->w0;
  }
 else
  {
   dest->left->w = matrix_copy(src->left->w);
   dest->right->w = matrix_copy(src->right->w);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x58550
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0xbfd86
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsd 0x48(%rax), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd %xmm0, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsd 0x48(%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsd %xmm0, 0x48(%rax)
jmp 0xbfe04
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x58550
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x58550
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x40(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/softtree.c
// Function: soft_tree_dimension_reduction
void soft_tree_dimension_reduction(Decisionnodeptr node, char st[READLINELENGTH], int level)
{
 int i, count;
	if (node->featureno != LEAF_NODE)
	 {
   count = 0;
   for (i = 0; i < current_dataset->multifeaturecount; i++)
     if (node->w.values[i][0] != 0)
       count++;
   sprintf(st,"%s%d-%d;", st, level, count);
   soft_tree_dimension_reduction(node->left, st, level + 1);
   soft_tree_dimension_reduction(node->right, st, level + 1);
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
je 0xc0735
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
leaq 0x45197(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x1c0(%rcx), %eax
jge 0xc06eb
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xc06d5
jp 0xc06d5
jmp 0xc06de
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc06e0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc069f
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl -0x1c(%rbp), %r8d
leaq 0x26df0(%rip), %rsi     # 0xe74f1
movb $0x0, %al
callq 0x4170
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0xc0670
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0xc0670
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/softtree.c
// Function: create_softtree_K_class
int create_softtree_K_class(Decisionnodeptr rootnode, Decisionnodeptr node, Instanceptr cvdata, Softregtree_parameterptr param)
{
 if (node != rootnode)
   node->instances = NULL;
 if (find_best_soft_tree_split_K_class(rootnode, node, cvdata, param))
  {
   create_softtree_K_class(rootnode, node->left, cvdata, param);
   create_softtree_K_class(rootnode, node->right, cvdata, param);
  }
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0xc076e
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xbfe10
cmpl $0x0, %eax
je 0xc07b9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xc0740
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xc0740
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/softtree.c
// Function: create_softtree
int create_softtree(Decisionnodeptr rootnode, Decisionnodeptr node, Instanceptr cvdata, Softregtree_parameterptr param)
{
 if (node != rootnode)
   node->instances = NULL;
 if (find_best_soft_tree_split(rootnode, node, cvdata, param))
  {
   create_softtree(rootnode, node->left, cvdata, param);
   create_softtree(rootnode, node->right, cvdata, param);
  }
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0xc07fe
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xc01f0
cmpl $0x0, %eax
je 0xc0849
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xc07d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xc07d0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/srm.c
// Function: vc_bound
double vc_bound(double rho)
{
 /*!Last Changed 11.03.2006*/
 double val1, val2, val3;
 if (rho < 0.5)
   return 1;
 val1 = log(2 * rho) + 1;
 val2 = rho - VC_K;
 val3 = val1 / val2;
 return VC_A * val3 * (sqrt(1 + VC_B / val3) + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x10(%rbp)
movsd 0x22143(%rip), %xmm0    # 0xe29b8
ucomisd -0x10(%rbp), %xmm0
jbe 0xc088e
movsd 0x21794(%rip), %xmm0    # 0xe2018
movsd %xmm0, -0x8(%rbp)
jmp 0xc0923
movsd 0x2240a(%rip), %xmm0    # 0xe2ca0
mulsd -0x10(%rbp), %xmm0
callq 0x4120
movsd 0x21770(%rip), %xmm1    # 0xe2018
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x2d20a(%rip), %xmm1    # 0xedac8
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x2d1e2(%rip), %xmm0    # 0xedac0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x2d1c8(%rip), %xmm1    # 0xedab8
divsd -0x28(%rbp), %xmm1
movsd 0x2171b(%rip), %xmm0    # 0xe2018
addsd %xmm1, %xmm0
callq 0x42a0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
movsd 0x21702(%rip), %xmm2    # 0xe2018
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/srm.c
// Function: solve_vc_bound_equation
double solve_vc_bound_equation(double epsilon)
{
 /*!Last Changed 11.03.2006*/
 double start = 0.5, end = 30, middle = 0, lastmiddle, val;
 if (epsilon > 1)
   return 0.5;
 while (epsilon < vc_bound(end))
   end *= 10;
 do
  {
   lastmiddle = middle;
   middle = (start + end) / 2; 
   val = vc_bound(middle);
   if (val > epsilon)
     start = middle;
   else
     end = middle;
  }while (fabs(middle - lastmiddle) > DBL_DELTA);
 return middle;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x10(%rbp)
movsd 0x22073(%rip), %xmm0    # 0xe29b8
movsd %xmm0, -0x18(%rbp)
movsd 0x23fee(%rip), %xmm0    # 0xe4940
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x216ac(%rip), %xmm1    # 0xe2018
ucomisd %xmm1, %xmm0
jbe 0xc0984
movsd 0x2203e(%rip), %xmm0    # 0xe29b8
movsd %xmm0, -0x8(%rbp)
jmp 0xc0a40
jmp 0xc0986
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0xc0860
movsd -0x40(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xc09b9
movsd 0x23f9b(%rip), %xmm0    # 0xe4948
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0xc0986
jmp 0xc09bb
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd 0x222c9(%rip), %xmm1    # 0xe2ca0
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0xc0860
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0xc0a07
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xc0a11
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0xc0a13
movsd -0x28(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movaps 0x2243c(%rip), %xmm1    # 0xe2e60
pand %xmm1, %xmm0
movsd 0x22040(%rip), %xmm1    # 0xe2a70
ucomisd %xmm1, %xmm0
ja 0xc09bb
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/srm.c
// Function: create_epsilon_estimate
Epsilonestimateptr create_epsilon_estimate(double epsilon)
{
 /*!Last Changed 06.04.2006*/
 Epsilonestimateptr newepsilonestimate;
 newepsilonestimate = safemalloc(sizeof(Epsilonestimate), "create_epsilon_estimate", 2);
 newepsilonestimate->epsilon = epsilon;
 newepsilonestimate->next = NULL;
 return newepsilonestimate;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
movl $0x10, %edi
leaq 0x2d067(%rip), %rsi     # 0xedad0
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/srm.c
// Function: create_vc_estimate
Vcestimateptr create_vc_estimate(int n, Epsilonestimateptr epsilonptr)
{
 /*!Last Changed 06.04.2006*/
 Vcestimateptr newvcestimate;
 newvcestimate = safemalloc(sizeof(Vcestimate), "create_vc_estimate", 2);
 newvcestimate->n = n;
 newvcestimate->next = NULL;
 newvcestimate->before = NULL;
 newvcestimate->epsilonestimates = epsilonptr;
 newvcestimate->count = 1;
 return newvcestimate;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x30, %edi
leaq 0x2d02d(%rip), %rsi     # 0xedae8
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/srm.c
// Function: deallocate_epsilon_estimates
void deallocate_epsilon_estimates(Epsilonestimateptr header)
{
 /*!Last Changed 01.04.2006*/
 Epsilonestimateptr tmp, next;
 tmp = header;
 while (tmp)
  {
   next = tmp->next;
   safe_free(tmp);
   tmp = next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc0b4a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x52e80
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xc0b24
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/srm.c
// Function: deallocate_vc_estimates
void deallocate_vc_estimates(Vcestimateptr header)
{
 /*!Last Changed 01.04.2006*/
 Vcestimateptr tmp, next;
 tmp = header;
 while (tmp)
  {
   next = tmp->next;
   deallocate_epsilon_estimates(tmp->epsilonestimates);
   safe_free(tmp);
   tmp = next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc0b97
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xc0b10
movq -0x10(%rbp), %rdi
callq 0x52e80
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xc0b64
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/srm.c
// Function: add_single_epsilon_estimate
void add_single_epsilon_estimate(Vcestimateptr* header, int n, double epsilon)
{
 /*!Last Changed 01.04.2006*/
 Vcestimateptr newvcestimate, tmpvc;
 Epsilonestimateptr newepsilonestimate;
 newepsilonestimate = create_epsilon_estimate(epsilon);
 tmpvc = *header;
 /* Finds the design point*/
 while (tmpvc && tmpvc->n != n)
   tmpvc = tmpvc->next;
 /*If there is a design point with the given sample size*/
 if (tmpvc)
  {
   newepsilonestimate->next = tmpvc->epsilonestimates;
   tmpvc->epsilonestimates = newepsilonestimate;
   (tmpvc->count)++;
  }
 /* If not, generate a new design point*/
 else
  {
   newvcestimate = create_vc_estimate(n, newepsilonestimate);
   if (*header)
    {
     newvcestimate->next = *header;
     (*header)->before = newvcestimate;
    }
   *header = newvcestimate;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0xc0a50
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
je 0xc0be8
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xc0bf1
jmp 0xc0bff
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xc0bcd
cmpq $0x0, -0x28(%rbp)
je 0xc0c31
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0xc0c74
movl -0xc(%rbp), %edi
movq -0x30(%rbp), %rsi
callq 0xc0aa0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc0c69
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/srm.c
// Function: number_of_experiments
int number_of_experiments(Vcestimateptr estimates)
{
 /*!Last Changed 01.04.2006*/
 Vcestimateptr tmpvc = estimates;
 int total = 0;
 while (tmpvc)
  {
   total += tmpvc->count;
   tmpvc = tmpvc->next;
  }
 return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc0cb9
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xc0c97
movl -0x14(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/srm.c
// Function: mse_fitting_for_vc_dimension
double mse_fitting_for_vc_dimension(Vcestimateptr estimates, double vcdimension, int n)
{
 /*!Last Changed 01.04.2006*/
 Vcestimateptr tmpvc = estimates;
 Epsilonestimateptr tmpepsilon;
 int count = 0;
 double mse = 0, add;
 while (tmpvc)
  {
   if (tmpvc->n != n)
    {
     tmpepsilon = tmpvc->epsilonestimates;
     while (tmpepsilon)
      {
       add = tmpepsilon->epsilon - vc_bound(tmpvc->n / vcdimension);
       mse += add * add;
       count++;
       tmpepsilon = tmpepsilon->next;
      }
    }
   tmpvc = tmpvc->next;
  }
 return mse / count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xc11ba
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
je 0xc11a9
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xc11a7
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x20(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
divsd -0x10(%rbp), %xmm0
callq 0xc0860
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x40(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xc113d
jmp 0xc11a9
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xc111b
movsd -0x38(%rbp), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
divsd %xmm1, %xmm0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/srm.c
// Function: vc_estimate_uniform_of_decision_tree
void vc_estimate_uniform_of_decision_tree(int featurecount, int nodecount, int experimentcount, char* featuretypes, int* featurevaluecounts)
{
 /*!Last Changed 24.09.2006 added different feature types*/
 /*!Last Changed 03.05.2006 run for a specific featurecount and nodecount*/
 /*!Last Changed 01.04.2006*/
 /*!Last Changed 11.03.2006*/
 void* parameters;
 double vcdimension, averagecount;
 Vcestimateptr estimates;
 parameters = prepare_supervised_algorithm_parameters(NBTREE);
 ((Nodeboundedtree_parameterptr) parameters)->prunetype = NOPRUNING;
 if (featurevaluecounts[0] > 1)
   ((Nodeboundedtree_parameterptr) parameters)->usediscrete = BOOLEAN_TRUE;
 else
   ((Nodeboundedtree_parameterptr) parameters)->usediscrete = BOOLEAN_FALSE;
 current_dataset = generate_random_dataset("VC-Estimate", featurecount, featuretypes, featurevaluecounts, 2);
 averagecount = average_valuecount(current_dataset);
 estimates = vc_estimates_for_a_design(parameters, nodecount, current_dataset, experimentcount, averagecount);
 vcdimension = vc_dimension_for_a_design(estimates, UNIFORM_DESIGN, -1);
 set_default_variable("out1", vcdimension);
 deallocate_vc_estimates(estimates);
 free_dataset(current_dataset);
 free_supervised_algorithm_parameters(NBTREE, parameters);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl $0x3fd, %edi            # imm = 0x3FD
callq 0x7410
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x3, 0x14(%rax)
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jle 0xc15a8
movq -0x28(%rbp), %rax
movl $0x1, 0xc(%rax)
jmp 0xc15b3
movq -0x28(%rbp), %rax
movl $0x0, 0xc(%rax)
movl -0x4(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x2c564(%rip), %rdi     # 0xedb29
movl $0x2, %r8d
callq 0x1e750
movq %rax, %rcx
leaq 0x44266(%rip), %rax     # 0x105840
movq %rcx, (%rax)
leaq 0x4425c(%rip), %rax     # 0x105840
movq (%rax), %rdi
callq 0x1dbf0
movsd %xmm0, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movl -0x8(%rbp), %esi
leaq 0x44241(%rip), %rax     # 0x105840
movq (%rax), %rdx
movl -0xc(%rbp), %ecx
movsd -0x38(%rbp), %xmm0
callq 0xc13d0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xc0cc0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
leaq 0x24554(%rip), %rdi     # 0xe5b88
callq 0x4b070
movq -0x40(%rbp), %rdi
callq 0xc0b50
leaq 0x441f7(%rip), %rax     # 0x105840
movq (%rax), %rdi
callq 0x1b710
movq -0x28(%rbp), %rsi
movl $0x3fd, %edi            # imm = 0x3FD
callq 0x5a00
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/srm.c
// Function: is_featurelist_valid
BOOLEAN is_featurelist_valid(int* featurelist, int* ruleset, int rulecount)
{
 /*!Last Changed 21.02.2008*/
 int i, j = 0, k, available[10], fno;
 for (i = 0; i < rulecount; i++)
  {
   if (ruleset[i] > 1)
    {
     for (k = 0; k < ruleset[i]; k++)
       available[k] = BOOLEAN_FALSE;
     for (k = 0; k < ruleset[i]; k++)
      {
       fno = featurelist[j + k] / 10;
       if (available[fno])
         return BOOLEAN_FALSE;
       available[fno] = BOOLEAN_TRUE;
      }
    }
   j += ruleset[i];
  }
 return BOOLEAN_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xc1d87
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jle 0xc1d68
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xc1d09
movslq -0x28(%rbp), %rax
movl $0x0, -0x50(%rbp,%rax,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xc1ce2
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xc1d66
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x54(%rbp)
movslq -0x54(%rbp), %rax
cmpl $0x0, -0x50(%rbp,%rax,4)
je 0xc1d4f
movl $0x0, -0x4(%rbp)
jmp 0xc1d8e
movslq -0x54(%rbp), %rax
movl $0x1, -0x50(%rbp,%rax,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xc1d10
jmp 0xc1d68
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xc1cbd
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: gaussian_vector
double gaussian_vector(Instanceptr x, Instanceptr mean, double stdev)
{
 /*Last Changed 11.07.2006 if stdev = 0 returns 0*/
 int i;
 double sum = 0, x_i, m_i;
 if (stdev == 0)
   return 0;
 for (i = 0; i < current_dataset->multifeaturecount - 1; i++)
  {
   x_i = real_feature(x, i);
   m_i = real_feature(mean, i);
   sum += (x_i - m_i) * (x_i - m_i);
  }
 return (1 / (stdev * sqrt(2 * PI))) * safeexp(-sum / (2 * stdev * stdev));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xc23ca
jp 0xc23ca
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xc24b7
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
leaq 0x43465(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
movl 0x1c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xc243e
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x42c40
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x42c40
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
subsd -0x40(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
subsd -0x40(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc23d1
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd 0x25260(%rip), %xmm0    # 0xe76b0
callq 0x42a0
movsd -0x50(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x1fbb2(%rip), %xmm0    # 0xe2018
divsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x30(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x2080d(%rip), %xmm1    # 0xe2ca0
mulsd -0x20(%rbp), %xmm1
mulsd -0x20(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0x52a40
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)