LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/srm.c
// Function: deallocate_vc_estimates
void deallocate_vc_estimates(Vcestimateptr header)
{
 /*!Last Changed 01.04.2006*/
 Vcestimateptr tmp, next;
 tmp = header;
 while (tmp)
  {
   next = tmp->next;
   deallocate_epsilon_estimates(tmp->epsilonestimates);
   safe_free(tmp);
   tmp = next;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x8ca96
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %r14
testq %rdi, %rdi
je 0x8ca81
movq 0x8(%rdi), %r15
callq 0x3a180
movq %r15, %rdi
testq %r15, %r15
jne 0x8ca70
movq %rbx, %rdi
callq 0x3a180
movq %r14, %rbx
testq %r14, %r14
jne 0x8ca63
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/srm.c
// Function: add_single_epsilon_estimate
void add_single_epsilon_estimate(Vcestimateptr* header, int n, double epsilon)
{
 /*!Last Changed 01.04.2006*/
 Vcestimateptr newvcestimate, tmpvc;
 Epsilonestimateptr newepsilonestimate;
 newepsilonestimate = create_epsilon_estimate(epsilon);
 tmpvc = *header;
 /* Finds the design point*/
 while (tmpvc && tmpvc->n != n)
   tmpvc = tmpvc->next;
 /*If there is a design point with the given sample size*/
 if (tmpvc)
  {
   newepsilonestimate->next = tmpvc->epsilonestimates;
   tmpvc->epsilonestimates = newepsilonestimate;
   (tmpvc->count)++;
  }
 /* If not, generate a new design point*/
 else
  {
   newvcestimate = create_vc_estimate(n, newepsilonestimate);
   if (*header)
    {
     newvcestimate->next = *header;
     (*header)->before = newvcestimate;
    }
   *header = newvcestimate;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x249af(%rip), %rsi     # 0xb1460
movl $0x10, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %r14
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
movq (%rbx), %rax
testq %rax, %rax
je 0x8cae7
cmpl %ebp, (%rax)
je 0x8cb29
movq 0x20(%rax), %rax
jmp 0x8cad8
leaq 0x2498a(%rip), %rsi     # 0xb1478
movl $0x30, %edi
movl $0x2, %edx
callq 0x3a0e1
movl %ebp, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %r14, 0x18(%rax)
movl $0x1, 0x4(%rax)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x8cb24
movq %rcx, 0x20(%rax)
movq (%rbx), %rcx
movq %rax, 0x28(%rcx)
movq %rax, (%rbx)
jmp 0x8cb38
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%r14)
movq %r14, 0x18(%rax)
incl 0x4(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/srm.c
// Function: mse_fitting_for_vc_dimension
double mse_fitting_for_vc_dimension(Vcestimateptr estimates, double vcdimension, int n)
{
 /*!Last Changed 01.04.2006*/
 Vcestimateptr tmpvc = estimates;
 Epsilonestimateptr tmpepsilon;
 int count = 0;
 double mse = 0, add;
 while (tmpvc)
  {
   if (tmpvc->n != n)
    {
     tmpepsilon = tmpvc->epsilonestimates;
     while (tmpepsilon)
      {
       add = tmpepsilon->epsilon - vc_bound(tmpvc->n / vcdimension);
       mse += add * add;
       count++;
       tmpepsilon = tmpepsilon->next;
      }
    }
   tmpvc = tmpvc->next;
  }
 return mse / count;
}

// Assembly:
testq %rdi, %rdi
je 0x8cee6
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movapd %xmm0, %xmm2
movq %rdi, %r14
xorl %ebp, %ebp
xorpd %xmm1, %xmm1
movsd %xmm0, (%rsp)
cmpl %ebx, (%r14)
jne 0x8ce7f
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x8ce6f
jmp 0x8cecf
movq 0x18(%r14), %r15
testq %r15, %r15
je 0x8ce74
movsd %xmm1, 0x10(%rsp)
movsd (%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sdl (%r14), %xmm0
divsd %xmm2, %xmm0
callq 0x8c834
movsd (%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm3
subsd %xmm0, %xmm3
mulsd %xmm3, %xmm3
addsd %xmm3, %xmm1
incl %ebp
movq 0x8(%r15), %r15
jmp 0x8ce83
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
divsd %xmm0, %xmm1
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8ceee
movsd 0x18e22(%rip), %xmm1    # 0xa5d10
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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, (%rsp)
movl %ecx, 0xc(%rsp)
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq $0x0, 0x20(%rsp)
movl %esi, (%rdi)
leaq 0x18729(%rip), %rdi     # 0xa57d6
callq 0x54afc
movl %eax, %edi
movl $0x3, %esi
movl $0x5, %edx
movl $0x6, %ecx
movl $0x7, %r8d
xorl %eax, %eax
callq 0x3aa8c
testl %eax, %eax
je 0x8d106
cmpl $0x0, 0xc(%r15)
je 0x8d112
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
callq 0x39bdc
mulsd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %esi
movq %r14, %rdi
callq 0xa2daf
jmp 0x8d12b
movq %r14, %rdi
movl %ebp, %esi
movl $0x2, %edx
jmp 0x8d126
leaq 0x186bd(%rip), %rdi     # 0xa57d6
callq 0x54afc
leal -0x5(%rax), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0xa2e36
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18ca0(%rip), %xmm0    # 0xa5de0
leaq 0x1c(%rsp), %r12
movsd %xmm0, (%rsp)
cmpl $0x0, 0xc(%rsp)
jle 0x8d18c
movsd (%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %ebx
movl 0xc(%rsp), %r13d
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
callq 0x8cef3
cmpl %ebp, 0x1c(%rsp)
jne 0x8d187
leaq 0x20(%rsp), %rdi
movl %ebx, %esi
callq 0x8ca97
decl %r13d
jne 0x8d165
movsd (%rsp), %xmm1
addsd 0x18c47(%rip), %xmm1    # 0xa5de0
movsd 0x1ac1f(%rip), %xmm0    # 0xa7dc0
movsd %xmm1, (%rsp)
ucomisd %xmm1, %xmm0
jae 0x8d14a
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_O3/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 0x5b37
movq %rax, %rbx
movl $0x3, 0x14(%rax)
xorl %eax, %eax
cmpl $0x2, (%r15)
setge %al
movl %eax, 0xc(%rbx)
leaq 0x242b9(%rip), %rdi     # 0xb14b9
movl %r13d, %esi
movq %r12, %rdx
movq %r15, %rcx
movl $0x2, %r8d
callq 0x156a2
leaq 0x48655(%rip), %r15     # 0xd5870
movq %rax, (%r15)
movq %rax, %rdi
callq 0x14fef
movq (%r15), %rdx
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %ecx
callq 0x8d07c
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x8cb52
leaq 0x1bd99(%rip), %rdi     # 0xa8fe8
callq 0x34a17
movq %r14, %rdi
callq 0x8ca56
movq (%r15), %rdi
callq 0x1376b
movl $0x3fd, %edi            # imm = 0x3FD
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4cff
// File: /workspace/github_c_makefile_star2_O3/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 0x8d66d
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 0x8cef3
cmpl %r12d, (%r13)
jne 0x8d66d
movq 0x18(%rbx), %r12
movq 0x8(%r12), %rax
movq %rax, 0x18(%rbx)
decl 0x4(%rbx)
leaq 0x23eaa(%rip), %rsi     # 0xb1460
movl $0x10, %edi
movl $0x2, %edx
movsd %xmm0, (%rsp)
callq 0x3a0e1
movq %rax, %r13
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x18(%r14), %rax
movq %rax, 0x8(%r13)
movq %r13, 0x18(%r14)
incl 0x4(%r14)
movl $0x1, %ebp
movq %r15, %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x8cb52
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8ce48
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x8d640
movq %r12, %rdi
callq 0x3a180
cmpl $0x0, 0x4(%rbx)
jne 0x8d66d
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
movq %rax, 0x20(%rcx)
movl $0x1, %ebp
testq %rax, %rax
je 0x8d665
movq %rcx, 0x28(%rax)
jmp 0x8d665
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 0x3a180
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_O3/olcaytaner[P]Isell/srm.c
// Function: is_featurelist_valid
BOOLEAN is_featurelist_valid(int* featurelist, int* ruleset, int rulecount)
{
 /*!Last Changed 21.02.2008*/
 int i, j = 0, k, available[10], fno;
 for (i = 0; i < rulecount; i++)
  {
   if (ruleset[i] > 1)
    {
     for (k = 0; k < ruleset[i]; k++)
       available[k] = BOOLEAN_FALSE;
     for (k = 0; k < ruleset[i]; k++)
      {
       fno = featurelist[j + k] / 10;
       if (available[fno])
         return BOOLEAN_FALSE;
       available[fno] = BOOLEAN_TRUE;
      }
    }
   j += ruleset[i];
  }
 return BOOLEAN_TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movl $0x1, %ebx
testl %edx, %edx
jle 0x8d715
movq %rsi, %r14
movl %edx, %r13d
xorl %ebp, %ebp
xorl %r12d, %r12d
movslq (%r14,%rbp,4), %r15
cmpq $0x2, %r15
jl 0x8d703
leaq (,%r15,4), %rdx
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x4050
movslq %r12d, %rax
movq 0x8(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
xorl %ecx, %ecx
movslq (%rax,%rcx,4), %rdx
imulq $0x66666667, %rdx, %rdx # imm = 0x66666667
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x22, %rdx
addl %esi, %edx
movslq %edx, %rdx
cmpl $0x0, 0x10(%rsp,%rdx,4)
jne 0x8d713
movl $0x1, 0x10(%rsp,%rdx,4)
incq %rcx
cmpq %rcx, %r15
jne 0x8d6d1
addl %r12d, %r15d
incq %rbp
movl %r15d, %r12d
cmpq %r13, %rbp
jne 0x8d6a5
jmp 0x8d715
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8db7d
jp 0x8db7d
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x18(%rsp)
leaq 0x47cdc(%rip), %r15     # 0xd5870
movq (%r15), %rax
xorpd %xmm2, %xmm2
cmpl $0x2, 0x1c0(%rax)
jl 0x8dbf3
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movapd %xmm2, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0x2ed6a
movsd %xmm0, 0x20(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2ed6a
movapd (%rsp), %xmm2
movsd 0x20(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm2
incl %ebp
movq (%r15), %rax
movl 0x1c0(%rax), %eax
decl %eax
cmpl %eax, %ebp
jl 0x8dbac
movsd 0x1d055(%rip), %xmm0    # 0xaac50
movsd 0x18(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x17913(%rip), %xmm3    # 0xa5520
divsd %xmm0, %xmm3
movsd %xmm3, (%rsp)
xorpd 0x185b2(%rip), %xmm2    # 0xa61d0
movapd %xmm1, %xmm0
addsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
divsd %xmm0, %xmm2
movapd %xmm2, %xmm0
callq 0x39bb5
mulsd (%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x47c08(%rip), %rax     # 0xd5870
movq (%rax), %rax
movl 0x1c0(%rax), %r13d
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x4078e
xorpd %xmm1, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x20(%rsp)
callq 0x39ab2
testl %eax, %eax
jne 0x8dd79
decl %r13d
movq %r15, %rdi
callq 0x2f0c1
movq %rax, %r15
movq %rdx, 0x18(%rsp)
movq %rax, %rsi
shrq $0x20, %rsi
movl $0x1, %edi
callq 0x3d79d
movq %rax, 0x10(%rsp)
movq %rdx, %rbp
movq (%rdx), %rdi
movq %r15, %rdx
sarq $0x1d, %rdx
andq $-0x8, %rdx
movq %r12, %rsi
callq 0x4310
xorps %xmm1, %xmm1
cvtsi2sd %r13d, %xmm1
movsd 0x23834(%rip), %xmm0    # 0xb1520
callq 0x42f0
movsd 0x20(%rsp), %xmm1
mulsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x8dd0e
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x8dd17
movapd %xmm1, %xmm0
callq 0x4300
movsd 0x17801(%rip), %xmm1    # 0xa5520
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 0x4088c
mulsd 0x1807e(%rip), %xmm0    # 0xa5dd0
callq 0x39bb5
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3ed51
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3ed51
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_O3/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, %ebp
movl %edi, %r14d
movsd %xmm0, 0x18(%rsp)
leaq 0x1db6b(%rip), %rsi     # 0xab96d
movq %rdx, %rdi
callq 0x40f0
movq %rax, (%rsp)
testq %rax, %rax
je 0x8dec5
testl %r14d, %r14d
jle 0x8deaa
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r13d, %r13d
leaq 0x20(%rsp), %r12
xorpd %xmm0, %xmm0
testl %ebp, %ebp
jle 0x8de71
xorl %r15d, %r15d
movl %ebp, %ebx
xorpd %xmm0, %xmm0
movsd 0x176d2(%rip), %xmm1    # 0xa5520
callq 0x3af6a
xorl %eax, %eax
movsd 0x18(%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %al
addl %eax, %r15d
decl %ebx
jne 0x8de42
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r12, %rdi
xorl %esi, %esi
leaq 0x1b312(%rip), %rdx     # 0xa919b
callq 0x3a535
movq (%rsp), %rdi
movq %r12, %rsi
movsd 0x10(%rsp), %xmm0
movb $0x1, %al
callq 0x42e0
incl %r13d
cmpl %r14d, %r13d
jne 0x8de35
movq (%rsp), %rdi
callq 0x42a0
addq $0x7a148, %rsp          # imm = 0x7A148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23844(%rip), %rdi     # 0xb1710
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_O3/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, 0x10(%rsp)
testl %esi, %esi
jle 0x8e46d
movl %esi, %eax
movq %rax, 0x18(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0x1b8ad(%rip), %r15     # 0xa9c80
leaq 0x20(%rsp), %r12
xorl %r14d, %r14d
xorl %ebp, %ebp
movq 0x10(%rsp), %r13
movq (%r13,%r14,8), %rdi
callq 0x38a4a
movl %eax, %ebx
movq (%r13,%r14,8), %rdi
leaq 0x1d561(%rip), %rsi     # 0xab95b
callq 0x40f0
testq %rax, %rax
je 0x8e477
movq %rax, %r13
movl %ebp, 0xc(%rsp)
movl %ebx, %ebp
testl %ebx, %ebx
movsd (%rsp), %xmm0
jle 0x8e43a
movsd %xmm0, (%rsp)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x4070
movsd (%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
decl %ebp
jne 0x8e416
movsd %xmm0, (%rsp)
movl 0xc(%rsp), %ebp
addl %ebx, %ebp
movq %r13, %rdi
callq 0x42a0
incq %r14
cmpq 0x18(%rsp), %r14
jne 0x8e3dd
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x8e492
movsd 0x1789b(%rip), %xmm0    # 0xa5d10
jmp 0x8e492
movq 0x10(%rsp), %rax
movq (%rax,%r14,8), %rsi
leaq 0x17d83(%rip), %rdi     # 0xa620a
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_O3/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:
testl %esi, %esi
jle 0x8e4ca
movl %esi, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
xorl %ecx, %ecx
ucomisd 0x8(%rdi,%rcx), %xmm0
jbe 0x8e4c1
movl $0x0, 0x10(%rdi,%rcx)
addq $0x18, %rcx
cmpq %rcx, %rax
jne 0x8e4b1
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0x8e4fc
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
movl %esi, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
xorl %ecx, %ecx
ucomisd 0x8(%rdi,%rcx), %xmm0
jbe 0x8e4f3
movl $0x0, 0x10(%rdi,%rcx)
addq $0x18, %rcx
cmpq %rcx, %rax
jne 0x8e4e3
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0x8e5b7
pushq %rbx
movl %esi, %eax
leaq 0x18(%rdi), %rcx
movl $0x1, %edx
xorl %r8d, %r8d
movq %r8, %r9
incq %r8
cmpq %rax, %r8
jae 0x8e57d
leaq (%r9,%r9,2), %r9
leaq (%rdi,%r9,8), %r9
movq %rax, %r10
movq %rcx, %r11
movsd 0x8(%r9), %xmm1
ucomisd 0x8(%r11), %xmm1
jbe 0x8e571
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
decq %r10
cmpq %r10, %rdx
jne 0x8e52d
incq %rdx
addq $0x18, %rcx
cmpq %rax, %r8
jne 0x8e514
testl %esi, %esi
jle 0x8e5b6
addq $0x10, %rdi
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
ucomisd -0x8(%rdi), %xmm2
jbe 0x8e5b6
movl $0x0, (%rdi)
addq $0x18, %rdi
decq %rax
jne 0x8e591
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8e6f7
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 0x1d38d(%rip), %rsi     # 0xab96d
callq 0x40f0
testq %rax, %rax
je 0x8e6e4
movq %rax, %rbx
decl %ebp
leaq 0x14(%rsp), %r12
leaq 0x8(%rsp), %rdx
movl %ebp, %edi
movq %r12, %rsi
callq 0x3971c
movq %rax, %r14
movl (%r12), %eax
testl %eax, %eax
jle 0x8e6c3
leaq 0x2282e(%rip), %r13     # 0xb0e4b
xorl %ebp, %ebp
movq 0x8(%rsp), %rcx
cmpl $0x2, (%rcx,%rbp,4)
jl 0x8e68d
movl $0xa, %esi
movl $0x1, %edx
leaq 0x23124(%rip), %rdi     # 0xb175f
movq %rbx, %rcx
callq 0x42c0
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax,%rbp,4)
jle 0x8e67c
xorl %r12d, %r12d
movq (%r14,%rbp,8), %rax
movslq (%rax,%r12,4), %rax
movq 0x8(%r15,%rax,8), %rdx
movq %rbx, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x42e0
incq %r12
movq 0x8(%rsp), %rax
movslq (%rax,%rbp,4), %rax
cmpq %rax, %r12
jl 0x8e651
movl $0xa, %edi
movq %rbx, %rsi
callq 0x4150
movl 0x14(%rsp), %eax
incq %rbp
movslq %eax, %rcx
cmpq %rcx, %rbp
jl 0x8e61f
testl %eax, %eax
jle 0x8e6c3
xorl %r15d, %r15d
movq 0x8(%rsp), %rcx
cmpl $0x0, (%rcx,%r15,4)
jle 0x8e6b8
movq (%r14,%r15,8), %rdi
callq 0x3a180
movl 0x14(%rsp), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x8e69f
movq %r14, %rdi
callq 0x3a180
movq 0x8(%rsp), %rdi
callq 0x3a180
movq %rbx, %rdi
callq 0x42a0
movl $0x1, %eax
jmp 0x8e6e9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movapd %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rdi, %r12
callq 0x38a4a
movl %eax, %ebp
leaq 0x1ca1e(%rip), %rsi     # 0xab95b
movq %r12, %rdi
callq 0x40f0
testq %rax, %rax
je 0x8f04a
testl %ebp, %ebp
jle 0x8f069
movq %rax, %r15
movapd 0x10(%rsp), %xmm1
movapd %xmm1, %xmm0
movapd (%rsp), %xmm2
subsd %xmm2, %xmm0
mulsd 0x16e6c(%rip), %xmm0    # 0xa5de0
movapd %xmm2, %xmm3
subsd %xmm0, %xmm3
movsd %xmm3, 0x28(%rsp)
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
leaq 0x1aced(%rip), %r12     # 0xa9c80
leaq 0x38(%rsp), %r13
movapd %xmm1, %xmm5
movapd %xmm2, (%rsp)
movapd %xmm1, 0x10(%rsp)
movapd %xmm5, 0x40(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4070
movapd 0x40(%rsp), %xmm5
movsd 0x38(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
cmpnlesd %xmm0, %xmm1
movapd %xmm1, %xmm2
movapd (%rsp), %xmm4
andpd %xmm4, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
movapd %xmm0, %xmm2
cmpnlesd 0x30(%rsp), %xmm2
movapd %xmm2, %xmm3
andnpd %xmm0, %xmm2
cmpnlesd %xmm0, %xmm5
cmpnlesd %xmm4, %xmm0
movapd %xmm4, %xmm6
movapd %xmm0, %xmm4
andnpd %xmm1, %xmm4
andpd %xmm6, %xmm0
orpd %xmm4, %xmm0
movapd 0x10(%rsp), %xmm4
andpd %xmm4, %xmm3
orpd %xmm3, %xmm2
movapd %xmm5, %xmm1
andnpd %xmm2, %xmm1
andpd %xmm4, %xmm5
orpd %xmm1, %xmm5
movapd %xmm5, %xmm1
movapd %xmm0, %xmm2
decl %ebp
jne 0x8ef9c
jmp 0x8f074
leaq 0x171b9(%rip), %rdi     # 0xa620a
movq %r12, %rsi
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4030
movapd (%rsp), %xmm0
movapd 0x10(%rsp), %xmm5
movsd %xmm0, (%r14)
movsd %xmm5, (%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %ebp
movq %rdi, 0x18(%rsp)
callq 0x8e3a1
testl %ebp, %ebp
jle 0x8f348
movsd %xmm0, 0x28(%rsp)
movl %ebp, %eax
movq %rax, 0x20(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x1a9fa(%rip), %r15     # 0xa9c80
leaq 0x30(%rsp), %r12
xorl %ebx, %ebx
xorl %ebp, %ebp
movq 0x18(%rsp), %r13
movq (%r13,%rbx,8), %rdi
callq 0x38a4a
movl %eax, %r14d
movq (%r13,%rbx,8), %rdi
leaq 0x1c6ae(%rip), %rsi     # 0xab95b
callq 0x40f0
testq %rax, %rax
je 0x8f367
movq %rax, %r13
movl %ebp, 0x14(%rsp)
movl %r14d, %ebp
testl %r14d, %r14d
movsd 0x8(%rsp), %xmm0
jle 0x8f310
movsd %xmm0, 0x8(%rsp)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %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)
movsd 0x8(%rsp), %xmm0
decl %ebp
jne 0x8f2d0
movsd %xmm0, 0x8(%rsp)
movl 0x14(%rsp), %ebp
addl %r14d, %ebp
movq %r13, %rdi
callq 0x42a0
incq %rbx
cmpq 0x20(%rsp), %rbx
jne 0x8f28f
decl %ebp
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
jmp 0x8f350
movsd 0x221d8(%rip), %xmm0    # 0xb1528
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x8f360
sqrtsd %xmm0, %xmm0
jmp 0x8f382
callq 0x4300
jmp 0x8f382
movq 0x18(%rsp), %rax
movq (%rax,%rbx,8), %rsi
leaq 0x16e93(%rip), %rdi     # 0xa620a
xorl %eax, %eax
callq 0x4030
xorpd %xmm0, %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r12d
movl %esi, %ebx
leaq 0x1c5b9(%rip), %rsi     # 0xab96d
callq 0x40f0
movq %rax, (%rsp)
testq %rax, %rax
je 0x8f49e
testl %ebx, %ebx
jle 0x8f495
xorps %xmm0, %xmm0
cvtsi2sd %r12d, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
testl %r12d, %r12d
jle 0x8f44f
movl %ebx, %r14d
xorl %ebp, %ebp
movl %r12d, %ebx
xorl %eax, %eax
callq 0x3af20
movl %eax, %r13d
xorl %eax, %eax
callq 0x3af20
imull %r13d, %eax
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rcx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
subl %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x1a7ba(%rip), %xmm0    # 0xa9be8
xorl %eax, %eax
movsd 0x18(%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %al
addl %eax, %ebp
decl %ebx
jne 0x8f3ec
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movl %r14d, %ebx
jmp 0x8f453
xorpd %xmm0, %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
leaq 0x19d2b(%rip), %rdx     # 0xa919b
callq 0x3a535
movq (%rsp), %rdi
movq %r14, %rsi
movsd 0x10(%rsp), %xmm0
movb $0x1, %al
callq 0x42e0
incl %r15d
cmpl %ebx, %r15d
jne 0x8f3df
movq (%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_O3/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
movl $0xc, %ebx
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
movsd 0x16044(%rip), %xmm1    # 0xa5520
callq 0x3af6a
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
decl %ebx
jne 0x8f4ca
addsd 0x18815(%rip), %xmm0    # 0xa7d18
mulsd 0x10(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a148, %rsp          # imm = 0x7A148
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebx
leaq 0x1c432(%rip), %rsi     # 0xab96d
callq 0x40f0
testq %rax, %rax
je 0x8f5cf
movq %rax, %r14
testl %ebx, %ebx
jle 0x8f5c7
xorl %r13d, %r13d
leaq 0x19c41(%rip), %r15     # 0xa919b
leaq 0x20(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3a535
movl $0xc, %ebp
xorpd %xmm1, %xmm1
movsd %xmm1, 0x18(%rsp)
xorpd %xmm0, %xmm0
movsd 0x15f99(%rip), %xmm1    # 0xa5520
callq 0x3af6a
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
decl %ebp
jne 0x8f575
addsd 0x18776(%rip), %xmm1    # 0xa7d18
mulsd 0x10(%rsp), %xmm1
addsd 0x8(%rsp), %xmm1
movq %r14, %rdi
movq %r12, %rsi
movapd %xmm1, %xmm0
movb $0x1, %al
callq 0x42e0
incl %r13d
cmpl %ebx, %r13d
jne 0x8f55f
movq %r14, %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_O3/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, %r15
movq %rdi, %r14
callq 0x38a4a
movl %eax, %ebx
leaq 0x1c355(%rip), %rsi     # 0xab95b
movq %r14, %rdi
callq 0x40f0
testq %rax, %rax
je 0x8f6e3
movq %rax, %r12
movslq %ebx, %rdi
shlq $0x3, %rdi
leaq 0x1c66a(%rip), %rsi     # 0xabc92
movl $0x5, %edx
callq 0x3a0e1
movq %rax, 0x8(%rsp)
movl %ebx, %r14d
testl %ebx, %ebx
jle 0x8f666
movl %r14d, %ebx
leaq 0x1a638(%rip), %r13     # 0xa9c80
movq 0x8(%rsp), %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x4070
addq $0x8, %rbp
decq %rbx
jne 0x8f64d
movq %r12, %rdi
callq 0x42a0
leaq 0x1c2f8(%rip), %rsi     # 0xab96d
movq %r15, %rdi
callq 0x40f0
testq %rax, %rax
je 0x8f6e3
movq %rax, %r15
movl %r14d, %ebp
testl %r14d, %r14d
movq 0x8(%rsp), %r12
jle 0x8f6d3
leaq 0x10(%rsp), %r13
movl %ebp, %ebx
xorl %eax, %eax
callq 0x3af20
cltd
idivl %ebp
movl %edx, %ebp
movq %r13, %rdi
xorl %esi, %esi
leaq 0x19aea(%rip), %rdx     # 0xa919b
callq 0x3a535
movslq %ebp, %rax
movl %r14d, %ebp
movsd (%r12,%rax,8), %xmm0
movq %r15, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x42e0
decl %ebx
jne 0x8f699
movq %r15, %rdi
callq 0x42a0
movq %r12, %rdi
callq 0x3a180
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8f70b
cmpl $0x1, %edx
jne 0x8f71b
leaq 0x2213c(%rip), %rdi     # 0xb1845
jmp 0x8f712
leaq 0x2210d(%rip), %rdi     # 0xb181f
addq $0x18, %rsp
jmp 0x4090
movq %rdi, %rax
movq %rsi, %rdi
callq *%rax
movsd %xmm0, 0x10(%rsp)
leaq 0x198be(%rip), %rdi     # 0xa8fee
callq 0x34a17
leaq 0x161ec(%rip), %rdi     # 0xa5928
callq 0x549ba
movsd 0x15dd7(%rip), %xmm1    # 0xa5520
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
leaq 0x16f0b(%rip), %rdi     # 0xa6665
callq 0x54bec
movsd 0x10(%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
jae 0x8f78a
testl %eax, %eax
je 0x8f77d
leaq 0x22184(%rip), %rdi     # 0xb18fc
callq 0x4090
leaq 0x19864(%rip), %rdi     # 0xa8fe8
xorpd %xmm0, %xmm0
jmp 0x8f7a9
testl %eax, %eax
je 0x8f79a
leaq 0x220d8(%rip), %rdi     # 0xb186d
callq 0x4090
leaq 0x19847(%rip), %rdi     # 0xa8fe8
movsd 0x15d77(%rip), %xmm0    # 0xa5520
addq $0x18, %rsp
jmp 0x34a17
// File: /workspace/github_c_makefile_star2_O3/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
movq $0x0, 0x10(%rsp)
cmpl $0x2, %edx
jl 0x8f81e
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x16154(%rip), %rdi     # 0xa5928
callq 0x549ba
movsd 0x15d3f(%rip), %xmm1    # 0xa5520
subsd %xmm0, %xmm1
leaq 0xc(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movapd %xmm1, %xmm0
callq *%rbx
testl %eax, %eax
je 0x8f82f
movl 0xc(%rsp), %ebx
leaq 0x16e5e(%rip), %rdi     # 0xa6665
callq 0x54bec
cmpl $0x1, %ebx
jne 0x8f872
testl %eax, %eax
je 0x8f893
leaq 0x22124(%rip), %rdi     # 0xb1940
jmp 0x8f88e
leaq 0x2206b(%rip), %rdi     # 0xb1890
callq 0x4090
jmp 0x8f8ca
leaq 0x16e2f(%rip), %rdi     # 0xa6665
callq 0x54bec
testl %eax, %eax
je 0x8f865
leaq 0x1ce75(%rip), %rdi     # 0xac6bb
callq 0x54920
cmpl $0x2, %eax
leaq 0x220a7(%rip), %rax     # 0xb18fc
leaq 0x22053(%rip), %rdi     # 0xb18af
cmoveq %rax, %rdi
callq 0x4090
leaq 0x1977c(%rip), %rdi     # 0xa8fe8
xorpd %xmm0, %xmm0
jmp 0x8f8c5
testl %eax, %eax
je 0x8f893
leaq 0x1ce3e(%rip), %rdi     # 0xac6bb
callq 0x54920
cmpl $0x2, %eax
jne 0x8f893
leaq 0x2208b(%rip), %rdi     # 0xb1919
callq 0x4090
leaq 0x1ce21(%rip), %rdi     # 0xac6bb
callq 0x54920
cmpl $0x1, %eax
jne 0x8f8b5
leaq 0x1973d(%rip), %rdi     # 0xa8fe8
movsd 0x15c6d(%rip), %xmm0    # 0xa5520
jmp 0x8f8c5
xorps %xmm0, %xmm0
cvtsi2sdl 0xc(%rsp), %xmm0
leaq 0x19723(%rip), %rdi     # 0xa8fe8
callq 0x34a17
movsd 0x10(%rsp), %xmm0
leaq 0x19717(%rip), %rdi     # 0xa8fee
callq 0x34a17
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x30309
leaq 0x45bdf(%rip), %r13     # 0xd5870
movq (%r13), %rcx
movl 0x10(%rcx), %esi
incl %esi
movl %eax, %edi
callq 0x3d79d
movq %rdx, %r12
movq %rax, (%rsp)
testl %eax, %eax
jle 0x8fd00
movq (%rsp), %rbp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movq (%r13), %rax
movl 0x10(%rax), %eax
xorl %r15d, %r15d
movq (%r12,%r15,8), %rdi
movq (%r14,%r15,8), %rsi
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x4310
movq %rbx, %rdi
callq 0x2f33a
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq (%r12,%r15,8), %rcx
movq (%r13), %rax
movslq 0x10(%rax), %rax
movsd %xmm0, (%rcx,%rax,8)
movq 0x10(%rbx), %rbx
incq %r15
cmpq %r15, %rbp
jne 0x8fcc0
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_O3/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 0x8fd16
movl (%rbx), %ecx
xorpd %xmm6, %xmm6
cmpl $0x2, %ecx
jl 0x90018
decl %ecx
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm2
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
movsd 0x15d35(%rip), %xmm0    # 0xa5d18
movsd 0x18(%rax,%rdx), %xmm3
movsd 0x20(%rax,%rdx), %xmm4
addsd %xmm4, %xmm2
movapd %xmm3, %xmm5
subsd %xmm1, %xmm5
mulsd %xmm2, %xmm5
mulsd %xmm0, %xmm5
addsd %xmm5, %xmm6
addq $0x18, %rdx
movapd %xmm3, %xmm1
movapd %xmm4, %xmm2
cmpq %rdx, %rcx
jne 0x8ffe3
movsd %xmm6, (%rsp)
movq %rax, %rdi
callq 0x3a180
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0x4582b(%rip), %r13     # 0xd5870
movq (%r13), %rax
movl 0x10(%rax), %eax
testl %eax, %eax
jle 0x900ad
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
movl %ecx, %r12d
leal 0x1(%r12), %ebp
cmpl %eax, %ebp
movl %ebp, 0xc(%rsp)
jge 0x9009f
movsd %xmm1, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebp, %ecx
movq %rbx, %r8
callq 0x8ffa1
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
incl %ebp
movq (%r13), %rax
movl 0x10(%rax), %eax
cmpl %eax, %ebp
jl 0x9006f
movl 0xc(%rsp), %ecx
cmpl %eax, %ecx
jl 0x9005f
addsd %xmm1, %xmm1
jmp 0x900b1
xorpd %xmm1, %xmm1
leal -0x1(%rax), %ecx
imull %eax, %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
testl %edi, %edi
jle 0x90167
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movsd 0x15429(%rip), %xmm1    # 0xa5520
movabsq $0x100000000, %r9       # imm = 0x100000000
xorpd %xmm2, %xmm2
xorl %r10d, %r10d
xorl %r8d, %r8d
xorl %edx, %edx
movq (%rsi,%r10,8), %r11
movsd (%r11), %xmm4
movsd 0x10(%r11), %xmm3
ucomisd %xmm0, %xmm4
jae 0x9013a
ucomisd %xmm1, %xmm3
jne 0x90147
jp 0x90147
movq %rdx, %r11
andq %rcx, %r11
movl %edx, %edx
addq %r11, %rdx
addq %r9, %rdx
jmp 0x90155
ucomisd %xmm2, %xmm3
jne 0x90153
jp 0x90153
incl %r8d
jmp 0x90155
leal 0x1(%rdx), %r11d
andq %rcx, %rdx
orq %r11, %rdx
jmp 0x90155
incl %eax
incq %r10
cmpq %r10, %rdi
jne 0x9010d
shlq $0x20, %r8
movl %eax, %eax
orq %r8, %rax
retq
xorl %edx, %edx
retq