LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: gaussian_multivariate
double gaussian_multivariate(Instanceptr inst, double* mean, matrix covariance)
{
 /*!Last Changed 12.01.2009 added mahalanobis_distance*/
 /*!Last Changed 25.02.2007*/
 matrix x, mu;
 double det, result;
 int d = current_dataset->multifeaturecount - 1;
 det = matrix_determinant(covariance);
 if (dequal(det, 0.0))
   return 0.0;
 x = instance_to_matrix(inst);
 /*Prepare mean matrix*/
 mu = matrix_alloc(1, x.col);
 memcpy(mu.values[0], mean, x.col * sizeof(double));
 result = (1 / sqrt(pow(2 * PI, d) * det)) * safeexp(-mahalanobis_distance(x, mu, covariance) / 2);
 matrix_free(x);
 matrix_free(mu);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
leaq 0x4334e(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %eax
subl $0x1, %eax
movl %eax, -0x5c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5c130
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0x526b0
cmpl $0x0, %eax
je 0xc2532
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xc2640
movq -0x20(%rbp), %rdi
callq 0x43160
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %esi
movl $0x1, %edi
callq 0x57fc0
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movslq -0x34(%rbp), %rdx
shlq $0x3, %rdx
callq 0x42b0
cvtsi2sdl -0x5c(%rbp), %xmm1
movsd 0x25113(%rip), %xmm0    # 0xe76b0
callq 0x4290
mulsd -0x50(%rbp), %xmm0
callq 0x42a0
movaps %xmm0, %xmm1
movsd 0x1fa61(%rip), %xmm0    # 0xe2018
divsd %xmm1, %xmm0
movsd %xmm0, -0x88(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x10(%rbp), %r9
callq 0x5c2f0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x206a1(%rip), %xmm1    # 0xe2ca0
divsd %xmm1, %xmm0
callq 0x52a40
movaps %xmm0, %xmm1
movsd -0x88(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x59ea0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x59ea0
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: produce_distribution
void produce_distribution(double probability, int howmany, int samplesize, char *f_name)
{
 /*Last Changed 23.04.2001*/
 FILE *myfile;
 int i, j, k;
 char pst[READLINELENGTH];
 if ((myfile = fopen(f_name, "w")) == NULL)
  {
   printf(m1314, f_name);
   return;
  }
 for (i = 0; i < howmany; i++)
  {
   k = 0;
   for (j = 0; j < samplesize; j++)
     if (produce_random_value(0, 1) < probability)
       k++;
   set_precision(pst, NULL, "\n");
   fprintf(myfile, pst, k / (samplesize + 0.0));
  }
 fclose(myfile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a150, %rsp          # imm = 0x7A150
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x25a99(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xc274b
movq -0x18(%rbp), %rsi
leaq 0x2b631(%rip), %rdi     # 0xedd70
movb $0x0, %al
callq 0x4030
jmp 0xc27fd
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xc27f4
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xc27a8
xorps %xmm0, %xmm0
movsd 0x1f899(%rip), %xmm1    # 0xe2018
callq 0x545a0
movaps %xmm0, %xmm1
movsd -0x8(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xc279b
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc279d
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xc276c
leaq -0x7a150(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x23581(%rip), %rdx     # 0xe5d3b
callq 0x53310
movq -0x20(%rbp), %rdi
leaq -0x7a150(%rbp), %rsi
cvtsi2sdl -0x2c(%rbp), %xmm0
cvtsi2sdl -0x10(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movb $0x1, %al
callq 0x4280
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc2752
movq -0x20(%rbp), %rdi
callq 0x4250
addq $0x7a150, %rsp          # imm = 0x7A150
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: file_mean
double file_mean(char **files,int filecount)
{
/*Last Changed 26.04.2002*/
 FILE *myfile;
 double sum=0,temp;
 int counts,i,total=0,j;
 for (i=0;i<filecount;i++)
  {
   counts=file_length(files[i]);
   if ((myfile=fopen(files[i],"r"))==NULL)
    {
     printf(m1274, files[i]);
     return 0;
    }
   for (j=0;j<counts;j++)
    {
     fscanf(myfile,"%lf",&temp);
     sum+=temp;
    }
   total+=counts;
   fclose(myfile);
  }
 return sum/total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xc305a
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x50f90
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x251de(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xc2ffb
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x1fea0(%rip), %rdi     # 0xe2e8a
movb $0x0, %al
callq 0x4030
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xc306d
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xc303a
movq -0x20(%rbp), %rdi
leaq 0x237b3(%rip), %rsi     # 0xe67c8
leaq -0x30(%rbp), %rdx
movb $0x0, %al
callq 0x4070
movsd -0x30(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xc3002
movl -0x34(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4250
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xc2f95
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x3c(%rbp), %xmm1
divsd %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/statistics.c
// Function: no_correction
void no_correction(Comparisonptr comparisons, int compcount, double confidence)
{
 /*Last Changed 14.05.2005*/
 int i;
 for (i = 0; i < compcount; i++)
   if (comparisons[i].confidence < confidence)
     comparisons[i].accepted = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xc30e1
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xc30d4
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x10(%rax)
jmp 0xc30d6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc3097
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: bonferroni_correction
void bonferroni_correction(Comparisonptr comparisons, int compcount, double confidence)
{
 /*Last Changed 18.11.2004*/
 int i;
 double corrected = confidence / compcount;
 for (i = 0; i < compcount; i++)
   if (comparisons[i].confidence < corrected)
     comparisons[i].accepted = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xc3164
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xc3157
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x10(%rax)
jmp 0xc3159
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc311a
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: holm_correction
void holm_correction(Comparisonptr comparisons, int compcount, double confidence)
{
 /*Last Changed 18.11.2004*/
 int i, j;
 double corrected;
 Comparison tmp;
 for (i = 0; i < compcount; i++)
   for (j = i + 1; j < compcount; j++)
     if (comparisons[i].confidence > comparisons[j].confidence)
      {
       tmp = comparisons[i];
       comparisons[i] = comparisons[j];
       comparisons[j] = tmp;
      }
 i = 0;
 corrected = confidence / (compcount - i);
 while (i < compcount && comparisons[i].confidence < corrected)
  {
   comparisons[i].accepted = 0;
   i++;
   corrected = confidence / (compcount - i);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xc3276
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xc3266
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
ucomisd 0x8(%rax), %xmm0
jbe 0xc3256
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movslq -0x20(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0xc3258
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xc319c
jmp 0xc3268
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc3187
movl $0x0, -0x1c(%rbp)
movsd -0x18(%rbp), %xmm0
movl -0xc(%rbp), %eax
subl -0x1c(%rbp), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x41(%rbp)
jge 0xc32c5
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
seta %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xc32ce
jmp 0xc3307
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x10(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movsd -0x18(%rbp), %xmm0
movl -0xc(%rbp), %eax
subl -0x1c(%rbp), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0xc3295
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: generate_tests
int generate_tests(char **files, int filecount)
{
 int *counts, **subsets, res, i, j;
 FILE *myfile;
 if (filecount < 2)
   return 0;
 myfile = fopen(files[0], "w");
 if (!myfile)
   return -1;
 subsets = generate_subsets(filecount - 1, &res, &counts);
 for (i = 0; i < res; i++)
   if (counts[i] > 1)
    {
     fprintf(myfile, "multitest ");
     for (j = 0; j < counts[i]; j++)
       fprintf(myfile, "%s ", files[subsets[i][j] + 1]);
     fprintf(myfile, "\n");
    }
 for (i = 0; i < res; i++)
   if (counts[i] > 0)
     safe_free(subsets[i]);
 safe_free(subsets);
 safe_free(counts);
 fclose(myfile);
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0xc3331
movl $0x0, -0x4(%rbp)
jmp 0xc3479
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x24e7f(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xc335b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc3479
movl -0x14(%rbp), %edi
subl $0x1, %edi
leaq -0x2c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x52000
movq %rax, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0xc341c
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jle 0xc340c
movq -0x40(%rbp), %rdi
leaq 0x2aa42(%rip), %rsi     # 0xedde0
movb $0x0, %al
callq 0x4280
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x20(%rbp), %rcx
movslq -0x30(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xc33fa
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x34(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x2a0d3(%rip), %rsi     # 0xed4bb
movb $0x0, %al
callq 0x4280
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xc33ac
movq -0x40(%rbp), %rdi
leaq 0x22936(%rip), %rsi     # 0xe5d3b
movb $0x0, %al
callq 0x4280
jmp 0xc340e
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xc3379
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0xc3457
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0xc344a
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x52e80
jmp 0xc344c
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xc3423
movq -0x28(%rbp), %rdi
callq 0x52e80
movq -0x20(%rbp), %rdi
callq 0x52e80
movq -0x40(%rbp), %rdi
callq 0x4250
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: file_whiskers
void file_whiskers(char* file, double p25, double p75, double* swhisker, double* lwhisker)
{
 /*Last Changed 29.01.2007*/
 FILE* myfile;
 int count, i;
 double lowerbound, upperbound, smallest, largest, observation;
 smallest = p25;
 largest = p75;
 lowerbound = p25 - (p75 - p25) * 1.5;
 upperbound = p75 + (p75 - p25) * 1.5;
 count = file_length(file);
 if ((myfile = fopen(file, "r")) == NULL)
  {
   printf(m1274, file);
   return;
  }
 for (i = 0; i < count; i++)
  {
   fscanf(myfile, "%lf", &observation);
   if (observation <= smallest && observation >= lowerbound)
     smallest = observation;
   if (observation >= largest && observation <= upperbound)
     largest = observation;
  } 
 *swhisker = smallest;
 *lwhisker = largest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x1e9d8(%rip), %xmm2    # 0xe2a78
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x18(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd 0x1e9b4(%rip), %xmm2    # 0xe2a78
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x50f90
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x240be(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xc410e
movq -0x8(%rbp), %rsi
leaq 0x1ed88(%rip), %rdi     # 0xe2e8a
movb $0x0, %al
callq 0x4030
jmp 0xc41a6
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xc418c
movq -0x30(%rbp), %rdi
leaq 0x226a0(%rip), %rsi     # 0xe67c8
leaq -0x60(%rbp), %rdx
movb $0x0, %al
callq 0x4070
movsd -0x60(%rbp), %xmm1
movsd -0x50(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0xc4159
movsd -0x60(%rbp), %xmm0
ucomisd -0x40(%rbp), %xmm0
jb 0xc4159
movsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x60(%rbp), %xmm0
ucomisd -0x58(%rbp), %xmm0
jb 0xc417f
movsd -0x60(%rbp), %xmm1
movsd -0x48(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0xc417f
movsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
jmp 0xc4181
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xc4115
movsd -0x50(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x58(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: file_variance
double file_variance(char **files,int filecount)
{
/*Last Changed 27.04.2002*/
 FILE *myfile;
 double mean = file_mean(files, filecount), sum = 0, temp;
 int counts,i,total=0,j;
 for (i=0;i<filecount;i++)
  {
   counts = file_length(files[i]);
   if ((myfile = fopen(files[i],"r")) == NULL)
    {
     printf(m1274, files[i]);
     return 0;
    }
   for (j=0;j<counts;j++)
    {
     fscanf(myfile,"%lf",&temp);
     sum+=(temp-mean)*(temp-mean);
    }
   total+=counts;
   fclose(myfile);
  }
 return sqrt(sum/(total-1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xc2f70
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xc45c5
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x50f90
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x23c8d(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xc454f
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x1e94f(%rip), %rdi     # 0xe2e8a
movb $0x0, %al
callq 0x4030
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xc45e2
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0xc45a5
movq -0x20(%rbp), %rdi
leaq 0x2225f(%rip), %rsi     # 0xe67c8
leaq -0x38(%rbp), %rdx
movb $0x0, %al
callq 0x4070
movsd -0x38(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
subsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xc4556
movl -0x3c(%rbp), %eax
addl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4250
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xc44e6
movsd -0x30(%rbp), %xmm0
movl -0x44(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
callq 0x42a0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: generate_statistical_data
void generate_statistical_data(char* filename, int datacount, int zeroonecount, double errorrate)
{
 FILE* myfile;
 int i, j, zeros, x;
 char pst[READLINELENGTH];
 myfile = fopen(filename,"w");
 if (!myfile)
   return;
 for (i = 0; i<datacount; i++)
  {
   zeros = 0;
   for (j = 0; j<zeroonecount; j++)
    {
     x = myrand()*myrand();
     if (((x%10000)/10000.0)<errorrate)
       zeros++;
    }
   set_precision(pst, NULL, "\n");
   fprintf(myfile, pst, zeros / (zeroonecount + 0.0));
  }
 fclose(myfile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a160, %rsp          # imm = 0x7A160
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x23ba9(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc462a
jmp 0xc4706
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xc46fd
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xc46b1
movb $0x0, %al
callq 0x54550
movl %eax, -0x7a154(%rbp)
movb $0x0, %al
callq 0x54550
movl %eax, %ecx
movl -0x7a154(%rbp), %eax
imull %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl $0x2710, %ecx           # imm = 0x2710
cltd
idivl %ecx
cvtsi2sd %edx, %xmm1
movsd 0x220a4(%rip), %xmm0    # 0xe6730
divsd %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xc46a4
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc46a6
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xc464b
leaq -0x7a150(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x21678(%rip), %rdx     # 0xe5d3b
callq 0x53310
movq -0x20(%rbp), %rdi
leaq -0x7a150(%rbp), %rsi
cvtsi2sdl -0x2c(%rbp), %xmm0
cvtsi2sdl -0x10(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movb $0x1, %al
callq 0x4280
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc4631
movq -0x20(%rbp), %rdi
callq 0x4250
addq $0x7a160, %rsp          # imm = 0x7A160
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: produce_normal_value
double produce_normal_value(double mean, double stdev)
{
 /*Last Changed 08.04.2004*/
 int i;
 double x = 0;
 for (i = 0; i < 12; i++)
   x += produce_random_value(0, 1);
 x -= 6;
 return mean + x * stdev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xc, -0x14(%rbp)
jge 0xc475c
xorps %xmm0, %xmm0
movsd 0x1d8d6(%rip), %xmm1    # 0xe2018
callq 0x545a0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc4731
movsd -0x20(%rbp), %xmm0
movsd 0x200ff(%rip), %xmm1    # 0xe4868
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: produce_normal_distribution
void produce_normal_distribution(char* filename, int N, double mean, double stdev)
{
 /*Last Changed 08.04.2004*/
 FILE* myfile;
 int i;
 char pst[READLINELENGTH];
 myfile = fopen(filename, "w");
 if (!myfile)
   return;
 for (i = 0; i < N; i++)
  {
   set_precision(pst, NULL, "\n");
   fprintf(myfile, pst, produce_normal_value(mean, stdev));
  }
 fclose(myfile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a160, %rsp          # imm = 0x7A160
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x23a07(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xc47c9
jmp 0xc4840
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xc4837
leaq -0x7a150(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x21551(%rip), %rdx     # 0xe5d3b
callq 0x53310
movq -0x28(%rbp), %rax
movq %rax, -0x7a160(%rbp)
leaq -0x7a150(%rbp), %rax
movq %rax, -0x7a158(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0xc4710
movq -0x7a160(%rbp), %rdi
movq -0x7a158(%rbp), %rsi
movb $0x1, %al
callq 0x4280
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc47d0
movq -0x28(%rbp), %rdi
callq 0x4250
addq $0x7a160, %rsp          # imm = 0x7A160
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: bootstrap
void bootstrap(char* infile, char* outfile)
{
 /*Last Changed 08.04.2004*/
 FILE* inputfile, *outputfile;
 double *input;
 char pst[READLINELENGTH];
 int len = file_length(infile), i, index;
 inputfile = fopen(infile, "r");
 if (!inputfile)
   return;
 input = safemalloc(len * sizeof(double), "bootstrap", 5);
 for (i = 0; i < len; i++)
   fscanf(inputfile, "%lf", &(input[i]));
 fclose(inputfile);
 outputfile = fopen(outfile, "w");
 if (!outputfile)
   return;
 for (i = 0; i < len; i++)
  {
   index = myrand() % len;
   set_precision(pst, NULL, "\n");
   fprintf(outputfile, pst, input[index]);
  }
 fclose(outputfile);
 safe_free(input);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a160, %rsp          # imm = 0x7A160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x50f90
movl %eax, -0x7a154(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x23929(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc4892
jmp 0xc49b0
movslq -0x7a154(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x23ca2(%rip), %rsi     # 0xe8546
movl $0x5, %edx
callq 0x52d70
movq %rax, -0x28(%rbp)
movl $0x0, -0x7a158(%rbp)
movl -0x7a158(%rbp), %eax
cmpl -0x7a154(%rbp), %eax
jge 0xc48ff
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
movslq -0x7a158(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x21ee1(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
movl -0x7a158(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7a158(%rbp)
jmp 0xc48bc
movq -0x18(%rbp), %rdi
callq 0x4250
movq -0x10(%rbp), %rdi
leaq 0x238ab(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc4928
jmp 0xc49b0
movl $0x0, -0x7a158(%rbp)
movl -0x7a158(%rbp), %eax
cmpl -0x7a154(%rbp), %eax
jge 0xc499e
movb $0x0, %al
callq 0x54550
cltd
idivl -0x7a154(%rbp)
movl %edx, -0x7a15c(%rbp)
leaq -0x7a150(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x213d5(%rip), %rdx     # 0xe5d3b
callq 0x53310
movq -0x20(%rbp), %rdi
leaq -0x7a150(%rbp), %rsi
movq -0x28(%rbp), %rax
movslq -0x7a15c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movb $0x1, %al
callq 0x4280
movl -0x7a158(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7a158(%rbp)
jmp 0xc4932
movq -0x20(%rbp), %rdi
callq 0x4250
movq -0x28(%rbp), %rdi
callq 0x52e80
addq $0x7a160, %rsp          # imm = 0x7A160
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: multiple_tests
void multiple_tests(double (*algorithm)(char** files), char** params, int paramcount)
{
/*Last Changed 30.04.2002*/
 double tmp;
 if (paramcount > 0)
   if (paramcount > 1)
    {
     tmp = algorithm(params);
     set_default_variable("out2",tmp);
     if (tmp >= 1 - get_parameter_f("confidencelevel"))
      {
       if (get_parameter_o("displayresulton"))
         printf(m1033);
       set_default_variable("out1",1.0);
      }
     else
      {
       if (get_parameter_o("displayresulton"))
         printf(m1034);
       set_default_variable("out1",0.0);
      }
    }
   else
     printf(m1035);
 else
   printf(m1036);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0xc4aac
cmpl $0x1, -0x14(%rbp)
jle 0xc4a9c
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
leaq 0x2118c(%rip), %rdi     # 0xe5b8e
callq 0x4b070
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
leaq 0x1dc85(%rip), %rdi     # 0xe269d
callq 0x79040
movaps %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
movsd 0x1d5eb(%rip), %xmm1    # 0xe2018
subsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0xc4a6c
leaq 0x1e82d(%rip), %rdi     # 0xe326b
callq 0x79440
cmpl $0x0, %eax
je 0xc4a56
leaq 0x293f8(%rip), %rdi     # 0xede47
movb $0x0, %al
callq 0x4030
leaq 0x2112b(%rip), %rdi     # 0xe5b88
movsd 0x1d5b3(%rip), %xmm0    # 0xe2018
callq 0x4b070
jmp 0xc4a9a
leaq 0x1e7f8(%rip), %rdi     # 0xe326b
callq 0x79440
cmpl $0x0, %eax
je 0xc4a8b
leaq 0x293e7(%rip), %rdi     # 0xede6b
movb $0x0, %al
callq 0x4030
leaq 0x210f6(%rip), %rdi     # 0xe5b88
xorps %xmm0, %xmm0
callq 0x4b070
jmp 0xc4aaa
leaq 0x24262(%rip), %rdi     # 0xe8d05
movb $0x0, %al
callq 0x4030
jmp 0xc4aba
leaq 0x263fc(%rip), %rdi     # 0xeaeaf
movb $0x0, %al
callq 0x4030
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: binary_comparison
void binary_comparison(int (*algorithm)(char** files,int *which,double confidence,double *real_confidence), char** params, int paramcount)
{
 int who;
 double conf = 0.0;
 if (paramcount >= 2)
   if (!(algorithm(params, &who, 1 - get_parameter_f("confidencelevel"), &conf)))
    {
     if (get_parameter_o("displayresulton"))
      {
       if (get_parameter_i("tailed") == 2)
         printf(m1034);
       else
         printf(m1111);
      }
     set_default_variable("out1", 0.0);
    }
   else
    {
     if (who == 1)
      {
       if (get_parameter_o("displayresulton"))
         printf(m1045);
      }
     else
       if (get_parameter_o("displayresulton"))
         if (get_parameter_i("tailed") == 2)
           printf(m1046);
     if (get_parameter_i("tailed") == 1)      
       set_default_variable("out1", 1.0);
     else
       set_default_variable("out1", who + 0.0);
    }
 else
   printf(m1047);
 set_default_variable("out2", conf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
cmpl $0x2, -0x14(%rbp)
jl 0xc4c1b
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x1dba1(%rip), %rdi     # 0xe269d
callq 0x79040
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movaps %xmm0, %xmm1
movsd 0x1d504(%rip), %xmm0    # 0xe2018
subsd %xmm1, %xmm0
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq *%rax
cmpl $0x0, %eax
jne 0xc4b7d
leaq 0x1e73d(%rip), %rdi     # 0xe326b
callq 0x79440
cmpl $0x0, %eax
je 0xc4b69
leaq 0x24705(%rip), %rdi     # 0xe9244
callq 0x78f10
cmpl $0x2, %eax
jne 0xc4b59
leaq 0x2931b(%rip), %rdi     # 0xede6b
movb $0x0, %al
callq 0x4030
jmp 0xc4b67
leaq 0x29329(%rip), %rdi     # 0xede89
movb $0x0, %al
callq 0x4030
jmp 0xc4b69
leaq 0x21018(%rip), %rdi     # 0xe5b88
xorps %xmm0, %xmm0
callq 0x4b070
jmp 0xc4c19
cmpl $0x1, -0x18(%rbp)
jne 0xc4ba4
leaq 0x1e6e1(%rip), %rdi     # 0xe326b
callq 0x79440
cmpl $0x0, %eax
je 0xc4ba2
leaq 0x2933c(%rip), %rdi     # 0xeded7
movb $0x0, %al
callq 0x4030
jmp 0xc4bd8
leaq 0x1e6c0(%rip), %rdi     # 0xe326b
callq 0x79440
cmpl $0x0, %eax
je 0xc4bd6
leaq 0x24688(%rip), %rdi     # 0xe9244
callq 0x78f10
cmpl $0x2, %eax
jne 0xc4bd4
leaq 0x29333(%rip), %rdi     # 0xedf00
movb $0x0, %al
callq 0x4030
jmp 0xc4bd6
jmp 0xc4bd8
leaq 0x24665(%rip), %rdi     # 0xe9244
callq 0x78f10
cmpl $0x1, %eax
jne 0xc4bff
leaq 0x20f98(%rip), %rdi     # 0xe5b88
movsd 0x1d420(%rip), %xmm0    # 0xe2018
callq 0x4b070
jmp 0xc4c17
cvtsi2sdl -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
leaq 0x20f76(%rip), %rdi     # 0xe5b88
callq 0x4b070
jmp 0xc4c19
jmp 0xc4c29
leaq 0x29306(%rip), %rdi     # 0xedf28
movb $0x0, %al
callq 0x4030
movsd -0x20(%rbp), %xmm0
leaq 0x20f59(%rip), %rdi     # 0xe5b8e
callq 0x4b070
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: tpr_fpr_performance
Performance_point tpr_fpr_performance(int tp, int fp, int tn, int fn)
{
 Performance_point p;
 if (tn + fp != 0)
   p.x = (fp + 0.0) / (tn + fp + 0.0);
 else
   p.x = 0.0;
 if (tp + fn != 0)
   p.y = (tp + 0.0) / (tp + fn + 0.0);
 else
   p.y = 0.0;
 return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl %r8d, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl -0x8(%rbp), %eax
cmpl $0x0, %eax
je 0xc507f
movq -0x20(%rbp), %rax
cvtsi2sdl -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
movl -0xc(%rbp), %ecx
addl -0x8(%rbp), %ecx
cvtsi2sd %ecx, %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
jmp 0xc508a
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl -0x4(%rbp), %eax
addl -0x10(%rbp), %eax
cmpl $0x0, %eax
je 0xc50c1
movq -0x20(%rbp), %rax
cvtsi2sdl -0x4(%rbp), %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
movl -0x4(%rbp), %ecx
addl -0x10(%rbp), %ecx
cvtsi2sd %ecx, %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0xc50cd
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: precision_recall_performance
Performance_point precision_recall_performance(int tp, int fp, int tn, int fn)
{
 Performance_point p;
 if (tp + fn != 0)
   p.x = (tp + 0.0) / (tp + fn + 0.0);
 else
   p.x = 0.0;
 if (tp + fp != 0)
   p.y = (tp + 0.0) / (tp + fp + 0.0);
 else
   p.y = 1.0;
 return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl %r8d, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl -0x10(%rbp), %eax
cmpl $0x0, %eax
je 0xc512f
movq -0x20(%rbp), %rax
cvtsi2sdl -0x4(%rbp), %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
movl -0x4(%rbp), %ecx
addl -0x10(%rbp), %ecx
cvtsi2sd %ecx, %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
jmp 0xc513a
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
cmpl $0x0, %eax
je 0xc5171
movq -0x20(%rbp), %rax
cvtsi2sdl -0x4(%rbp), %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
movl -0x4(%rbp), %ecx
addl -0x8(%rbp), %ecx
cvtsi2sd %ecx, %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0xc5182
movq -0x20(%rbp), %rax
movsd 0x1ce9b(%rip), %xmm0    # 0xe2018
movsd %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: construct_posterior_matrix
matrix construct_posterior_matrix(double** posteriors, Instanceptr data)
{
 int i;
 matrix m;
 Instanceptr tmp = data;
 m = matrix_alloc(data_size(data), current_dataset->classno + 1);
 for (i = 0; i < m.row; i++)
  {
   memcpy(m.values[i], posteriors[i], current_dataset->classno * sizeof(double));
   m.values[i][current_dataset->classno] = give_classno(tmp);
   tmp = tmp->next;
  }
 return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x449f0
movl %eax, %edi
leaq 0x40686(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
addl $0x1, %esi
callq 0x57fc0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xc5261
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x40632(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdx
shlq $0x3, %rdx
callq 0x42b0
movq -0x30(%rbp), %rdi
callq 0x43530
cvtsi2sd %eax, %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
leaq 0x40602(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
movslq 0x10(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc51e7
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: find_area_under_the_curve_2class
double find_area_under_the_curve_2class(matrix posteriors, int posclass, int negclass, Performance_point (*calculate_performance)(int tp, int fp, int tn, int fn))
{
 int i, number_of_points;
 double area = 0.0;
 Performance_pointptr points;
 points = find_performance_points(posteriors, &number_of_points, posclass, negclass, calculate_performance);
 for (i = 0; i < number_of_points - 1; i++)
   area += (points[i].y + points[i + 1].y) * (points[i + 1].x - points[i].x) / 2;
 safe_free(points);
 return area;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movq -0x20(%rbp), %r9
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xc5270
movq %rax, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xc565a
movq -0x38(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq -0x38(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
addsd 0x8(%rax), %xmm0
movq -0x38(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm1
movq -0x38(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
subsd (%rax), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1d662(%rip), %xmm1    # 0xe2ca0
divsd %xmm1, %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc55c9
movq -0x38(%rbp), %rdi
callq 0x52e80
movsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: find_area_under_the_curve_kclass
double find_area_under_the_curve_kclass(matrix posteriors, Performance_point (*calculate_performance)(int tp, int fp, int tn, int fn))
{
 double sum = 0.0;
 int i, j;
 for (i = 0; i < current_dataset->classno; i++)
   for (j = i + 1; j < current_dataset->classno; j++)
     sum += find_area_under_the_curve_2class(posteriors, i, j, calculate_performance);
 return (2 * sum) / (current_dataset->classno * (current_dataset->classno - 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
leaq 0x401a3(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xc56f9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
leaq 0x40188(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xc56ec
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %r8
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xc5580
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xc56ae
jmp 0xc56ee
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc5693
movsd 0x1d59f(%rip), %xmm0    # 0xe2ca0
mulsd -0x20(%rbp), %xmm0
leaq 0x40133(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %eax
leaq 0x40126(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
imull %ecx, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: construct_confusion_matrix_from_posteriors
Confusion_matrix construct_confusion_matrix_from_posteriors(matrix posteriors, double decision_threshold)
{
 /*!Last Changed 17.01.2009*/
 int i;
 Confusion_matrix result = {0, 0, 0, 0};
 for (i = 0; i < posteriors.row; i++)
   if (posteriors.values[i][POSITIVE_CLASS] >= decision_threshold) /*positive class assigned*/
     if (posteriors.values[i][2] == POSITIVE_CLASS)
       result.true_positives++;
     else
       result.false_positives++;
   else /*negative class assigned*/
     if (posteriors.values[i][2] == NEGATIVE_CLASS)
       result.true_negatives++;
     else
       result.false_negatives++;
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x4050
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xc5808
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
ucomisd -0x28(%rbp), %xmm0
jb 0xc57c1
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd 0x10(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xc57b6
jp 0xc57b6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc57bf
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xc57f8
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd 0x10(%rax), %xmm0
movsd 0x1c83e(%rip), %xmm1    # 0xe2018
ucomisd %xmm1, %xmm0
jne 0xc57ed
jp 0xc57ed
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xc57f6
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xc57f8
jmp 0xc57fa
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc576c
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/statistics.c
// Function: construct_confusion_matrix_from_file
Confusion_matrixptr construct_confusion_matrix_from_file(char* posterior_file_name, double decision_threshold)
{
 /*!Last Changed 17.01.2009*/
 matrixptr posteriors;
 Confusion_matrixptr result;
 int i, numberofruns = get_parameter_i("runcount") * get_parameter_i("foldcount");
 result = safemalloc(numberofruns * sizeof(Confusion_matrix), "construct_confusion_matrix_from_file", 4);
 posteriors = read_posteriors(numberofruns, posterior_file_name);
 for (i = 0; i < numberofruns; i++)
  {
   result[i] = construct_confusion_matrix_from_posteriors(posteriors[i], decision_threshold);
   matrix_free(posteriors[i]);
  }
 safe_free(posteriors);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
leaq 0x21f25(%rip), %rdi     # 0xe775d
callq 0x78f10
movl %eax, -0x3c(%rbp)
leaq 0x21f1f(%rip), %rdi     # 0xe7766
callq 0x78f10
movl %eax, %ecx
movl -0x3c(%rbp), %eax
imull %ecx, %eax
movl %eax, -0x28(%rbp)
movslq -0x28(%rbp), %rdi
shlq $0x4, %rdi
leaq 0x286f7(%rip), %rsi     # 0xedf5d
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0xb2a0
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0xc590a
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd -0x10(%rbp), %xmm0
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0xc5740
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x59ea0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc588b
movq -0x18(%rbp), %rdi
callq 0x52e80
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/svm.c
// Function: free_svm_split
void free_svm_split(Svm_split s)
{
	/*Last Changed 25.07.2005 added weights*/
	/*Last Changed 28.05.2005*/
	int i;
	safe_free(s.sv_coef);
	for (i = 0; i < s.l; i++)
		 safe_free(s.SV[i]);
	safe_free(s.SV);
	safe_free(s.weights);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x68(%rax), %rdi
callq 0x52e80
movl $0x0, -0x4(%rbp)
movq -0x10(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x58(%rcx), %eax
jge 0xc5e1c
movq -0x10(%rbp), %rax
movq 0x60(%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 0xc5df0
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x52e80
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/svm.c
// Function: free_svm_model
void free_svm_model(Svm_modelptr model)
{
 /*LAst Changed 04.01.2006 added probA and probB*/
	/*Last Changed 03.05.2005*/
	int i;
	safe_free(model->nSV);
	safe_free(model->rho);
	safe_free(model->SV);
	for (i = 0; i < model->nr_class - 1; i++)
		 safe_free(model->sv_coef[i]);
	safe_free(model->sv_coef);
 safe_free(model->probA);
 safe_free(model->probB);
	safe_free(model);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x52e80
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x58(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xc5eab
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x52e80
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc5e7a
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/svm.c
// Function: free_svm_problem
void free_svm_problem(Svm_problem prob)
{
	/*Last Changed 03.05.2005*/
	int i;
 if (prob.l > 0)
  {
	  safe_free(prob.y);
	  for (i = 0; i < prob.l; i++)
		   safe_free(prob.x[i]);
	  safe_free(prob.x);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, (%rax)
jle 0xc5f51
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x52e80
movl $0x0, -0x4(%rbp)
movq -0x10(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl (%rcx), %eax
jge 0xc5f44
movq -0x10(%rbp), %rax
movq 0x10(%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 0xc5f19
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/svm.c
// Function: sigmoid_predict
double sigmoid_predict(double decision_value, double A, double B)
{
 double fApB = decision_value * A + B;
 if (fApB >= 0)
   return exp(-fApB) / (1.0 + exp(-fApB));
 else
   return 1.0 / (1 + exp(fApB)) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xc9597
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x4060
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x4060
movaps %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
movsd 0x18a90(%rip), %xmm1    # 0xe2018
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xc95be
movsd -0x28(%rbp), %xmm0
callq 0x4060
movsd 0x18a6f(%rip), %xmm1    # 0xe2018
addsd %xmm0, %xmm1
movsd 0x18a63(%rip), %xmm0    # 0xe2018
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)