LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/srm.c
// Function: vc_estimates_for_a_design
Vcestimateptr vc_estimates_for_a_design(void* parameters, int nodecount, Datasetptr d, int experimentcount, double averagevaluecount)
{
 /*!Last Changed 06.11.2007 added preestimation value*/
 /*!Last Changed 01.10.2006*/
 /*!Last Changed 01.04.2006*/
 int multiplier, n, k, ncount;
 double p, epsilon;
 Vcestimateptr header = NULL;
 ((Nodeboundedtree_parameterptr) parameters)->nodecount = nodecount;
 if (in_list(get_parameter_l("modelselectionmethod"), 3, MODEL_SELECTION_UNI, MODEL_SELECTION_LIN, MODEL_SELECTION_QUA))
   if (((Nodeboundedtree_parameterptr) parameters)->usediscrete)
     multiplier = decisiontree_vc_dimension_preestimation_discrete(d, (int) (nodecount * log2(averagevaluecount)));
   else
     multiplier = decisiontree_vc_dimension_preestimation(d, nodecount, get_parameter_l("modelselectionmethod") - 5);
 else
   multiplier = decisiontree_vc_dimension_preestimation(d, nodecount, MODEL_QUA);
 for (p = 1.5; p <= 30; p += 1.5)
  {
   n = (int) (multiplier * p);
   for (k = 0; k < experimentcount; k++)
    {
     epsilon = vc_single_epsilon_estimate(parameters, d, n, &ncount);
     if (ncount == nodecount)
       add_single_epsilon_estimate(&header, n, epsilon);
    }
  }
 return header;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x10(%rsp)
movl %ecx, %r15d
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
andq $0x0, 0x20(%rsp)
movl %esi, (%rdi)
leaq 0x15fc4(%rip), %rdi     # 0x957d6
callq 0x4cf11
pushq $0x3
popq %rsi
pushq $0x5
popq %rdx
pushq $0x6
popq %rcx
pushq $0x7
popq %r8
movl %eax, %edi
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0x7f861
cmpl $0x0, 0xc(%r14)
je 0x7f866
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x34d77
mulsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %esi
movq %rbx, %rdi
callq 0x93761
jmp 0x7f87f
pushq $0x2
popq %rdx
jmp 0x7f875
leaq 0x15f69(%rip), %rdi     # 0x957d6
callq 0x4cf11
leal -0x5(%rax), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x937e0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %eax, %eax
testl %r15d, %r15d
cmovgl %r15d, %eax
movl %eax, 0x18(%rsp)
movsd 0x1654a(%rip), %xmm1    # 0x95de8
leaq 0x1c(%rsp), %r15
movsd 0x18495(%rip), %xmm0    # 0x97d40
ucomisd %xmm1, %xmm0
jb 0x7f907
movsd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
mulsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %r13d
movl 0x18(%rsp), %r12d
subl $0x1, %r12d
jb 0x7f8f7
movq %r14, %rdi
movq %rbx, %rsi
movl %r13d, %edx
movq %r15, %rcx
callq 0x7f675
cmpl %ebp, 0x1c(%rsp)
jne 0x7f8cb
leaq 0x20(%rsp), %rdi
movl %r13d, %esi
callq 0x7f222
jmp 0x7f8cb
movsd 0x10(%rsp), %xmm1
addsd 0x164e3(%rip), %xmm1    # 0x95de8
jmp 0x7f8a3
movq 0x20(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r13d
movl $0x3fd, %edi            # imm = 0x3FD
callq 0x5a9c
movq %rax, %rbx
movl $0x3, 0x14(%rax)
xorl %eax, %eax
cmpl $0x2, (%r15)
setge %al
movl %eax, 0xc(%rbx)
leaq 0x21abe(%rip), %rdi     # 0xa1419
pushq $0x2
popq %r8
movl %r13d, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x143f8
leaq 0x4defc(%rip), %r15     # 0xcd870
movq %rax, (%r15)
movq %rax, %rdi
callq 0x13dd9
movq (%r15), %rdx
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %ecx
callq 0x7f7e4
movq %rax, %r14
pushq $-0x1
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x7f28d
leaq 0x195b2(%rip), %rdi     # 0x98f58
callq 0x30597
movq %r14, %rdi
callq 0x7f1f4
movq (%r15), %rdi
callq 0x12723
movl $0x3fd, %edi            # imm = 0x3FD
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4cf6
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/srm.c
// Function: move_vc_estimates
int move_vc_estimates(Vcestimateptr header, Vcestimateptr from, Vcestimateptr to, Datasetptr d, void* parameters, int nodecount, double previousmse)
{
 /*!Last Changed 05.04.2006*/
 Epsilonestimateptr deleted, added;
 double epsilon, vcdimension, mse;
 int ncount;
 if (to->issaturated)
   return FAILURE;
 epsilon = vc_single_epsilon_estimate(parameters, d, to->n, &ncount);
 if (ncount == nodecount)
  {
   deleted = from->epsilonestimates;
   from->epsilonestimates = from->epsilonestimates->next;
   (from->count)--;
   added = create_epsilon_estimate(epsilon);
   added->next = to->epsilonestimates;
   to->epsilonestimates = added;
   (to->count)++;
   vcdimension = vc_dimension_for_a_design(header, OPTIMIZED_DESIGN, -1);
   mse = mse_fitting_for_vc_dimension(header, vcdimension, -1);   
   if (mse < previousmse)
    {
     safe_free(deleted);
     if (from->count == 0)
      {
       from->before->next = from->next;
       if (from->next)
         from->next->before = from->before;
       safe_free(from);
      }
     return SUCCESS;
    }
   else
    {
     (to->count)--;
     to->epsilonestimates = to->epsilonestimates->next;
     (from->count)++;
     deleted->next = from->epsilonestimates;
     from->epsilonestimates = deleted;
     safe_free(added);
     return FAILURE;
    }
  }
 else
   return FAILURE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %ebp, %ebp
cmpl $0x0, 0x8(%rdx)
jne 0x7fd2d
movl %r9d, %r12d
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movsd %xmm0, 0x8(%rsp)
movl (%rdx), %edx
leaq 0x14(%rsp), %r13
movq %r8, %rdi
movq %rcx, %rsi
movq %r13, %rcx
callq 0x7f675
cmpl %r12d, (%r13)
jne 0x7fd2d
movq 0x18(%rbx), %r12
movq 0x8(%r12), %rax
movq %rax, 0x18(%rbx)
decl 0x4(%rbx)
callq 0x7f181
movq %rax, %r13
movq 0x18(%r14), %rax
movq %rax, 0x8(%r13)
movq %r13, 0x18(%r14)
incl 0x4(%r14)
pushq $0x1
popq %rbp
pushq $-0x1
popq %rdx
movq %r15, %rdi
movl %ebp, %esi
callq 0x7f28d
movq %r15, %rdi
pushq $-0x1
popq %rsi
callq 0x7f5e2
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x7fd00
movq %r12, %rdi
callq 0x34ff7
cmpl $0x0, 0x4(%rbx)
jne 0x7fd2d
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
movq %rax, 0x20(%rcx)
pushq $0x1
popq %rbp
testq %rax, %rax
je 0x7fd25
movq %rcx, 0x28(%rax)
jmp 0x7fd25
decl 0x4(%r14)
movq 0x18(%r14), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%r14)
incl 0x4(%rbx)
movq 0x18(%rbx), %rax
movq %rax, 0x8(%r12)
movq %r12, 0x18(%rbx)
xorl %ebp, %ebp
movq %r13, %rbx
movq %rbx, %rdi
callq 0x34ff7
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ecx
xorl %r9d, %r9d
testl %edx, %edx
cmovlel %r9d, %ecx
movl $0x1, %r8d
movl $0xa, %r10d
xorl %r11d, %r11d
cmpq %rcx, %r9
je 0x7fdb8
movslq (%rsi,%r9,4), %rbx
cmpq $0x2, %rbx
jl 0x7fdaa
xorl %eax, %eax
cmpq %rax, %rbx
je 0x7fd7d
andl $0x0, -0x30(%rsp,%rax,4)
incq %rax
jmp 0x7fd6e
movslq %r11d, %rax
leaq (%rdi,%rax,4), %r14
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0x7fdaa
movl (%r14,%r15,4), %eax
cltd
idivl %r10d
cltq
cmpl $0x0, -0x30(%rsp,%rax,4)
jne 0x7fdb5
movl $0x1, -0x30(%rsp,%rax,4)
incq %r15
jmp 0x7fd87
addl %r11d, %ebx
incq %r9
movl %ebx, %r11d
jmp 0x7fd5d
xorl %r8d, %r8d
movl %r8d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x801b9
jp 0x801b9
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
xorpd %xmm2, %xmm2
leaq 0x4d69a(%rip), %r15     # 0xcd870
movsd %xmm1, 0x18(%rsp)
movq (%r15), %rax
movl 0x1c0(%rax), %eax
decl %eax
cmpl %eax, %ebp
jge 0x8022b
movq %r14, %rdi
movl %ebp, %esi
movapd %xmm2, (%rsp)
callq 0x2aea2
movsd %xmm0, 0x20(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2aea2
movapd (%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
movsd 0x20(%rsp), %xmm3
subsd %xmm0, %xmm3
mulsd %xmm3, %xmm3
addsd %xmm3, %xmm2
incl %ebp
jmp 0x801dc
movsd 0x1a94d(%rip), %xmm0    # 0x9ab80
mulsd %xmm1, %xmm0
movsd 0x152e1(%rip), %xmm3    # 0x95520
divsd %xmm0, %xmm3
movsd %xmm3, (%rsp)
xorpd 0x15f80(%rip), %xmm2    # 0x961d0
movapd %xmm1, %xmm0
addsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
divsd %xmm0, %xmm2
movapd %xmm2, %xmm0
callq 0x34d50
mulsd (%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x4d5d6(%rip), %rax     # 0xcd870
movq (%rax), %rax
movl 0x1c0(%rax), %r13d
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x3a822
xorpd %xmm1, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x20(%rsp)
callq 0x34c3a
testl %eax, %eax
jne 0x803a3
decl %r13d
movq %r15, %rdi
callq 0x2b20d
movq %rax, %r15
movq %rdx, 0x18(%rsp)
movq %rax, %rsi
shrq $0x20, %rsi
pushq $0x1
popq %rdi
callq 0x380d3
movq %rax, 0x10(%rsp)
movq %rdx, %rbp
movq (%rdx), %rdi
movq %r15, %rdx
sarq $0x1d, %rdx
andq $-0x8, %rdx
movq %r12, %rsi
callq 0x4310
cvtsi2sd %r13d, %xmm1
movsd 0x21167(%rip), %xmm0    # 0xa1480
callq 0x42f0
movsd 0x20(%rsp), %xmm1
mulsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x80338
sqrtsd %xmm1, %xmm0
jmp 0x80341
movapd %xmm1, %xmm0
callq 0x4300
movsd 0x151d7(%rip), %xmm1    # 0x95520
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r15, %rdi
movq 0x18(%rsp), %r12
movq %r12, %rsi
movq 0x10(%rsp), %r13
movq %r13, %rdx
movq %rbp, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x3a8ff
mulsd 0x15a5c(%rip), %xmm0    # 0x95dd8
callq 0x34d50
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3929f
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3929f
movsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a148, %rsp          # imm = 0x7A148
movq %rdx, %r15
movl %esi, %ebx
movl %edi, %r14d
movsd %xmm0, 0x18(%rsp)
leaq 0x1b465(%rip), %rsi     # 0x9b891
movq %rdx, %rdi
callq 0x40f0
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x804e3
cvtsi2sd %ebx, %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
testl %r14d, %r14d
cmovlel %r13d, %r14d
leaq 0x20(%rsp), %r12
cmpl %r14d, %r13d
je 0x804c7
xorl %r15d, %r15d
movl %ebx, %ebp
subl $0x1, %ebx
jb 0x80495
xorpd %xmm0, %xmm0
movsd 0x150a4(%rip), %xmm1    # 0x95520
callq 0x35cae
xorl %eax, %eax
movsd 0x18(%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %al
addl %eax, %r15d
jmp 0x8046b
movq %r12, %rdi
xorl %esi, %esi
leaq 0x18c6a(%rip), %rdx     # 0x9910b
callq 0x35305
cvtsi2sd %r15d, %xmm0
divsd 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x42e0
incl %r13d
movl %ebp, %ebx
jmp 0x80461
movq 0x8(%rsp), %rdi
callq 0x42a0
addq $0x7a148, %rsp          # imm = 0x7A148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21186(%rip), %rdi     # 0xa1670
movq %r15, %rsi
xorl %eax, %eax
addq $0x7a148, %rsp          # imm = 0x7A148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4030
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
movq %rsi, 0x18(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0x191fa(%rip), %r12     # 0x99ba8
leaq 0x20(%rsp), %r13
xorl %r15d, %r15d
xorl %r14d, %r14d
cmpq 0x18(%rsp), %r15
je 0x80a33
movq 0x8(%rsp), %rbx
movq (%rbx,%r15,8), %rdi
callq 0x33f62
movl %eax, %ebp
movq %r15, 0x10(%rsp)
movq (%rbx,%r15,8), %rdi
leaq 0x1ae9f(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x80a47
movq %rax, %r15
testl %ebp, %ebp
movl $0x0, %ebx
cmovgl %ebp, %ebx
subl $0x1, %ebx
jb 0x80a1e
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4070
movsd (%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rsp)
jmp 0x809f7
addl %ebp, %r14d
movq %r15, %rdi
callq 0x42a0
movq 0x10(%rsp), %r15
incq %r15
jmp 0x809b9
cvtsi2sd %r14d, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x80a67
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x157ae(%rip), %rdi     # 0x9620a
xorl %eax, %eax
callq 0x4030
xorpd %xmm0, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
imulq $0x18, %rsi, %rcx
cmpq %rax, %rcx
je 0x80a99
ucomisd 0x8(%rdi,%rax), %xmm0
jbe 0x80a93
andl $0x0, 0x10(%rdi,%rax)
addq $0x18, %rax
jmp 0x80a81
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
imulq $0x18, %rsi, %rcx
cmpq %rax, %rcx
je 0x80ac5
ucomisd 0x8(%rdi,%rax), %xmm0
jbe 0x80abf
andl $0x0, 0x10(%rdi,%rax)
addq $0x18, %rax
jmp 0x80aad
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
leaq 0x18(%rdi), %rdx
movl $0x1, %r8d
cmpq %rcx, %rax
je 0x80b4d
imulq $0x18, %rax, %r9
addq %rdi, %r9
movl %r8d, %r10d
movq %rdx, %r11
cmpl %esi, %r10d
jge 0x80b41
movsd 0x8(%r9), %xmm1
ucomisd 0x8(%r11), %xmm1
jbe 0x80b38
movq 0x10(%r9), %rbx
movq %rbx, -0x10(%rsp)
movups (%r9), %xmm1
movaps %xmm1, -0x20(%rsp)
movq 0x10(%r11), %rbx
movq %rbx, 0x10(%r9)
movups (%r11), %xmm1
movups %xmm1, (%r9)
movq -0x10(%rsp), %rbx
movq %rbx, 0x10(%r11)
movapd -0x20(%rsp), %xmm1
movupd %xmm1, (%r11)
addq $0x18, %r11
incl %r10d
jmp 0x80aef
incq %rax
addq $0x18, %rdx
incl %r8d
jmp 0x80add
imulq $0x18, %rcx, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x80b79
cvtsi2sd %esi, %xmm1
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
ucomisd 0x8(%rdi,%rcx), %xmm2
jbe 0x80b79
andl $0x0, 0x10(%rdi,%rcx)
addq $0x18, %rcx
decl %esi
jmp 0x80b53
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
cmpl $0x2, %esi
jl 0x80c95
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r15
movq (%rdi), %rdi
leaq 0x1acee(%rip), %rsi     # 0x9b891
callq 0x40f0
testq %rax, %rax
je 0x80c84
movq %rax, %rbx
decl %ebp
leaq 0xc(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movl %ebp, %edi
callq 0x34903
movq %rax, %r14
leaq 0x201de(%rip), %r12     # 0xa0daf
xorl %ebp, %ebp
movslq 0xc(%rsp), %rax
cmpq %rax, %rbp
jge 0x80c3d
movq 0x10(%rsp), %rax
cmpl $0x2, (%rax,%rbp,4)
jl 0x80c38
leaq 0x20ad0(%rip), %rdi     # 0xa16bf
pushq $0xa
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x42c0
xorl %r13d, %r13d
movq 0x10(%rsp), %rax
movslq (%rax,%rbp,4), %rax
cmpq %rax, %r13
jge 0x80c2d
movq (%r14,%rbp,8), %rax
movslq (%rax,%r13,4), %rax
movq 0x8(%r15,%rax,8), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x42e0
incq %r13
jmp 0x80c00
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x4150
incq %rbp
jmp 0x80bd3
xorl %r15d, %r15d
movslq %eax, %rcx
cmpq %rcx, %r15
jge 0x80c66
movq 0x10(%rsp), %rcx
cmpl $0x0, (%rcx,%r15,4)
jle 0x80c61
movq (%r14,%r15,8), %rdi
callq 0x34ff7
movl 0xc(%rsp), %eax
incq %r15
jmp 0x80c40
movq %r14, %rdi
callq 0x34ff7
movq 0x10(%rsp), %rdi
callq 0x34ff7
movq %rbx, %rdi
callq 0x42a0
pushq $0x1
jmp 0x80c86
pushq $-0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rdi, %r12
callq 0x33f62
movl %eax, %ebp
leaq 0x1a469(%rip), %rsi     # 0x9b87f
movq %r12, %rdi
callq 0x40f0
testq %rax, %rax
je 0x8152e
movq %rax, %r15
movapd 0x10(%rsp), %xmm4
movapd %xmm4, %xmm0
movapd (%rsp), %xmm2
subsd %xmm2, %xmm0
mulsd 0x149a3(%rip), %xmm0    # 0x95de8
movapd %xmm2, %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x20(%rsp)
addsd %xmm4, %xmm0
movsd %xmm0, 0x28(%rsp)
xorl %eax, %eax
testl %ebp, %ebp
cmovlel %eax, %ebp
leaq 0x1873d(%rip), %r12     # 0x99ba8
leaq 0x30(%rsp), %r13
movapd %xmm2, %xmm1
subl $0x1, %ebp
jb 0x81516
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
movapd %xmm4, 0x10(%rsp)
movapd %xmm1, (%rsp)
callq 0x4070
movsd 0x30(%rsp), %xmm1
movsd 0x20(%rsp), %xmm0
cmpnlesd %xmm1, %xmm0
movapd %xmm0, %xmm2
movapd (%rsp), %xmm5
andpd %xmm5, %xmm2
andnpd %xmm1, %xmm0
orpd %xmm2, %xmm0
movapd %xmm1, %xmm2
cmpnlesd 0x28(%rsp), %xmm2
movapd %xmm2, %xmm3
andnpd %xmm1, %xmm2
movapd 0x10(%rsp), %xmm6
movapd %xmm6, %xmm4
cmpnlesd %xmm1, %xmm4
cmpnlesd %xmm5, %xmm1
movapd %xmm5, %xmm7
movapd %xmm1, %xmm5
andnpd %xmm0, %xmm5
andpd %xmm7, %xmm1
orpd %xmm5, %xmm1
andpd %xmm6, %xmm3
orpd %xmm3, %xmm2
movapd %xmm4, %xmm0
andnpd %xmm2, %xmm0
andpd %xmm6, %xmm4
orpd %xmm0, %xmm4
jmp 0x81474
movsd %xmm1, (%r14)
movsd %xmm4, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14cd5(%rip), %rdi     # 0x9620a
movq %r12, %rsi
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4030
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movq %rdi, 0x10(%rsp)
callq 0x8097f
movsd %xmm0, 0x28(%rsp)
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
movq %rbx, 0x20(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x1846b(%rip), %r12     # 0x99ba8
leaq 0x30(%rsp), %r13
xorl %r15d, %r15d
xorl %ebx, %ebx
cmpq 0x20(%rsp), %r15
je 0x817de
movq 0x10(%rsp), %r14
movq (%r14,%r15,8), %rdi
callq 0x33f62
movl %eax, %ebp
movq %r15, 0x18(%rsp)
movq (%r14,%r15,8), %rdi
leaq 0x1a10d(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x81802
movq %rax, %r15
testl %ebp, %ebp
movl $0x0, %r14d
cmovgl %ebp, %r14d
subl $0x1, %r14d
jb 0x817c7
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4070
movsd 0x30(%rsp), %xmm0
subsd 0x28(%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
jmp 0x8178f
addl %ebp, %ebx
movq %r15, %rdi
callq 0x42a0
movq 0x18(%rsp), %r15
incq %r15
jmp 0x81747
decl %ebx
cvtsi2sd %ebx, %xmm0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movapd %xmm1, %xmm0
jb 0x81824
sqrtsd %xmm0, %xmm0
jmp 0x81829
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x149f3(%rip), %rdi     # 0x9620a
xorl %eax, %eax
callq 0x4030
xorpd %xmm0, %xmm0
jmp 0x81829
callq 0x4300
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a148, %rsp          # imm = 0x7A148
movsd %xmm0, 0x18(%rsp)
movl %edx, %r14d
movl %esi, %ebp
leaq 0x1a036(%rip), %rsi     # 0x9b891
callq 0x40f0
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x81925
cvtsi2sd %r14d, %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
testl %ebp, %ebp
cmovlel %eax, %ebp
movl $0x2710, %r15d          # imm = 0x2710
xorl %ebx, %ebx
movl %ebp, 0x4(%rsp)
cmpl %ebp, %ebx
je 0x8191b
xorl %ebp, %ebp
movl %r14d, %r12d
subl $0x1, %r14d
jb 0x818de
xorl %eax, %eax
callq 0x35c7f
movl %eax, %r13d
xorl %eax, %eax
callq 0x35c7f
imull %r13d, %eax
cltd
idivl %r15d
cvtsi2sd %edx, %xmm0
divsd 0x18245(%rip), %xmm0    # 0x99b10
xorl %eax, %eax
movsd 0x18(%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %al
addl %eax, %ebp
jmp 0x818a0
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
leaq 0x1781c(%rip), %rdx     # 0x9910b
callq 0x35305
cvtsi2sd %ebp, %xmm0
divsd 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movb $0x1, %al
callq 0x42e0
incl %ebx
movl %r12d, %r14d
movl 0x4(%rsp), %ebp
jmp 0x81893
movq 0x8(%rsp), %rdi
callq 0x42a0
addq $0x7a148, %rsp          # imm = 0x7A148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x18(%rsp)
xorpd %xmm0, %xmm0
pushq $0xc
popq %rbx
subl $0x1, %ebx
jb 0x81983
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
movsd 0x13bba(%rip), %xmm1    # 0x95520
callq 0x35cae
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
jmp 0x8194f
addsd 0x16315(%rip), %xmm0    # 0x97ca0
mulsd 0x10(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x7a138, %rsp          # imm = 0x7A138
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movl %esi, %ebx
leaq 0x19ed2(%rip), %rsi     # 0x9b891
callq 0x40f0
testq %rax, %rax
je 0x81a18
movq %rax, %r14
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq 0x17731(%rip), %r15     # 0x9910b
leaq 0x10(%rsp), %r12
subl $0x1, %ebx
jb 0x81a10
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x35305
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x81937
movq %r14, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x42e0
jmp 0x819df
movq %r14, %rdi
callq 0x42a0
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a138, %rsp          # imm = 0x7A138
movq %rsi, %rbx
movq %rdi, %r14
callq 0x33f62
movl %eax, 0x4(%rsp)
leaq 0x19e31(%rip), %rsi     # 0x9b87f
movq %r14, %rdi
callq 0x40f0
testq %rax, %rax
je 0x81b30
movq %rax, %r12
movq %rbx, 0x8(%rsp)
movslq 0x4(%rsp), %rbx
leaq (,%rbx,8), %rdi
leaq 0x1a13b(%rip), %rsi     # 0x9bbb6
pushq $0x5
popq %rdx
callq 0x34f59
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
movq %rax, %r14
leaq (,%rbx,8), %rbp
leaq 0x1810c(%rip), %r13     # 0x99ba8
xorl %r15d, %r15d
cmpq %r15, %rbp
je 0x81abb
leaq (%r14,%r15), %rdx
movq %r12, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %r15
jmp 0x81a9f
movq %r12, %rdi
callq 0x42a0
leaq 0x19dc7(%rip), %rsi     # 0x9b891
movq 0x8(%rsp), %rdi
callq 0x40f0
testq %rax, %rax
je 0x81b30
movq %rax, %r15
leaq 0x17628(%rip), %r12     # 0x9910b
leaq 0x10(%rsp), %r13
subl $0x1, %ebx
jb 0x81b20
xorl %eax, %eax
callq 0x35c7f
cltd
idivl 0x4(%rsp)
movl %edx, %ebp
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x35305
movslq %ebp, %rax
movsd (%r14,%rax,8), %xmm0
movq %r15, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x42e0
jmp 0x81ae8
movq %r15, %rdi
callq 0x42a0
movq %r14, %rdi
callq 0x34ff7
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
subq $0x18, %rsp
testl %edx, %edx
jle 0x81b58
cmpl $0x1, %edx
jne 0x81b68
leaq 0x1fc4f(%rip), %rdi     # 0xa17a5
jmp 0x81b5f
leaq 0x1fc20(%rip), %rdi     # 0xa177f
addq $0x18, %rsp
jmp 0x4090
movq %rdi, %rax
movq %rsi, %rdi
callq *%rax
movsd %xmm0, 0x10(%rsp)
leaq 0x173e1(%rip), %rdi     # 0x98f5e
callq 0x30597
leaq 0x13d9f(%rip), %rdi     # 0x95928
callq 0x4cdcf
movsd 0x1398a(%rip), %xmm1    # 0x95520
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
leaq 0x14a5e(%rip), %rdi     # 0x96605
callq 0x4cff1
movsd 0x10(%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
jae 0x81bd7
testl %eax, %eax
je 0x81bca
leaq 0x1fc97(%rip), %rdi     # 0xa185c
callq 0x4090
leaq 0x17387(%rip), %rdi     # 0x98f58
xorpd %xmm0, %xmm0
jmp 0x81bf6
testl %eax, %eax
je 0x81be7
leaq 0x1fbeb(%rip), %rdi     # 0xa17cd
callq 0x4090
leaq 0x1736a(%rip), %rdi     # 0x98f58
movsd 0x1392a(%rip), %xmm0    # 0x95520
addq $0x18, %rsp
jmp 0x30597
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
andq $0x0, 0x10(%rsp)
cmpl $0x2, %edx
jl 0x81c68
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x13d0a(%rip), %rdi     # 0x95928
callq 0x4cdcf
movsd 0x138f5(%rip), %xmm1    # 0x95520
subsd %xmm0, %xmm1
leaq 0xc(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movapd %xmm1, %xmm0
callq *%rbx
testl %eax, %eax
je 0x81c79
movl 0xc(%rsp), %ebx
leaq 0x149b4(%rip), %rdi     # 0x96605
callq 0x4cff1
cmpl $0x1, %ebx
jne 0x81cbc
testl %eax, %eax
je 0x81cdd
leaq 0x1fc3a(%rip), %rdi     # 0xa18a0
jmp 0x81cd8
leaq 0x1fb81(%rip), %rdi     # 0xa17f0
callq 0x4090
jmp 0x81d11
leaq 0x14985(%rip), %rdi     # 0x96605
callq 0x4cff1
testl %eax, %eax
je 0x81caf
leaq 0x1a94f(%rip), %rdi     # 0x9c5df
callq 0x4cd35
cmpl $0x2, %eax
leaq 0x1fbbd(%rip), %rax     # 0xa185c
leaq 0x1fb69(%rip), %rdi     # 0xa180f
cmoveq %rax, %rdi
callq 0x4090
leaq 0x172a2(%rip), %rdi     # 0x98f58
xorpd %xmm0, %xmm0
jmp 0x81d0c
testl %eax, %eax
je 0x81cdd
leaq 0x1a918(%rip), %rdi     # 0x9c5df
callq 0x4cd35
cmpl $0x2, %eax
jne 0x81cdd
leaq 0x1fba1(%rip), %rdi     # 0xa1879
callq 0x4090
leaq 0x1a8fb(%rip), %rdi     # 0x9c5df
callq 0x4cd35
cmpl $0x1, %eax
jne 0x81cff
leaq 0x17263(%rip), %rdi     # 0x98f58
movsd 0x13823(%rip), %xmm0    # 0x95520
jmp 0x81d0c
cvtsi2sdl 0xc(%rsp), %xmm0
leaq 0x1724c(%rip), %rdi     # 0x98f58
callq 0x30597
movsd 0x10(%rsp), %xmm0
leaq 0x17240(%rip), %rdi     # 0x98f5e
callq 0x30597
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2c3cc
leaq 0x4b7a9(%rip), %r13     # 0xcd870
movq (%r13), %rcx
movl 0x10(%rcx), %esi
incl %esi
movl %eax, %edi
callq 0x380d3
movq %rdx, %r12
xorl %ebp, %ebp
testl %eax, %eax
movq %rax, (%rsp)
movl %eax, %r15d
cmovlel %ebp, %r15d
cmpq %rbp, %r15
je 0x8212d
movq (%r12,%rbp,8), %rdi
movq (%r14,%rbp,8), %rsi
movq (%r13), %rax
movslq 0x10(%rax), %rdx
shlq $0x3, %rdx
callq 0x4310
movq %rbx, %rdi
callq 0x2b47e
cvtsi2sd %eax, %xmm0
movq (%r12,%rbp,8), %rax
movq (%r13), %rcx
movslq 0x10(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x10(%rbx), %rbx
incq %rbp
jmp 0x820e9
movq (%rsp), %rax
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %r8, %r9
movl %ecx, %r8d
movl %edx, %ecx
leaq 0xc(%rsp), %rbx
movq %rbx, %rdx
callq 0x82143
movl (%rbx), %ecx
cmpl $0x2, %ecx
pushq $0x1
popq %rdx
cmovgel %ecx, %edx
decl %edx
imulq $0x18, %rdx, %rcx
xorpd %xmm3, %xmm3
xorl %edx, %edx
movsd 0x13976(%rip), %xmm0    # 0x95d20
cmpq %rdx, %rcx
je 0x823d8
movsd 0x8(%rax,%rdx), %xmm1
movsd 0x18(%rax,%rdx), %xmm2
addsd 0x20(%rax,%rdx), %xmm1
subsd (%rax,%rdx), %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm2, %xmm3
addq $0x18, %rdx
jmp 0x823aa
movq %rax, %rdi
movsd %xmm3, (%rsp)
callq 0x34ff7
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4b462(%rip), %r13     # 0xcd870
movq (%r13), %rax
movl 0x10(%rax), %eax
xorl %r12d, %r12d
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
cmpl %eax, %r12d
jge 0x8246b
leal 0x1(%r12), %ebp
movl %ebp, 0x14(%rsp)
cmpl %eax, %ebp
jge 0x82462
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebp, %ecx
movq %rbx, %r8
callq 0x82371
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
incl %ebp
movq (%r13), %rax
movl 0x10(%rax), %eax
jmp 0x82430
movl 0x14(%rsp), %ecx
movl %ecx, %r12d
jmp 0x82422
movsd 0x8(%rsp), %xmm0
addsd %xmm0, %xmm0
leal -0x1(%rax), %ecx
imull %eax, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
xorl %ecx, %ecx
testl %edi, %edi
cmovlel %ecx, %edi
movsd 0x13075(%rip), %xmm1    # 0x95520
movabsq $0x100000000, %r9       # imm = 0x100000000
xorpd %xmm2, %xmm2
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r10d, %r10d
cmpq %rcx, %rdi
je 0x82514
movq (%rsi,%rcx,8), %r11
movsd (%r11), %xmm4
movsd 0x10(%r11), %xmm3
ucomisd %xmm0, %xmm4
jae 0x824f3
ucomisd %xmm1, %xmm3
jne 0x82500
jp 0x82500
movq %rdx, %r11
andq %rax, %r11
movl %edx, %edx
addq %r11, %rdx
addq %r9, %rdx
jmp 0x8250f
ucomisd %xmm2, %xmm3
jne 0x8250c
jp 0x8250c
incl %r8d
jmp 0x8250f
leal 0x1(%rdx), %r11d
andq %rax, %rdx
orq %r11, %rdx
jmp 0x8250f
incl %r10d
incq %rcx
jmp 0x824c1
shlq $0x20, %r8
movl %r10d, %eax
orq %r8, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdi, %r15
leaq 0x186f7(%rip), %rdi     # 0x9ac2d
callq 0x4cd35
movl %eax, %ebx
leaq 0x1c5c8(%rip), %rdi     # 0x9eb0c
callq 0x4cd35
imull %ebx, %eax
movslq %eax, %rbx
movq %rbx, %rdi
shlq $0x4, %rdi
leaq 0x1f1cb(%rip), %rsi     # 0xa1728
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %r14
movl %ebx, %edi
movq %r15, %rsi
callq 0x8294
movq %rax, %r15
xorl %r12d, %r12d
testl %ebx, %ebx
cmovlel %r12d, %ebx
shlq $0x4, %rbx
cmpq %r12, %rbx
je 0x825b7
movq (%r15,%r12), %rdi
movq 0x8(%r15,%r12), %rsi
movsd (%rsp), %xmm0
callq 0x82492
movq %rax, (%r14,%r12)
movq %rdx, 0x8(%r14,%r12)
movq (%r15,%r12), %rdi
movq 0x8(%r15,%r12), %rsi
callq 0x3929f
addq $0x10, %r12
jmp 0x82582
movq %r15, %rdi
callq 0x34ff7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/structure.c
// Function: simulated_annealing_bn
bayesiangraphptr simulated_annealing_bn(char *graph_name, char *train_file, char *cv_file, char *test_file, ORDERING_TYPE ordering, double infthreshold)
{/*Last Changed 09.03.2001*/
 int i = 0, j, edgecount;
 bayesiangraphptr newnetwork;
 double **edges;
 newnetwork = (bayesiangraphptr) initial_graph_from_data(graph_name, train_file, cv_file, test_file);
 if (!newnetwork)
   return NULL;
 newnetwork->independence = zero_independence_test(newnetwork);
 newnetwork->one_independence = one_independence_test(newnetwork);
 edges = find_edges(newnetwork, infthreshold, &edgecount);
 switch (ordering)
  {
   case ORDERING_RANDOM  :random_ordering(newnetwork);
                          break;
   case ORDERING_STATE   :state_ordering(newnetwork);
                          break;
   case ORDERING_MINTABLE:min_table_ordering(newnetwork, edges, edgecount);
                          break;
   case ORDERING_ALARM   :alarm_ordering(newnetwork);
                          break;
   default               :printf(m1240, ordering);
                          break;
  }
 add_arcs_according_to_ordering(newnetwork, edges, edgecount);
 make_conditional_tables(newnetwork);
 while (i < 5)
  {
   j = myrand() % 2;
   if (j)
     if (!remove_operator(newnetwork))
       i++;
     else
       i = 0;
   else
     if (!modify_operator(newnetwork))
       i++;
     else
       i = 0;
  }
 return newnetwork;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movl %r8d, %ebp
callq 0x23ab7
movq %rax, %rbx
testq %rax, %rax
je 0x826bd
movq %rbx, %rdi
callq 0x2a88c
movq %rax, 0x30(%rbx)
movq %rbx, %rdi
callq 0x2abdc
movq %rax, 0x38(%rbx)
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x47d22
movq %rax, %r14
cmpl $0x3, %ebp
ja 0x82666
movl %ebp, %eax
leaq 0x1f29a(%rip), %rcx     # 0xa18c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x4c960
jmp 0x82676
movl 0x4(%rsp), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4ca02
jmp 0x82676
movq %rbx, %rdi
callq 0x4cba8
jmp 0x82676
movq %rbx, %rdi
callq 0x4c980
jmp 0x82676
leaq 0x1f27b(%rip), %rdi     # 0xa18e8
movl %ebp, %esi
xorl %eax, %eax
callq 0x4030
movl 0x4(%rsp), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x480fa
movq %rbx, %rdi
callq 0x48369
xorl %ebp, %ebp
xorl %r14d, %r14d
cmpl $0x4, %r14d
jg 0x826bd
xorl %eax, %eax
callq 0x35c7f
movq %rbx, %rdi
testb $0x1, %al
jne 0x826ad
callq 0x4c7b2
jmp 0x826b2
callq 0x4c678
incl %r14d
testl %eax, %eax
cmovnel %ebp, %r14d
jmp 0x82692
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x30(%rsp), %r14
movq 0x68(%r14), %rdi
callq 0x34ff7
movslq 0x58(%r14), %r15
movq 0x60(%r14), %rbx
xorl %r12d, %r12d
cmpq %r15, %r12
jge 0x828f0
movq (%rbx,%r12,8), %rdi
callq 0x34ff7
incq %r12
jmp 0x828dd
movq %rbx, %rdi
callq 0x34ff7
movq 0x78(%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
callq 0x34ff7
movq 0x70(%rbx), %rdi
callq 0x34ff7
movq 0x60(%rbx), %rdi
callq 0x34ff7
xorl %r14d, %r14d
movslq 0x58(%rbx), %rax
decq %rax
movq 0x68(%rbx), %rdi
cmpq %rax, %r14
jge 0x8294f
movq (%rdi,%r14,8), %rdi
callq 0x34ff7
incq %r14
jmp 0x82931
callq 0x34ff7
movq 0xa0(%rbx), %rdi
callq 0x34ff7
movq 0xa8(%rbx), %rdi
callq 0x34ff7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movslq 0x20(%rsp), %r14
testq %r14, %r14
jle 0x829bf
leaq 0x20(%rsp), %rbx
movq 0x8(%rbx), %rdi
callq 0x34ff7
movq 0x10(%rbx), %rbx
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x829b2
movq (%rbx,%r15,8), %rdi
callq 0x34ff7
incq %r15
jmp 0x8299f
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x34ff7
popq %rbx
popq %r14
popq %r15
retq