LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/dimreduction.c
// Function: local_covariance_matrix
matrix local_covariance_matrix(Datasetptr d, Instanceptr inst, Instanceptr traindata, matrix neighborhood, int index)
{
 /*!Last Changed 19.01.2008*/
 matrix C;
 int i, j, t, k, p, size = matrix_sum_row(neighborhood, index);
 Instanceptr temp1, temp2;
 double sum;
 C = matrix_alloc(size, size);
 for (i = 0, j = 0, temp1 = traindata; i < neighborhood.row; i++, temp1 = temp1->next)
   if (neighborhood.values[index][i] == 1)
    {
     for (t = 0, k = 0, temp2 = traindata; t < neighborhood.row; t++, temp2 = temp2->next)
       if (neighborhood.values[index][t] == 1)
        {
         sum = 0.0;
         for (p = 0; p < d->multifeaturecount - 1; p++)
           sum += (real_feature(inst, p) - real_feature(temp1, p)) * (real_feature(inst, p) - real_feature(temp2, p));
         C.values[j][k] = sum;
         k++;
        }
     j++;
    }
 return C;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %ebx
movq %rcx, %r14
movq %rdx, 0x18(%rsp)
movq %rsi, %r12
movq %rdi, %r13
movq %rcx, %rdi
movq %r8, 0x30(%rsp)
movq %r8, %rsi
movl %r9d, %edx
callq 0x3ecbf
cvttsd2si %xmm0, %edi
movl %edi, %esi
callq 0x3c6e5
movq %rax, 0x38(%rsp)
movq %rdx, 0x20(%rsp)
movq %r14, (%rsp)
testl %r14d, %r14d
jle 0x1f144
movslq %ebx, %rax
movq %rax, 0x28(%rsp)
movq (%rsp), %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, (%rsp)
xorl %edx, %edx
xorl %esi, %esi
movq 0x18(%rsp), %r15
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax,%rdx,8), %xmm0
ucomisd 0x834fd(%rip), %xmm0    # 0xa2520
jne 0x1f133
jp 0x1f133
movq %rdx, 0x40(%rsp)
movl %esi, 0x14(%rsp)
movslq %esi, %rax
movq %rax, 0x48(%rsp)
xorl %r14d, %r14d
movq 0x18(%rsp), %rbp
xorl %edx, %edx
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax,%r14,8), %xmm0
ucomisd 0x834ba(%rip), %xmm0    # 0xa2520
jne 0x1f117
jp 0x1f117
movq %rdx, 0x50(%rsp)
xorpd %xmm0, %xmm0
cmpl $0x2, 0x1c0(%r13)
jl 0x1f0fa
xorl %ebx, %ebx
movsd %xmm0, 0x60(%rsp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x2e4b6
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
movl %ebx, %esi
callq 0x2e4b6
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x2e4b6
movsd %xmm0, 0x58(%rsp)
movq %rbp, %rdi
movl %ebx, %esi
callq 0x2e4b6
movsd 0x58(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0x60(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm1
addsd %xmm1, %xmm0
incl %ebx
movl 0x1c0(%r13), %eax
decl %eax
cmpl %eax, %ebx
jl 0x1f087
movq 0x20(%rsp), %rax
movq 0x48(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rsp), %rdx
movslq %edx, %rdx
movsd %xmm0, (%rax,%rdx,8)
incl %edx
incq %r14
movq 0x10(%rbp), %rbp
cmpq (%rsp), %r14
jne 0x1f04a
movl 0x14(%rsp), %esi
incl %esi
movq 0x40(%rsp), %rdx
incq %rdx
movq 0x10(%r15), %r15
cmpq (%rsp), %rdx
jne 0x1f008
movq 0x38(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/dimreduction.c
// Function: local_contributions_of_neighbors
matrix local_contributions_of_neighbors(Datasetptr d, Instanceptr traindata, matrix neighborhood)
{
 /*!Last Changed 19.01.2008*/
 matrix w, C;
 Instanceptr tmp = traindata;
 double denominator, nominator;
 int i = 0, j, t;
 w = matrix_alloc(neighborhood.row, neighborhood.col);
 while (tmp)
  {
   C = local_covariance_matrix(d, tmp, traindata, neighborhood, i);
   matrix_inverse(&C);
   denominator = matrix_sum_of_elements(C);
   t = 0;
   for (j = 0; j < neighborhood.col; j++)
     if (neighborhood.values[i][j])
      {
       nominator = matrix_sum_row(C, t);
       w.values[i][j] = nominator / denominator;
       t++;
      }
     else
       w.values[i][j] = 0.0;
   i++;
   tmp = tmp->next;
   matrix_free(C);
  }
 return w;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
movq %rdx, %r13
shrq $0x20, %r13
movq %rdx, 0x30(%rsp)
movl %edx, %edi
movl %r13d, %esi
callq 0x3c6e5
movq %rax, 0x20(%rsp)
movq %rdx, %rbp
movq %r14, 0x18(%rsp)
testq %r14, %r14
je 0x1f277
xorl %r12d, %r12d
movq 0x18(%rsp), %r14
movq 0x28(%rsp), %rdi
movq %r14, 0x38(%rsp)
movq %r14, %rsi
movq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq %rbx, %r8
movl %r12d, %r9d
callq 0x1ef96
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3f648
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3e9ee
movsd %xmm0, 0x40(%rsp)
testl %r13d, %r13d
jle 0x1f253
xorl %r15d, %r15d
xorl %r14d, %r14d
movq (%rbx,%r12,8), %rax
movsd (%rax,%r15,8), %xmm0
ucomisd 0x83af6(%rip), %xmm0    # 0xa2d08
jne 0x1f216
jnp 0x1f23e
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %r14d, %edx
callq 0x3ecbf
divsd 0x40(%rsp), %xmm0
movq (%rbp,%r12,8), %rax
movsd %xmm0, (%rax,%r15,8)
incl %r14d
jmp 0x1f24b
movq (%rbp,%r12,8), %rax
movq $0x0, (%rax,%r15,8)
incq %r15
cmpq %r15, %r13
jne 0x1f200
incq %r12
movq 0x38(%rsp), %r14
movq 0x10(%r14), %r14
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3dbad
testq %r14, %r14
jne 0x1f1aa
movq 0x20(%rsp), %rax
movq %rbp, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/dimreduction.c
// Function: calculate_m_for_lle
matrix calculate_m_for_lle(matrix w)
{
 /*!Last Changed 19.01.2008*/
 int i, j, k;
 double sum;
 matrix M = matrix_alloc(w.row, w.col);
 for (i = 0; i < w.row; i++)
   for (j = 0; j < w.col; j++)
    {
     sum = kronecker_delta(i, j) - w.values[i][j] - w.values[j][i];
     for (k = 0; k < w.row; k++)
       sum += w.values[k][i] * w.values[k][j];
     M.values[i][j] = sum;
    }
 return M;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %r15
shrq $0x20, %r15
movl %r15d, %esi
callq 0x3c6e5
movq %rax, (%rsp)
movq %rdx, %r13
testl %r14d, %r14d
jle 0x1f327
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
testl %r15d, %r15d
jle 0x1f31f
xorl %r12d, %r12d
movl %ebp, %edi
movl %r12d, %esi
callq 0x39518
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq (%rbx,%rbp,8), %rax
subsd (%rax,%r12,8), %xmm0
movq (%rbx,%r12,8), %rax
subsd (%rax,%rbp,8), %xmm0
xorl %eax, %eax
movq (%rbx,%rax,8), %rcx
movsd (%rcx,%rbp,8), %xmm1
mulsd (%rcx,%r12,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq %rax, %r14
jne 0x1f2f1
movq (%r13,%rbp,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
cmpq %r15, %r12
jne 0x1f2cb
incq %rbp
cmpq %r14, %rbp
jne 0x1f2c3
movq (%rsp), %rax
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/distributions.c
// Function: beta
double beta(double* x, int count)
{
 /*Last Changed 28.02.2007*/
 double sum = 0.0, result = 0.0;
 int i;
 for (i = 0; i < count; i++)
  {
   result += gammln(x[i]);
   sum += x[i];
  }
 result -= gammln(sum);
 return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testl %esi, %esi
jle 0x1f398
movq %rdi, %rbx
movl %esi, %r14d
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %r15d, %r15d
xorpd %xmm1, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd (%rbx,%r15,8), %xmm0
callq 0x1f3c5
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd 0x8(%rsp), %xmm1
addsd (%rbx,%r15,8), %xmm1
incq %r15
cmpq %r15, %r14
jne 0x1f363
jmp 0x1f3a5
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movapd %xmm1, %xmm0
callq 0x1f3c5
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/distributions.c
// Function: gammln
double gammln(double x)
{
 /*Last Changed 28.02.2007*/
 /*Returns ln of gamma(x)*/
 double y,tmp,ser;
 double cof[6]={76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, 0.1208650973866179e-2, -0.5395239384953e-5};
 int j;
 y = x;
 tmp = x + 5.5;
 tmp -= (x + 0.5) * log(tmp);
 ser = 1.000000000190015;
 for (j = 0; j <= 5; j++) 
   ser += cof[j] / ++y;
 return -tmp + log(2.5066282746310005 * ser / x);
}

// Assembly:
subq $0x48, %rsp
movapd %xmm0, %xmm1
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
movapd %xmm0, 0x20(%rsp)
movapd %xmm0, 0x30(%rsp)
movabsq $0x40530b869f76170a, %rax # imm = 0x40530B869F76170A
movq %rax, 0x10(%rsp)
movabsq $-0x3faa5fa8d4ebc9aa, %rax # imm = 0xC055A0572B143656
movq %rax, 0x18(%rsp)
movabsq $0x4038039bf13b4cc6, %rax # imm = 0x4038039BF13B4CC6
movq %rax, 0x20(%rsp)
movabsq $-0x400c4acb72323374, %rax # imm = 0xBFF3B5348DCDCC8C
movq %rax, 0x28(%rsp)
movabsq $0x3f53cd7319ec12d8, %rax # imm = 0x3F53CD7319EC12D8
movq %rax, 0x30(%rsp)
movabsq $-0x41295ee7e3f16778, %rax # imm = 0xBED6A1181C0E9888
movq %rax, 0x38(%rsp)
movsd 0x855ad(%rip), %xmm0    # 0xa49f8
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
callq 0x4160
movsd 0x8(%rsp), %xmm5
movapd %xmm0, %xmm1
movsd 0x85595(%rip), %xmm0    # 0xa4a00
xorl %eax, %eax
movsd 0x830ab(%rip), %xmm2    # 0xa2520
movapd %xmm5, %xmm3
movsd 0x10(%rsp,%rax,8), %xmm4
addsd %xmm2, %xmm3
divsd %xmm3, %xmm4
addsd %xmm4, %xmm0
incq %rax
cmpq $0x6, %rax
jne 0x1f479
movsd 0x8387c(%rip), %xmm2    # 0xa2d18
addsd %xmm5, %xmm2
mulsd %xmm1, %xmm2
movsd (%rsp), %xmm1
subsd %xmm2, %xmm1
movsd %xmm1, (%rsp)
mulsd 0x8554e(%rip), %xmm0    # 0xa4a08
divsd %xmm5, %xmm0
callq 0x4160
subsd (%rsp), %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/distributions.c
// Function: z_normal
double z_normal(double z)
{/*Returns the probability*/
 double  y, x, w;
 if (z == 0.0)
   x = 0.0;
 else
  {
   y = 0.5 * fabs (z);
   if (y >= (Z_MAX * 0.5))
     x = 1.0;
   else
     if (y < 1.0)
      {
       w = y*y;
       x = ((((((((0.000124818987 * w-0.001075204047) * w +0.005198775019) * w-0.019198292004) * w +0.059054035642) * w-0.151968751364) * w +0.319152932694) * w-0.531923007300) * w +0.797884560593) * y * 2.0;
      }
     else
      {
       y -= 2.0;
       x = (((((((((((((-0.000045255659 * y+0.000152529290) * y -0.000019538132) * y-0.000676904986) * y +0.001390604284) * y-0.000794620820) * y -0.002034254874) * y+0.006549791214) * y -0.010557625006) * y+0.011630447319) * y -0.009279453341) * y+0.005353579108) * y -0.002141268741) * y+0.000535310849) * y +0.999936657524;
      }
  }
 if (z > 0.0)
   return ((x + 1.0) * 0.5);
 else
   return ((1.0 - x) * 0.5);
}

// Assembly:
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
xorpd %xmm2, %xmm2
jne 0x1f788
jnp 0x1f8ed
movapd 0x83a50(%rip), %xmm3    # 0xa31e0
andpd %xmm1, %xmm3
mulsd 0x8357c(%rip), %xmm3    # 0xa2d18
movsd 0x82d7c(%rip), %xmm2    # 0xa2520
ucomisd 0x85284(%rip), %xmm3    # 0xa4a30
jae 0x1f8ed
ucomisd %xmm3, %xmm2
jbe 0x1f835
movapd %xmm3, %xmm4
mulsd %xmm3, %xmm4
movsd 0x852f0(%rip), %xmm2    # 0xa4ab8
mulsd %xmm4, %xmm2
addsd 0x852ec(%rip), %xmm2    # 0xa4ac0
mulsd %xmm4, %xmm2
addsd 0x852e8(%rip), %xmm2    # 0xa4ac8
mulsd %xmm4, %xmm2
addsd 0x852e4(%rip), %xmm2    # 0xa4ad0
mulsd %xmm4, %xmm2
addsd 0x852e0(%rip), %xmm2    # 0xa4ad8
mulsd %xmm4, %xmm2
addsd 0x852dc(%rip), %xmm2    # 0xa4ae0
mulsd %xmm4, %xmm2
addsd 0x852d8(%rip), %xmm2    # 0xa4ae8
mulsd %xmm4, %xmm2
addsd 0x852d4(%rip), %xmm2    # 0xa4af0
mulsd %xmm4, %xmm2
addsd 0x852d0(%rip), %xmm2    # 0xa4af8
mulsd %xmm3, %xmm2
addsd %xmm2, %xmm2
jmp 0x1f8ed
addsd 0x851fb(%rip), %xmm3    # 0xa4a38
movsd 0x851fb(%rip), %xmm2    # 0xa4a40
mulsd %xmm3, %xmm2
addsd 0x851f7(%rip), %xmm2    # 0xa4a48
mulsd %xmm3, %xmm2
addsd 0x851f3(%rip), %xmm2    # 0xa4a50
mulsd %xmm3, %xmm2
addsd 0x851ef(%rip), %xmm2    # 0xa4a58
mulsd %xmm3, %xmm2
addsd 0x851eb(%rip), %xmm2    # 0xa4a60
mulsd %xmm3, %xmm2
addsd 0x851e7(%rip), %xmm2    # 0xa4a68
mulsd %xmm3, %xmm2
addsd 0x851e3(%rip), %xmm2    # 0xa4a70
mulsd %xmm3, %xmm2
addsd 0x851df(%rip), %xmm2    # 0xa4a78
mulsd %xmm3, %xmm2
addsd 0x851db(%rip), %xmm2    # 0xa4a80
mulsd %xmm3, %xmm2
addsd 0x851d7(%rip), %xmm2    # 0xa4a88
mulsd %xmm3, %xmm2
addsd 0x851d3(%rip), %xmm2    # 0xa4a90
mulsd %xmm3, %xmm2
addsd 0x851cf(%rip), %xmm2    # 0xa4a98
mulsd %xmm3, %xmm2
addsd 0x851cb(%rip), %xmm2    # 0xa4aa0
mulsd %xmm3, %xmm2
addsd 0x851c7(%rip), %xmm2    # 0xa4aa8
mulsd %xmm3, %xmm2
addsd 0x851c3(%rip), %xmm2    # 0xa4ab0
movapd 0x838db(%rip), %xmm3    # 0xa31d0
xorpd %xmm2, %xmm3
cmpltsd %xmm1, %xmm0
andpd %xmm0, %xmm2
andnpd %xmm3, %xmm0
orpd %xmm2, %xmm0
addsd 0x82c0e(%rip), %xmm0    # 0xa2520
mulsd 0x833fe(%rip), %xmm0    # 0xa2d18
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/distributions.c
// Function: chi_square_inverse
double chi_square_inverse(double p,int freedom)
{
 double  minchisq = 0.0;
 double  maxchisq = CHI_MAX;
 double  chisqval;
 if (p <= 0.0)
   return (maxchisq);
 else
   if (p >= 1.0)
     return (0.0);
 chisqval = freedom / sqrt (p);    /* fair first value */
 while (maxchisq - minchisq > CHI_EPSILON)
  {
   if (chi_square (freedom , chisqval) < p)
     maxchisq = chisqval;
   else
     minchisq = chisqval;
   chisqval = (maxchisq + minchisq) * 0.5;
  }
 return (chisqval);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jae 0x1f95f
ucomisd 0x82bee(%rip), %xmm0    # 0xa2520
jae 0x1f9f7
movl %edi, %ebx
xorps %xmm2, %xmm2
cvtsi2sd %edi, %xmm2
xorpd %xmm3, %xmm3
xorps %xmm1, %xmm1
movaps %xmm1, 0x20(%rsp)
ucomisd %xmm3, %xmm0
movsd %xmm0, 0x10(%rsp)
jb 0x1f96c
sqrtsd %xmm0, %xmm0
jmp 0x1f97b
movsd 0x85199(%rip), %xmm2    # 0xa4b00
jmp 0x1f9f7
movapd %xmm2, (%rsp)
callq 0x4300
movapd (%rsp), %xmm2
divsd %xmm0, %xmm2
movsd 0x85179(%rip), %xmm1    # 0xa4b00
movsd %xmm1, 0x18(%rsp)
movapd %xmm2, (%rsp)
movl %ebx, %edi
movapd %xmm2, %xmm0
callq 0x1f4cd
movapd (%rsp), %xmm3
movsd 0x10(%rsp), %xmm2
ucomisd %xmm0, %xmm2
movapd %xmm3, %xmm1
ja 0x1f9b8
movsd 0x18(%rsp), %xmm1
cmpltsd %xmm2, %xmm0
movapd 0x20(%rsp), %xmm4
andpd %xmm0, %xmm4
andnpd %xmm3, %xmm0
orpd %xmm0, %xmm4
movapd %xmm1, %xmm2
addsd %xmm4, %xmm2
mulsd 0x83339(%rip), %xmm2    # 0xa2d18
movapd %xmm1, %xmm0
movapd %xmm4, 0x20(%rsp)
subsd %xmm4, %xmm0
ucomisd 0x85113(%rip), %xmm0    # 0xa4b08
ja 0x1f987
movapd %xmm2, %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/distributions.c
// Function: dirichlet
double dirichlet(Instanceptr x, double* alpha)
{
 /*Last Changed 28.02.2007*/
 int i;
 double result = 1.0;
 for (i = 0; i < current_dataset->multifeaturecount - 1; i++)
   result *= pow(real_feature(x, i), alpha[i] - 1);
 result /= beta(alpha, current_dataset->multifeaturecount - 1);
 return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xb2e5d(%rip), %r12     # 0xd2870
movq (%r12), %rax
movl 0x1c0(%rax), %esi
cmpl $0x2, %esi
jl 0x1fa79
movq %rdi, %r14
movsd 0x82af3(%rip), %xmm0    # 0xa2520
movsd %xmm0, (%rsp)
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x2e4b6
movsd (%rbx,%r15,8), %xmm1
addsd 0x8335a(%rip), %xmm1    # 0xa2da8
callq 0x42f0
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incq %r15
movq (%r12), %rax
movslq 0x1c0(%rax), %rsi
decq %rsi
cmpq %rsi, %r15
jl 0x1fa35
jmp 0x1fa88
decl %esi
movsd 0x82a9d(%rip), %xmm0    # 0xa2520
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x1f340
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/distributions.c
// Function: f_distribution_inverse
double f_distribution_inverse(double p, int freedom1, int freedom2)
{/*Finds the value*/
 double  fval;
 double  maxf = F_MAX;     /* maximum F ratio */
 double  minf = 0.0;       /* minimum F ratio */
 if (p <= 0.0 || p >= 1.0)
   return (0.0);
 if (freedom1 == freedom2 && freedom1 > 2500)
   return 1 + 4.0 / freedom1;
 fval = 1.0 / p;             /* the smaller the p, the larger the F */
 while (fabs (maxf - minf) > F_EPSILON)
  {
   if (f_distribution (fval, freedom1, freedom2) < p)     /* F too large */
     maxf = fval;
   else                              /* F too small */
     minf = fval;
   fval = (maxf + minf) * 0.5;
  }
 return (fval);
}

// Assembly:
xorpd %xmm3, %xmm3
ucomisd %xmm0, %xmm3
jae 0x1fe82
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movapd %xmm0, %xmm2
ucomisd 0x82779(%rip), %xmm0    # 0xa2520
jae 0x1fe7c
movl %esi, %ebp
movl %edi, %ebx
cmpl %esi, %edi
setne %al
cmpl $0x9c5, %edi            # imm = 0x9C5
setl %cl
orb %al, %cl
jne 0x1fde3
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movsd 0x83016(%rip), %xmm3    # 0xa2de8
divsd %xmm0, %xmm3
addsd 0x82742(%rip), %xmm3    # 0xa2520
jmp 0x1fe7c
movsd 0x82735(%rip), %xmm3    # 0xa2520
divsd %xmm2, %xmm3
movsd 0x84d29(%rip), %xmm1    # 0xa4b20
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movsd %xmm2, 0x8(%rsp)
movapd %xmm1, 0x10(%rsp)
movapd %xmm3, 0x20(%rsp)
movapd %xmm3, %xmm0
movl %ebx, %edi
movl %ebp, %esi
callq 0x1faa9
movapd 0x20(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
ucomisd %xmm0, %xmm2
ja 0x1fe36
movsd %xmm1, (%rsp)
cmpltsd %xmm2, %xmm0
andpd %xmm0, %xmm1
andnpd 0x10(%rsp), %xmm0
orpd %xmm1, %xmm0
movapd %xmm0, %xmm3
movsd (%rsp), %xmm4
addsd %xmm4, %xmm3
mulsd 0x82eba(%rip), %xmm3    # 0xa2d18
movapd %xmm0, %xmm1
subsd %xmm4, %xmm1
andpd 0x83372(%rip), %xmm1    # 0xa31e0
ucomisd 0x84c92(%rip), %xmm1    # 0xa4b08
movapd %xmm0, %xmm1
ja 0x1fe06
addq $0x38, %rsp
popq %rbx
popq %rbp
movapd %xmm3, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/distributions.c
// Function: normal
double normal(double x,int upper)
{
 double Alnorm,ltone=7.0,utzero=18.66,con=1.28,z,y;
 z=x;
 if (z<0)
  {
   upper=1-upper;
   z=-z;
  }
 if ((z <= ltone) || ((upper) && (z >= utzero)))
  {
   y=0.5*z*z;
   if (z>con)
     Alnorm=0.398942280385*exp(-y)/(z-3.8052*0.00000001+1.00000615302/(z+3.98064794*0.0001+1.98615381364/(z-0.151679116635+5.29330324926/(z+4.8385912808-15.1508972451/(z+0.742380924027+30.789933034/(z+3.99019417011))))));
   else
     Alnorm=0.5-z*(0.398942280444-0.399903438504*y/(y+5.75885480458-29.8213557808/(y+2.62433121679+48.6959930692/(y+5.92885724438))));
  }
 else
   Alnorm=0;
 if (!upper)
   return 1-Alnorm;
 else
   return Alnorm;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl $0x1, %ebx
subl %edi, %ebx
movapd 0x832ef(%rip), %xmm5    # 0xa31d0
xorpd %xmm0, %xmm5
ucomisd %xmm0, %xmm5
cmovbel %edi, %ebx
maxsd %xmm0, %xmm5
movsd 0x84c40(%rip), %xmm0    # 0xa4b38
ucomisd %xmm5, %xmm0
jae 0x1ff1a
testl %ebx, %ebx
sete %al
ucomisd 0x84c35(%rip), %xmm5    # 0xa4b40
setb %cl
orb %al, %cl
xorpd %xmm0, %xmm0
jne 0x2005d
movsd 0x82df6(%rip), %xmm0    # 0xa2d18
mulsd %xmm5, %xmm0
mulsd %xmm5, %xmm0
ucomisd 0x84c16(%rip), %xmm5    # 0xa4b48
jbe 0x1fff5
xorpd 0x83290(%rip), %xmm0    # 0xa31d0
movapd %xmm5, (%rsp)
callq 0x4060
mulsd 0x84c36(%rip), %xmm0    # 0xa4b88
movsd 0x84c36(%rip), %xmm1    # 0xa4b90
movapd (%rsp), %xmm6
addsd %xmm6, %xmm1
movsd 0x84c2d(%rip), %xmm2    # 0xa4b98
addsd %xmm6, %xmm2
movsd 0x84c29(%rip), %xmm3    # 0xa4ba0
addsd %xmm6, %xmm3
movsd 0x84c25(%rip), %xmm4    # 0xa4ba8
addsd %xmm6, %xmm4
movsd 0x84c21(%rip), %xmm5    # 0xa4bb0
addsd %xmm6, %xmm5
addsd 0x84c1d(%rip), %xmm6    # 0xa4bb8
movapd %xmm6, %xmm7
movsd 0x84c19(%rip), %xmm6    # 0xa4bc0
divsd %xmm7, %xmm6
addsd %xmm5, %xmm6
movsd 0x84c11(%rip), %xmm5    # 0xa4bc8
divsd %xmm6, %xmm5
addsd %xmm4, %xmm5
movsd 0x84c09(%rip), %xmm4    # 0xa4bd0
divsd %xmm5, %xmm4
addsd %xmm3, %xmm4
movsd 0x84c01(%rip), %xmm3    # 0xa4bd8
divsd %xmm4, %xmm3
addsd %xmm2, %xmm3
movsd 0x84bf9(%rip), %xmm2    # 0xa4be0
divsd %xmm3, %xmm2
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
jmp 0x2005d
movsd 0x84b53(%rip), %xmm1    # 0xa4b50
mulsd %xmm0, %xmm1
movsd 0x84b4f(%rip), %xmm2    # 0xa4b58
addsd %xmm0, %xmm2
movsd 0x84b4b(%rip), %xmm3    # 0xa4b60
addsd %xmm0, %xmm3
addsd 0x84b47(%rip), %xmm0    # 0xa4b68
movsd 0x84b47(%rip), %xmm4    # 0xa4b70
divsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd 0x84b3f(%rip), %xmm0    # 0xa4b78
divsd %xmm4, %xmm0
addsd %xmm2, %xmm0
divsd %xmm0, %xmm1
addsd 0x84b33(%rip), %xmm1    # 0xa4b80
mulsd %xmm1, %xmm5
movsd 0x82cbf(%rip), %xmm0    # 0xa2d18
subsd %xmm5, %xmm0
testl %ebx, %ebx
jne 0x20071
movsd 0x824b7(%rip), %xmm1    # 0xa2520
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/distributions.c
// Function: qtrng0
double qtrng0(double p, double v, double r)
{
 double q,t,vmax=12000,c1=0.8843,c2=0.2368,c3=1.214,c4=1.208,c5=1.4142;
 t=z_inverse(0.5+0.5*p);
 if (v<vmax)
   t=t+(t*t*t+t)/v/4;
 q=c1-c2*t;
 if (v<vmax)
   q=q-c3/v+c4*t/v;
 return t*(q*log(r-1)+c5);
}

// Assembly:
subq $0x18, %rsp
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, (%rsp)
movsd 0x827f6(%rip), %xmm1    # 0xa2d18
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
callq 0x205d6
movsd (%rsp), %xmm3
movsd 0x846c4(%rip), %xmm2    # 0xa4c00
ucomisd %xmm3, %xmm2
jbe 0x20562
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
divsd %xmm3, %xmm1
mulsd 0x8279a(%rip), %xmm1    # 0xa2cf8
addsd %xmm1, %xmm0
ucomisd %xmm3, %xmm2
movsd 0x846d2(%rip), %xmm2    # 0xa4c40
mulsd %xmm0, %xmm2
addsd 0x846ce(%rip), %xmm2    # 0xa4c48
movsd %xmm0, 0x8(%rsp)
jbe 0x205a6
movsd 0x846c6(%rip), %xmm1    # 0xa4c50
divsd %xmm3, %xmm1
addsd %xmm1, %xmm2
movsd 0x846be(%rip), %xmm1    # 0xa4c58
mulsd %xmm0, %xmm1
divsd %xmm3, %xmm1
addsd %xmm1, %xmm2
movsd %xmm2, (%rsp)
movsd 0x10(%rsp), %xmm0
addsd 0x827ef(%rip), %xmm0    # 0xa2da8
callq 0x4160
mulsd (%rsp), %xmm0
addsd 0x84695(%rip), %xmm0    # 0xa4c60
mulsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/distributions.c
// Function: z_inverse
double z_inverse(double p)
{/*Returns the critical value given the probability*/
 double  minz = -Z_MAX;    /* minimum of range of z */
 double  maxz = Z_MAX;     /* maximum of range of z */
 double  zval = 0.0;       /* computed/returned z value */
 double  pval;     /* prob (z) function, pval := poz (zval) */
 if (p <= 0.0 || p >= 1.0)
   return (0.0);
 while (maxz - minz > Z_EPSILON)
  {
   pval = z_normal (zval);
   if (pval > p)
     maxz = zval;
   else
     minz = zval;
   zval = (maxz + minz) * 0.5;
  }
 return (zval);
}

// Assembly:
movapd %xmm0, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm3, %xmm0
jae 0x2068e
subq $0x38, %rsp
ucomisd 0x81f2c(%rip), %xmm3    # 0xa2520
jae 0x2068a
movsd 0x84666(%rip), %xmm1    # 0xa4c68
movsd 0x84666(%rip), %xmm2    # 0xa4c70
xorpd %xmm0, %xmm0
movsd %xmm3, (%rsp)
movsd %xmm2, 0x8(%rsp)
movapd %xmm1, 0x10(%rsp)
movapd %xmm0, 0x20(%rsp)
callq 0x1f770
movapd 0x20(%rsp), %xmm4
movsd (%rsp), %xmm3
ucomisd %xmm3, %xmm0
movapd %xmm4, %xmm1
ja 0x20645
movsd 0x8(%rsp), %xmm1
movapd %xmm3, %xmm2
cmpltsd %xmm0, %xmm2
movapd 0x10(%rsp), %xmm5
andpd %xmm2, %xmm5
andnpd %xmm4, %xmm2
orpd %xmm2, %xmm5
movapd %xmm1, %xmm0
addsd %xmm5, %xmm0
mulsd 0x826a8(%rip), %xmm0    # 0xa2d18
movapd %xmm1, %xmm2
subsd %xmm5, %xmm2
ucomisd 0x84488(%rip), %xmm2    # 0xa4b08
movapd %xmm1, %xmm2
movapd %xmm5, %xmm1
ja 0x20613
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/distributions.c
// Function: studentized_range_inverse
double studentized_range_inverse(double p, double v, double r)
{
 double pcut=0.001,result,q1,p1 = 0.0,p2 = 0.0,q2,e1,e2;
 int j,jmax=8;
 q1=qtrng0(p,v,r);
 p1=studentized_range(q1,v,r);
 result=q1;
 if (fabs(p1-p)<pcut)
   return result;
 if (p1>p)
   p1=1.75*p-0.75*p1;
 if (p1<p)
   p2=p+(p-p1)*(1-p)/(1-p1)*0.75;
 if (p2<0.80)
   p2=0.80;
 else
   if (p2>0.995)
     p2=0.995;
 q2=qtrng0(p2,v,r);
 for (j=2;j<=jmax;j++)
  {
   p2=studentized_range(q2,v,r);
   e1=p1-p;
   e2=p2-p;
   result=(e2*q1-e1*q2)/(e2-e1);
   if (fabs(e1)>=fabs(e2))
    {
     q1=q2;
     p1=p2;
    }
   if (fabs(p1-p)<5*pcut)
     return result;
   q2=result;
  }
 return result;
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x18(%rsp)
callq 0x2050b
movapd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x20077
movsd 0x18(%rsp), %xmm3
movapd %xmm0, %xmm1
subsd %xmm3, %xmm1
andpd 0x82b08(%rip), %xmm1    # 0xa31e0
movsd 0x84598(%rip), %xmm2    # 0xa4c78
ucomisd %xmm1, %xmm2
jbe 0x206f1
movapd 0x20(%rsp), %xmm0
jmp 0x2088c
movapd %xmm3, %xmm4
cmpltsd %xmm0, %xmm4
movapd %xmm0, %xmm1
mulsd 0x8457a(%rip), %xmm1    # 0xa4c80
movsd 0x8457a(%rip), %xmm2    # 0xa4c88
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
andpd %xmm4, %xmm2
andnpd %xmm0, %xmm4
orpd %xmm2, %xmm4
xorpd %xmm1, %xmm1
ucomisd %xmm4, %xmm3
jbe 0x2075c
movapd %xmm3, %xmm0
subsd %xmm4, %xmm0
movsd 0x81de4(%rip), %xmm2    # 0xa2520
movapd %xmm2, %xmm1
subsd %xmm3, %xmm1
mulsd %xmm0, %xmm1
subsd %xmm4, %xmm2
divsd %xmm2, %xmm1
mulsd 0x84538(%rip), %xmm1    # 0xa4c90
addsd %xmm3, %xmm1
movapd %xmm4, 0x30(%rsp)
movsd 0x8452e(%rip), %xmm0    # 0xa4c98
ucomisd %xmm1, %xmm0
ja 0x20786
ucomisd 0x84528(%rip), %xmm1    # 0xa4ca0
movapd %xmm1, %xmm0
jbe 0x20786
movsd 0x8451a(%rip), %xmm0    # 0xa4ca0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x2050b
movapd %xmm0, %xmm2
movl $0x7, %ebx
movapd 0x20(%rsp), %xmm1
movapd 0x30(%rsp), %xmm4
movapd %xmm4, 0x30(%rsp)
movapd %xmm1, 0x20(%rsp)
movapd %xmm2, 0x40(%rsp)
movapd %xmm2, %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x20077
movapd 0x40(%rsp), %xmm8
movapd %xmm0, %xmm1
movapd 0x30(%rsp), %xmm10
movapd %xmm10, %xmm3
movsd 0x18(%rsp), %xmm6
subsd %xmm6, %xmm3
movapd %xmm0, %xmm2
subsd %xmm6, %xmm2
movapd %xmm8, %xmm4
mulsd %xmm3, %xmm4
movapd %xmm2, %xmm0
movapd 0x20(%rsp), %xmm9
mulsd %xmm9, %xmm0
subsd %xmm4, %xmm0
movapd %xmm2, %xmm4
subsd %xmm3, %xmm4
divsd %xmm4, %xmm0
movapd 0x829b3(%rip), %xmm7    # 0xa31e0
andpd %xmm7, %xmm3
andpd %xmm7, %xmm2
movapd %xmm2, %xmm4
cmpnlesd %xmm3, %xmm4
movapd %xmm4, %xmm5
andnpd %xmm1, %xmm5
andpd %xmm10, %xmm4
orpd %xmm5, %xmm4
movapd %xmm4, %xmm1
subsd %xmm6, %xmm1
andpd %xmm7, %xmm1
movsd 0x84445(%rip), %xmm5    # 0xa4ca8
ucomisd %xmm1, %xmm5
ja 0x2088c
movapd %xmm9, %xmm1
cmpnlesd %xmm3, %xmm2
andpd %xmm2, %xmm1
andnpd %xmm8, %xmm2
orpd %xmm2, %xmm1
movapd %xmm0, %xmm2
decl %ebx
jne 0x207ac
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/distributions.c
// Function: t_distribution_inverse
double t_distribution_inverse(double p,int freedom)
{
 if (p<0.5)
   return sqrt(f_distribution_inverse(p*2,1,freedom));
 else
   return -sqrt(f_distribution_inverse((1-p)*2,1,freedom));
}

// Assembly:
pushq %rax
movl %edi, %esi
movsd 0x82431(%rip), %xmm1    # 0xa2d18
ucomisd %xmm0, %xmm1
jbe 0x2090b
addsd %xmm0, %xmm0
movl $0x1, %edi
callq 0x1fd87
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x20939
sqrtsd %xmm0, %xmm0
jmp 0x2094c
movsd 0x81c0d(%rip), %xmm1    # 0xa2520
subsd %xmm0, %xmm1
addsd %xmm1, %xmm1
movapd %xmm1, %xmm0
movl $0x1, %edi
callq 0x1fd87
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2093f
sqrtsd %xmm0, %xmm0
jmp 0x20944
popq %rax
jmp 0x4300
callq 0x4300
xorpd 0x82884(%rip), %xmm0    # 0xa31d0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/distributions.c
// Function: kolmogorov_two_sample
double kolmogorov_two_sample(int m, int n, double D)
{
 int i;
 double N, lambda, pvalue;
 N = m * n / (m + n + 0.0);
 lambda = (sqrt(N) + 0.12 + 0.11 / sqrt(N)) * D;
 pvalue = 0.0;
 for (i = 1; i <= 101; i++)
  {
   if ((i - 1) % 2 == 0)
     pvalue += 2 * exp(-2 * lambda * lambda * i * i);
   else
     pvalue -= 2 * exp(-2 * lambda * lambda * i * i);
  }
 return pvalue;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, 0x18(%rsp)
movl %esi, %eax
imull %edi, %eax
cvtsi2sd %eax, %xmm2
addl %edi, %esi
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
divsd %xmm0, %xmm2
sqrtsd %xmm2, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
movapd %xmm3, %xmm1
jae 0x209aa
movapd %xmm2, %xmm0
movsd %xmm2, 0x8(%rsp)
movsd %xmm3, 0x10(%rsp)
callq 0x4300
movsd 0x10(%rsp), %xmm3
movsd 0x8(%rsp), %xmm2
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
addsd 0x842fe(%rip), %xmm1    # 0xa4cb0
ucomisd %xmm0, %xmm2
jae 0x209d1
movapd %xmm2, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x4300
movsd 0x8(%rsp), %xmm1
movapd %xmm0, %xmm3
movsd 0x842df(%rip), %xmm0    # 0xa4cb8
divsd %xmm3, %xmm0
addsd %xmm0, %xmm1
mulsd 0x18(%rsp), %xmm1
movsd 0x84049(%rip), %xmm0    # 0xa4a38
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0x1, %ebx
movsd 0x81b16(%rip), %xmm1    # 0xa2520
xorpd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
testb $0x1, %bl
movsd %xmm1, 0x8(%rsp)
jne 0x20a42
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
callq 0x4060
addsd %xmm0, %xmm0
movsd 0x18(%rsp), %xmm1
subsd %xmm0, %xmm1
jmp 0x20a63
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
callq 0x4060
addsd %xmm0, %xmm0
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm1
addsd 0x81aab(%rip), %xmm1    # 0xa2520
incl %ebx
cmpl $0x66, %ebx
jne 0x20a0e
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/divs.c
// Function: condition_cover_instance3
int condition_cover_instance3(Instanceptr instance, Condition condition)
{
	int fno;
	fno = condition.featureindex;
 switch (current_dataset->features[fno].type)
  {
   case INTEGER:if (condition.comparison == '<' && instance->values[fno].intvalue > condition.value)
                  return NO;
                if (condition.comparison == '>' && instance->values[fno].intvalue < condition.value)
                  return NO;
                break;
   case    REAL:if (condition.comparison == '<' && instance->values[fno].floatvalue > condition.value)
                  return NO;
                if (condition.comparison == '>' && instance->values[fno].floatvalue < condition.value)
                  return NO;
                break;
   case  STRING:if (instance->values[fno].stringindex != condition.value)
                  return NO;
                break;
  }
	return YES;
}

// Assembly:
movslq %esi, %rax
shrq $0x20, %rsi
leaq 0xb1aca(%rip), %rcx     # 0xd2870
movq (%rcx), %rcx
imulq $0x340, %rax, %rdx      # imm = 0x340
movl 0x30f08(%rcx,%rdx), %ecx
cmpl $0x2, %ecx
je 0x20e0d
cmpl $0x1, %ecx
je 0x20dfb
testl %ecx, %ecx
jne 0x20e3d
cmpb $0x3e, %sil
je 0x20de8
movzbl %sil, %ecx
cmpl $0x3c, %ecx
jne 0x20e3d
movq (%rdi), %rcx
cvtsi2sdl (%rcx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x20e3a
cmpb $0x3e, %sil
jne 0x20e3d
movq (%rdi), %rcx
xorps %xmm1, %xmm1
cvtsi2sdl (%rcx,%rax,8), %xmm1
ucomisd %xmm1, %xmm0
ja 0x20e3a
jmp 0x20e3d
movq (%rdi), %rcx
cvtsi2sdl (%rcx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x20e3a
jp 0x20e3a
jmp 0x20e3d
cmpb $0x3e, %sil
je 0x20e30
movzbl %sil, %ecx
cmpl $0x3c, %ecx
jne 0x20e3d
movq (%rdi), %rcx
movsd (%rcx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x20e3a
cmpb $0x3e, %sil
jne 0x20e3d
movq (%rdi), %rcx
ucomisd (%rcx,%rax,8), %xmm0
jbe 0x20e3d
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/divs.c
// Function: m_belongs
BOOLEAN m_belongs(Instanceptr current, Condition* counter_example, int conditioncount, int M)
{
 int i;
 int NS = 0;
 Condition selector;
 for (i = 0; i < conditioncount; i++)
  {
   selector = counter_example[i];
   if (condition_cover_instance3(current, selector))
    {
     NS++;
     if (NS >= M)
       return BOOLEAN_TRUE;
    }
  }
 return BOOLEAN_FALSE;
}

// Assembly:
testl %edx, %edx
jle 0x20e90
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r12d
shlq $0x4, %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%r14,%r13), %rsi
movsd 0x8(%r14,%r13), %xmm0
movq %r15, %rdi
callq 0x20d98
testl %eax, %eax
je 0x20e83
incl %ebp
cmpl %ebx, %ebp
jge 0x20e93
addq $0x10, %r13
cmpq %r13, %r12
jne 0x20e66
xorl %eax, %eax
jmp 0x20e98
xorl %eax, %eax
retq
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/divs.c
// Function: epsilon_neighbor
BOOLEAN epsilon_neighbor(Instanceptr current, Condition** training_example, int rulecount, int* conditioncounts, int M, int epsilon)
{
 int i;
 Condition* counter_example;
 int NI = 0;
 for (i = 0; i < rulecount; i++)
  {
   counter_example = training_example[i];
   if (!m_belongs(current, counter_example, conditioncounts[i], M))
    {
     NI++;
     if (NI > epsilon)
       return BOOLEAN_FALSE;
    }
  }
 return BOOLEAN_TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, (%rsp)
movl %r8d, 0x4(%rsp)
movl $0x1, %eax
testl %edx, %edx
jle 0x20f06
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl %edx, %ebx
xorl %ebp, %ebp
xorl %r14d, %r14d
movq (%r12,%rbp,8), %rsi
movl (%r15,%rbp,4), %edx
movq %r13, %rdi
movl 0x4(%rsp), %ecx
callq 0x20e43
testl %eax, %eax
jne 0x20ef5
cmpl (%rsp), %r14d
jge 0x20f04
incl %r14d
incq %rbp
cmpq %rbp, %rbx
jne 0x20ed4
movl $0x1, %eax
jmp 0x20f06
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/divs.c
// Function: classify_using_divs_oracle
int classify_using_divs_oracle(Instanceptr current, Model_divsptr model, int M, int epsilon)
{
 int i, *votes, maxclass;
 votes = safecalloc(current_dataset->classno, sizeof(int), "classify_using_divs_oracle", 2);
 for (i = 0; i < model->datacount; i++)
   if (epsilon_neighbor(current, model->hypotheses[i], model->rulecounts[i], model->conditioncounts[i], M, epsilon))
     votes[model->classno[i]]++;
 maxclass = find_max_in_list(votes, current_dataset->classno);
 safe_free(votes);
 return maxclass;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %r15
leaq 0xb1938(%rip), %rax     # 0xd2870
movq (%rax), %rax
movslq 0x10(%rax), %rdi
leaq 0x83dba(%rip), %rdx     # 0xa4d00
movl $0x4, %esi
movl $0x2, %ecx
callq 0x39210
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x20(%r14)
jle 0x20fad
movq (%r14), %r13
movq 0x8(%r14), %r12
movq 0x18(%r14), %rbx
xorl %ebp, %ebp
movq (%r13,%rbp,8), %rsi
movl (%r12,%rbp,4), %edx
movq (%rbx,%rbp,8), %rcx
movq %r15, %rdi
movl 0x8(%rsp), %r8d
movl 0xc(%rsp), %r9d
callq 0x20ea7
testl %eax, %eax
je 0x20fa1
movq 0x10(%r14), %rax
movslq (%rax,%rbp,4), %rax
movq 0x10(%rsp), %rcx
incl (%rcx,%rax,4)
incq %rbp
movslq 0x20(%r14), %rax
cmpq %rax, %rbp
jl 0x20f6e
leaq 0xb18bc(%rip), %rax     # 0xd2870
movq (%rax), %rax
movl 0x10(%rax), %esi
movq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x37504
movl %eax, %ebx
movq %r14, %rdi
callq 0x39194
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/divs.c
// Function: tune_consistency_and_generality
void tune_consistency_and_generality(Model_divsptr model, Instanceptr cvdata)
{
 Instanceptr tmp;
 int M, epsilon, error, besterror = +INT_MAX;
 for (epsilon = 0; epsilon <= 25; epsilon += 5)
   for (M = 1; M <= 20; M++)
    {
     error = 0;
     tmp = cvdata;
     while (tmp != NULL)
      {
       if (classify_using_divs_oracle(tmp, model, M, epsilon) != give_classno(tmp))
         error++;
       tmp = tmp->next;
      }
     if (error < besterror)
      {
       besterror = error;
       model->M = M;
       model->epsilon = epsilon;
      }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r14
xorl %r15d, %r15d
movl $0x7fffffff, 0xc(%rsp)  # imm = 0x7FFFFFFF
movq %rsi, 0x10(%rsp)
movl $0x1, %ebp
xorl %ebx, %ebx
testq %r12, %r12
je 0x2103e
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x20f15
movl %eax, %r13d
movq %r12, %rdi
callq 0x2eaca
xorl %ecx, %ecx
cmpl %eax, %r13d
setne %cl
addl %ecx, %ebx
movq 0x10(%r12), %r12
jmp 0x2100d
cmpl 0xc(%rsp), %ebx
jge 0x21050
movl %ebp, 0x24(%r14)
movl %r15d, 0x28(%r14)
movl %ebx, 0xc(%rsp)
incl %ebp
cmpl $0x15, %ebp
movq 0x10(%rsp), %r12
jne 0x2100b
leal 0x5(%r15), %eax
cmpl $0x15, %r15d
movl %eax, %r15d
jb 0x21006
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/eps.c
// Function: write_image_header
void write_image_header(FILE* myfile,int width,int height)
{
 /*!Last Changed 12.09.2006*/ 
 fprintf(myfile, "%c!PS-Adobe-3.0 EPSF-3.0\n", '%');
 fprintf(myfile, "%c%cWritten by ISELL Environment\n", '%', '%');
 fprintf(myfile, "%c%cBoundingBox: 0 0 %d %d\n", '%', '%', width, height);
 fprintf(myfile, "/Times findfont 10 scalefont setfont\n");
 write_dictionary(myfile);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x82ce8(%rip), %rsi     # 0xa4f31
movl $0x25, %edx
xorl %eax, %eax
callq 0x42e0
leaq 0x82cef(%rip), %rsi     # 0xa4f4b
movq %rbx, %rdi
movl $0x25, %edx
movl $0x25, %ecx
xorl %eax, %eax
callq 0x42e0
leaq 0x82cf6(%rip), %rsi     # 0xa4f6d
movq %rbx, %rdi
movl $0x25, %edx
movl $0x25, %ecx
movl %r14d, %r8d
movl %ebp, %r9d
xorl %eax, %eax
callq 0x42e0
leaq 0x82cf1(%rip), %rdi     # 0xa4f89
movl $0x25, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x26232
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/eps.c
// Function: write_string
void write_string(FILE* myfile, int posx, int posy, char* st, ALIGN_TYPE align)
{
 /*!Last Changed 19.09.2006 added clshow and crshow*/
 /*!Last Changed 07.09.2006*/
 fprintf(myfile,"%d %d moveto\n", posx, posy);
 if (in_list(align, 3, ALIGN_ROTATE_CENTER, ALIGN_ROTATE_LEFT, ALIGN_ROTATE_RIGHT))
   fprintf(myfile, "90 rotate\n");
 switch (align)
  {
   case ALIGN_LEFT         :
   case ALIGN_ROTATE_LEFT  :fprintf(myfile,"(%s) clshow\n", st);
                            break;
   case ALIGN_CENTER       :
   case ALIGN_ROTATE_CENTER:fprintf(myfile,"(%s) cshow\n", st);
                            break;
   case ALIGN_RIGHT        :
   case ALIGN_ROTATE_RIGHT :fprintf(myfile,"(%s) crshow\n", st);
                            break;
  }
 if (in_list(align, 3, ALIGN_ROTATE_CENTER, ALIGN_ROTATE_LEFT, ALIGN_ROTATE_RIGHT))
   fprintf(myfile, "-90 rotate\n");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %ecx
movl %esi, %edx
movq %rdi, %rbx
leaq 0x822b8(%rip), %rsi     # 0xa4fe3
xorl %eax, %eax
callq 0x42e0
movl %ebp, %edi
movl $0x3, %esi
movl $0x5, %edx
movl $0x3, %ecx
movl $0x4, %r8d
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
je 0x22d6d
leaq 0x822e0(%rip), %rdi     # 0xa503b
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
cmpl $0x5, %ebp
ja 0x22d8f
movl %ebp, %eax
leaq 0x820ad(%rip), %rcx     # 0xa4e28
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x42e0
movl %ebp, %edi
movl $0x3, %esi
movl $0x5, %edx
movl $0x3, %ecx
movl $0x4, %r8d
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
je 0x22dce
leaq 0x82282(%rip), %rdi     # 0xa503a
movl $0xb, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x42c0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/eps.c
// Function: write_rectangle
void write_rectangle(FILE* myfile, int corner1x, int corner1y, int corner2x, int corner2y, FILL_TYPE filltype, int color)
{
 /*!Last Changed 18.09.2006*/
 switch (filltype)
  {
   case FILL_NONE      :fprintf(myfile, "%d %d %d %d drawrect\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_FLOOD     :fprintf(myfile, "0.0 %d %d %d %d fillrectgray\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_GRAY      :fprintf(myfile, "0.5 %d %d %d %d fillrectgray\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_VERTICAL  :fprintf(myfile, "4 %d %d %d %d verticalfill\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_HORIZONTAL:fprintf(myfile, "4 %d %d %d %d horizontalfill\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_SQUARE    :fprintf(myfile, "4 %d %d %d %d squarefill\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_COLOR     :fprintf(myfile, "%.3f %.3f %.3f %d %d %d %d fillrectcolor\n", availablecolors[color][0], availablecolors[color][1], availablecolors[color][2], corner1x, corner1y, corner2x, corner2y);
                        break;
  }
}

// Assembly:
cmpl $0x6, %r9d
ja 0x22e46
movl %r8d, %eax
movl %ecx, %r8d
movl %edx, %ecx
movl %esi, %edx
movl %r9d, %esi
leaq 0x8200f(%rip), %r9      # 0xa4dfc
movslq (%r9,%rsi,4), %rsi
addq %r9, %rsi
jmpq *%rsi
leaq 0x82249(%rip), %rsi     # 0xa5046
jmp 0x22e60
movslq 0x8(%rsp), %rsi
leaq (%rsi,%rsi,2), %rsi
leaq 0xaedb1(%rip), %r9      # 0xd1bc0
movsd (%r9,%rsi,8), %xmm0
movsd 0x8(%r9,%rsi,8), %xmm1
movsd 0x10(%r9,%rsi,8), %xmm2
leaq 0x822c2(%rip), %rsi     # 0xa50ec
movl %eax, %r9d
movb $0x3, %al
jmp 0x42e0
leaq 0x8223f(%rip), %rsi     # 0xa507a
jmp 0x22e60
leaq 0x8228e(%rip), %rsi     # 0xa50d2
jmp 0x22e60
retq
leaq 0x8220e(%rip), %rsi     # 0xa505c
jmp 0x22e60
leaq 0x82241(%rip), %rsi     # 0xa5098
jmp 0x22e60
leaq 0x82254(%rip), %rsi     # 0xa50b4
movl %eax, %r9d
xorl %eax, %eax
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/eps.c
// Function: plot_decision_tree
void plot_decision_tree(Decisionnodeptr rootnode)
{
 FILE* outfile;
 int level = 0, maxdepth = depth_of_tree(rootnode), maxwidth = decisiontree_leaf_count(rootnode) + decisiontree_node_count(rootnode);
 outfile = fopen("image.eps", "w");
 if (!outfile)
   return; 
 write_image_header(outfile, 2 * MARGIN + epsaxis, 2 * MARGIN + epsaxis);  
 level_of_decision_tree(rootnode);
 inorder_traversal_decision_tree(rootnode, &level);
 plot_decision_node(outfile, rootnode, maxdepth, maxwidth);
 write_image_footer(outfile);
 fclose(outfile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl $0x0, 0xc(%rsp)
callq 0x1dbd6
movl %eax, %ebp
movq %r14, %rdi
callq 0x1c4e8
movl %eax, %r12d
movq %r14, %rdi
callq 0x1c583
movl %eax, %r15d
leaq 0x81d06(%rip), %rdi     # 0xa4eb3
leaq 0x856ed(%rip), %rsi     # 0xa88a1
callq 0x40f0
testq %rax, %rax
je 0x23235
movq %rax, %rbx
addl %r12d, %r15d
movq %rax, %rdi
movl $0x294, %esi            # imm = 0x294
movl $0x294, %edx            # imm = 0x294
callq 0x22236
movq %r14, %rdi
callq 0x1dda0
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x1dc71
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x22ea1
leaq 0x81c5c(%rip), %rdi     # 0xa4e5e
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x81da3(%rip), %rdi     # 0xa4fbe
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
movq %rbx, %rdi
callq 0x42a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/eps.c
// Function: plot_regression_tree
void plot_regression_tree(Regressionnodeptr rootnode, int algorithm, double outputmean, double outputvariance)
{
 FILE* outfile;
 int level = 0, maxdepth = depth_of_regression_tree(rootnode), maxwidth = regressiontree_leaf_count(rootnode) + regressiontree_node_count(rootnode);
 outfile = fopen("image.eps", "w");
 if (!outfile)
   return; 
 write_image_header(outfile, 2 * MARGIN + epsaxis, 2 * MARGIN + epsaxis);    
 level_of_regression_tree(rootnode);
 inorder_traversal_regression_tree(rootnode, &level);
 plot_regression_node(outfile, rootnode, maxdepth, maxwidth, algorithm, outputmean, outputvariance);
 fclose(outfile);
 write_image_footer(outfile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebp
movq %rdi, %r14
movl $0x0, 0x4(%rsp)
callq 0x76d91
movl %eax, %r15d
movq %r14, %rdi
callq 0x74d19
movl %eax, %r13d
movq %r14, %rdi
callq 0x74d45
movl %eax, %r12d
leaq 0x7fda7(%rip), %rdi     # 0xa4eb3
leaq 0x8378e(%rip), %rsi     # 0xa88a1
callq 0x40f0
testq %rax, %rax
je 0x251a8
movq %rax, %rbx
addl %r13d, %r12d
movq %rax, %rdi
movl $0x294, %esi            # imm = 0x294
movl $0x294, %edx            # imm = 0x294
callq 0x22236
movq %r14, %rdi
callq 0x76cc3
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x76c90
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x24e35
movq %rbx, %rdi
callq 0x42a0
leaq 0x7fce1(%rip), %rdi     # 0xa4e5e
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x7fe28(%rip), %rdi     # 0xa4fbe
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/eps.c
// Function: plot_regression_model_tree
void plot_regression_model_tree(Regressionnodeptr rootnode, double outputmean, double outputvariance)
{
 FILE* outfile;
 int level = 0, maxdepth = depth_of_regression_tree(rootnode), maxwidth = regressiontree_leaf_count(rootnode) + regressiontree_node_count(rootnode);
 outfile = fopen("image.eps", "w");
 if (!outfile)
   return; 
 write_image_header(outfile, 2 * MARGIN + epsaxis, 2 * MARGIN + epsaxis);    
 level_of_regression_tree(rootnode);
 inorder_traversal_regression_tree(rootnode, &level);
 plot_regression_model_at_node(outfile, rootnode, maxdepth, maxwidth, outputmean, outputvariance);
 fclose(outfile);
 write_image_footer(outfile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdi, %r14
movl $0x0, 0xc(%rsp)
callq 0x76d91
movl %eax, %ebp
movq %r14, %rdi
callq 0x74d19
movl %eax, %r12d
movq %r14, %rdi
callq 0x74d45
movl %eax, %r15d
leaq 0x7f907(%rip), %rdi     # 0xa4eb3
leaq 0x832ee(%rip), %rsi     # 0xa88a1
callq 0x40f0
testq %rax, %rax
je 0x25644
movq %rax, %rbx
addl %r12d, %r15d
movq %rax, %rdi
movl $0x294, %esi            # imm = 0x294
movl $0x294, %edx            # imm = 0x294
callq 0x22236
movq %r14, %rdi
callq 0x76cc3
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x76c90
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r15d, %ecx
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x2536d
movq %rbx, %rdi
callq 0x42a0
leaq 0x7f845(%rip), %rdi     # 0xa4e5e
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x7f98c(%rip), %rdi     # 0xa4fbe
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/eps.c
// Function: plot_model_tree
void plot_model_tree(Decisionnodeptr rootnode)
{
 FILE* outfile;
 int level = 0, maxdepth = depth_of_tree(rootnode), maxwidth = decisiontree_leaf_count(rootnode) + decisiontree_node_count(rootnode);
 outfile = fopen("image.eps", "w");
 if (!outfile)
   return; 
 write_image_header(outfile, 2 * MARGIN + epsaxis, 2 * MARGIN + epsaxis);    
 level_of_decision_tree(rootnode);
 inorder_traversal_decision_tree(rootnode, &level);
 plot_decision_model_at_node(outfile, rootnode, maxdepth, maxwidth);
 fclose(outfile);
 write_image_footer(outfile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl $0x0, 0xc(%rsp)
callq 0x1dbd6
movl %eax, %ebp
movq %r14, %rdi
callq 0x1c4e8
movl %eax, %r12d
movq %r14, %rdi
callq 0x1c583
movl %eax, %r15d
leaq 0x7f827(%rip), %rdi     # 0xa4eb3
leaq 0x8320e(%rip), %rsi     # 0xa88a1
callq 0x40f0
testq %rax, %rax
je 0x25714
movq %rax, %rbx
addl %r12d, %r15d
movq %rax, %rdi
movl $0x294, %esi            # imm = 0x294
movl $0x294, %edx            # imm = 0x294
callq 0x22236
movq %r14, %rdi
callq 0x1dda0
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x1dc71
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x251b7
movq %rbx, %rdi
callq 0x42a0
leaq 0x7f775(%rip), %rdi     # 0xa4e5e
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x7f8bc(%rip), %rdi     # 0xa4fbe
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq