LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x205c6
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movapd %xmm0, %xmm2
ucomisd 0x85035(%rip), %xmm0    # 0xa5520
jae 0x205c0
movl %esi, %ebp
movl %edi, %ebx
cmpl %esi, %edi
setne %al
cmpl $0x9c5, %edi            # imm = 0x9C5
setl %cl
orb %al, %cl
jne 0x20527
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movsd 0x858d2(%rip), %xmm3    # 0xa5de8
divsd %xmm0, %xmm3
addsd 0x84ffe(%rip), %xmm3    # 0xa5520
jmp 0x205c0
movsd 0x84ff1(%rip), %xmm3    # 0xa5520
divsd %xmm2, %xmm3
movsd 0x8769d(%rip), %xmm1    # 0xa7bd8
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 0x201ed
movapd 0x20(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
ucomisd %xmm0, %xmm2
ja 0x2057a
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 0x85776(%rip), %xmm3    # 0xa5d18
movapd %xmm0, %xmm1
subsd %xmm4, %xmm1
andpd 0x85c2e(%rip), %xmm1    # 0xa61e0
ucomisd 0x87606(%rip), %xmm1    # 0xa7bc0
movapd %xmm0, %xmm1
ja 0x2054a
addq $0x38, %rsp
popq %rbx
popq %rbp
movapd %xmm3, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x85bab(%rip), %xmm5    # 0xa61d0
xorpd %xmm0, %xmm5
ucomisd %xmm0, %xmm5
cmovbel %edi, %ebx
maxsd %xmm0, %xmm5
movsd 0x875b4(%rip), %xmm0    # 0xa7bf0
ucomisd %xmm5, %xmm0
jae 0x2065e
testl %ebx, %ebx
sete %al
ucomisd 0x875a9(%rip), %xmm5    # 0xa7bf8
setb %cl
orb %al, %cl
xorpd %xmm0, %xmm0
jne 0x207a1
movsd 0x856b2(%rip), %xmm0    # 0xa5d18
mulsd %xmm5, %xmm0
mulsd %xmm5, %xmm0
ucomisd 0x8758a(%rip), %xmm5    # 0xa7c00
jbe 0x20739
xorpd 0x85b4c(%rip), %xmm0    # 0xa61d0
movapd %xmm5, (%rsp)
callq 0x4060
mulsd 0x875aa(%rip), %xmm0    # 0xa7c40
movsd 0x875aa(%rip), %xmm1    # 0xa7c48
movapd (%rsp), %xmm6
addsd %xmm6, %xmm1
movsd 0x875a1(%rip), %xmm2    # 0xa7c50
addsd %xmm6, %xmm2
movsd 0x8759d(%rip), %xmm3    # 0xa7c58
addsd %xmm6, %xmm3
movsd 0x87599(%rip), %xmm4    # 0xa7c60
addsd %xmm6, %xmm4
movsd 0x87595(%rip), %xmm5    # 0xa7c68
addsd %xmm6, %xmm5
addsd 0x87591(%rip), %xmm6    # 0xa7c70
movapd %xmm6, %xmm7
movsd 0x8758d(%rip), %xmm6    # 0xa7c78
divsd %xmm7, %xmm6
addsd %xmm5, %xmm6
movsd 0x87585(%rip), %xmm5    # 0xa7c80
divsd %xmm6, %xmm5
addsd %xmm4, %xmm5
movsd 0x8757d(%rip), %xmm4    # 0xa7c88
divsd %xmm5, %xmm4
addsd %xmm3, %xmm4
movsd 0x87575(%rip), %xmm3    # 0xa7c90
divsd %xmm4, %xmm3
addsd %xmm2, %xmm3
movsd 0x8756d(%rip), %xmm2    # 0xa7c98
divsd %xmm3, %xmm2
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
jmp 0x207a1
movsd 0x874c7(%rip), %xmm1    # 0xa7c08
mulsd %xmm0, %xmm1
movsd 0x874c3(%rip), %xmm2    # 0xa7c10
addsd %xmm0, %xmm2
movsd 0x874bf(%rip), %xmm3    # 0xa7c18
addsd %xmm0, %xmm3
addsd 0x874bb(%rip), %xmm0    # 0xa7c20
movsd 0x874bb(%rip), %xmm4    # 0xa7c28
divsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd 0x874b3(%rip), %xmm0    # 0xa7c30
divsd %xmm4, %xmm0
addsd %xmm2, %xmm0
divsd %xmm0, %xmm1
addsd 0x874a7(%rip), %xmm1    # 0xa7c38
mulsd %xmm1, %xmm5
movsd 0x8557b(%rip), %xmm0    # 0xa5d18
subsd %xmm5, %xmm0
testl %ebx, %ebx
jne 0x207b5
movsd 0x84d73(%rip), %xmm1    # 0xa5520
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x28, %rsp
movsd %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movsd 0x8509f(%rip), %xmm1    # 0xa5d18
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
callq 0x20d4a
movapd 0x10(%rsp), %xmm3
movsd 0x87024(%rip), %xmm1    # 0xa7cb8
ucomisd %xmm3, %xmm1
jbe 0x20d02
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
divsd %xmm3, %xmm1
mulsd 0x85042(%rip), %xmm1    # 0xa5cf8
addsd %xmm1, %xmm0
movsd 0x87036(%rip), %xmm2    # 0xa7cf8
mulsd %xmm0, %xmm2
addsd 0x87032(%rip), %xmm2    # 0xa7d00
movsd 0x87032(%rip), %xmm1    # 0xa7d08
movsd %xmm0, 0x8(%rsp)
mulsd %xmm0, %xmm1
movapd 0x86d98(%rip), %xmm0    # 0xa7a80
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
divpd %xmm3, %xmm0
subsd %xmm0, %xmm2
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
jmp 0x20d18
movsd %xmm0, 0x8(%rsp)
mulsd 0x86fe8(%rip), %xmm0    # 0xa7cf8
addsd 0x86fe8(%rip), %xmm0    # 0xa7d00
movapd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
addsd 0x8507c(%rip), %xmm0    # 0xa5da8
callq 0x4160
mulsd 0x10(%rsp), %xmm0
addsd 0x86fd1(%rip), %xmm0    # 0xa7d10
mulsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x20e02
subq $0x38, %rsp
ucomisd 0x847b8(%rip), %xmm3    # 0xa5520
jae 0x20dfe
movsd 0x86fa2(%rip), %xmm1    # 0xa7d18
movsd 0x86fa2(%rip), %xmm2    # 0xa7d20
xorpd %xmm0, %xmm0
movsd %xmm3, (%rsp)
movsd %xmm2, 0x8(%rsp)
movapd %xmm1, 0x10(%rsp)
movapd %xmm0, 0x20(%rsp)
callq 0x1feb4
movapd 0x20(%rsp), %xmm4
movsd (%rsp), %xmm3
ucomisd %xmm3, %xmm0
movapd %xmm4, %xmm1
ja 0x20db9
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 0x84f34(%rip), %xmm0    # 0xa5d18
movapd %xmm1, %xmm2
subsd %xmm5, %xmm2
ucomisd 0x86dcc(%rip), %xmm2    # 0xa7bc0
movapd %xmm1, %xmm2
movapd %xmm5, %xmm1
ja 0x20d87
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x20c62
movapd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x207bb
movsd 0x18(%rsp), %xmm3
movapd %xmm0, %xmm1
subsd %xmm3, %xmm1
andpd 0x85394(%rip), %xmm1    # 0xa61e0
movsd 0x86ed4(%rip), %xmm2    # 0xa7d28
ucomisd %xmm1, %xmm2
jbe 0x20e65
movapd 0x20(%rsp), %xmm0
jmp 0x21006
movapd %xmm3, %xmm4
cmpltsd %xmm0, %xmm4
movapd %xmm0, %xmm1
mulsd 0x86eb6(%rip), %xmm1    # 0xa7d30
movsd 0x86eb6(%rip), %xmm2    # 0xa7d38
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
andpd %xmm4, %xmm2
andnpd %xmm0, %xmm4
orpd %xmm2, %xmm4
ucomisd %xmm4, %xmm3
movapd %xmm4, 0x30(%rsp)
jbe 0x20ef8
movapd %xmm3, %xmm0
subsd %xmm4, %xmm0
movsd 0x8466e(%rip), %xmm2    # 0xa5520
movapd %xmm2, %xmm1
subsd %xmm3, %xmm1
mulsd %xmm0, %xmm1
subsd %xmm4, %xmm2
divsd %xmm2, %xmm1
mulsd 0x86e7a(%rip), %xmm1    # 0xa7d48
addsd %xmm3, %xmm1
movsd 0x86e66(%rip), %xmm0    # 0xa7d40
ucomisd %xmm1, %xmm0
ja 0x20f00
ucomisd 0x86e68(%rip), %xmm1    # 0xa7d50
movapd %xmm1, %xmm0
jbe 0x20f00
movsd 0x86e5a(%rip), %xmm0    # 0xa7d50
jmp 0x20f00
movsd 0x86e40(%rip), %xmm0    # 0xa7d40
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x20c62
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 0x207bb
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 0x85239(%rip), %xmm7    # 0xa61e0
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 0x86d7b(%rip), %xmm5    # 0xa7d58
ucomisd %xmm1, %xmm5
ja 0x21006
movapd %xmm9, %xmm1
cmpnlesd %xmm3, %xmm2
andpd %xmm2, %xmm1
andnpd %xmm8, %xmm2
orpd %xmm2, %xmm1
movapd %xmm0, %xmm2
decl %ebx
jne 0x20f26
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x84cb7(%rip), %xmm1    # 0xa5d18
ucomisd %xmm0, %xmm1
jbe 0x21085
addsd %xmm0, %xmm0
movl $0x1, %edi
callq 0x204cb
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x210b3
sqrtsd %xmm0, %xmm0
jmp 0x210c6
movsd 0x84493(%rip), %xmm1    # 0xa5520
subsd %xmm0, %xmm1
addsd %xmm1, %xmm1
movapd %xmm1, %xmm0
movl $0x1, %edi
callq 0x204cb
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x210b9
sqrtsd %xmm0, %xmm0
jmp 0x210be
popq %rax
jmp 0x4300
callq 0x4300
xorpd 0x8510a(%rip), %xmm0    # 0xa61d0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, 0x10(%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 0x21128
movapd %xmm2, %xmm0
movsd %xmm2, 0x8(%rsp)
movsd %xmm3, 0x18(%rsp)
callq 0x4300
movsd 0x18(%rsp), %xmm3
movsd 0x8(%rsp), %xmm2
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
addsd 0x86c30(%rip), %xmm1    # 0xa7d60
ucomisd %xmm0, %xmm2
jae 0x2114f
movapd %xmm2, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x4300
movsd 0x8(%rsp), %xmm1
movapd %xmm0, %xmm3
movsd 0x86c11(%rip), %xmm0    # 0xa7d68
divsd %xmm3, %xmm0
addsd %xmm0, %xmm1
mulsd 0x10(%rsp), %xmm1
movsd 0x86983(%rip), %xmm0    # 0xa7af0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x1, %ebx
movsd 0x84398(%rip), %xmm1    # 0xa5520
xorpd %xmm0, %xmm0
leaq 0x868fd(%rip), %r14     # 0xa7a90
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
xorl %r15d, %r15d
testb $0x1, %bl
sete %r15b
movsd 0x18(%rsp), %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
callq 0x4060
mulsd (%r14,%r15,8), %xmm0
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
addsd 0x8433a(%rip), %xmm1    # 0xa5520
incl %ebx
cmpl $0x66, %ebx
jne 0x21193
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb42e6(%rip), %rcx     # 0xd5870
movq (%rcx), %rcx
imulq $0x340, %rax, %rdx      # imm = 0x340
movl 0x30f08(%rcx,%rdx), %ecx
cmpl $0x2, %ecx
je 0x215d4
cmpl $0x1, %ecx
je 0x215c2
testl %ecx, %ecx
jne 0x215fe
cmpb $0x3e, %sil
je 0x21604
movzbl %sil, %ecx
cmpl $0x3c, %ecx
jne 0x215fe
movq (%rdi), %rcx
cvtsi2sdl (%rcx,%rax,8), %xmm1
jmp 0x215eb
movq (%rdi), %rcx
cvtsi2sdl (%rcx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x215f1
jp 0x215f1
jmp 0x215fe
cmpb $0x3e, %sil
je 0x215f4
movzbl %sil, %ecx
cmpl $0x3c, %ecx
jne 0x215fe
movq (%rdi), %rcx
movsd (%rcx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x215fe
xorl %eax, %eax
retq
movq (%rdi), %rcx
ucomisd (%rcx,%rax,8), %xmm0
ja 0x215f1
movl $0x1, %eax
retq
movq (%rdi), %rcx
cvtsi2sdl (%rcx,%rax,8), %xmm1
ucomisd %xmm1, %xmm0
ja 0x215f1
jmp 0x215fe
// File: /workspace/github_c_makefile_star2_O3/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 0x21661
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 0x2157c
testl %eax, %eax
je 0x21654
incl %ebp
cmpl %ebx, %ebp
jge 0x21664
addq $0x10, %r13
cmpq %r13, %r12
jne 0x21637
xorl %eax, %eax
jmp 0x21669
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_O3/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 0x216d7
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 0x21614
testl %eax, %eax
jne 0x216c6
cmpl (%rsp), %r14d
jge 0x216d5
incl %r14d
incq %rbp
cmpq %rbp, %rbx
jne 0x216a5
movl $0x1, %eax
jmp 0x216d7
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_O3/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, 0x4(%rsp)
movl %edx, (%rsp)
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0xb4166(%rip), %rax     # 0xd5870
movq (%rax), %rax
movslq 0x10(%rax), %rdi
leaq 0x86670(%rip), %rdx     # 0xa7d88
movl $0x4, %esi
movl $0x2, %ecx
callq 0x3a1fc
movq %rax, 0x8(%rsp)
movl 0x20(%r14), %r13d
testl %r13d, %r13d
jle 0x21786
movq (%r14), %r12
movq 0x8(%r14), %rbx
movq 0x18(%r14), %rbp
xorl %r15d, %r15d
movq (%r12,%r15,8), %rsi
movl (%rbx,%r15,4), %edx
movq (%rbp,%r15,8), %rcx
movq 0x10(%rsp), %rdi
movl (%rsp), %r8d
movl 0x4(%rsp), %r9d
callq 0x21678
testl %eax, %eax
je 0x2177b
movq 0x10(%r14), %rax
movslq (%rax,%r15,4), %rax
movq 0x8(%rsp), %rcx
incl (%rcx,%rax,4)
movl 0x20(%r14), %r13d
incq %r15
movslq %r13d, %rax
cmpq %rax, %r15
jl 0x21743
leaq 0xb40e3(%rip), %rax     # 0xd5870
movq (%rax), %rax
movl 0x10(%rax), %esi
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x38002
movl %eax, %ebx
movq %r14, %rdi
callq 0x3a180
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_O3/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 0x21817
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x216e6
movl %eax, %r13d
movq %r12, %rdi
callq 0x2f33a
xorl %ecx, %ecx
cmpl %eax, %r13d
setne %cl
addl %ecx, %ebx
movq 0x10(%r12), %r12
jmp 0x217e6
cmpl 0xc(%rsp), %ebx
jge 0x21829
movl %ebp, 0x24(%r14)
movl %r15d, 0x28(%r14)
movl %ebx, 0xc(%rsp)
incl %ebp
cmpl $0x15, %ebp
movq 0x10(%rsp), %r12
jne 0x217e4
leal 0x5(%r15), %eax
cmpl $0x15, %r15d
movl %eax, %r15d
jb 0x217df
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/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 0x8551a(%rip), %rsi     # 0xa7f89
movl $0x25, %edx
xorl %eax, %eax
callq 0x42e0
leaq 0x85521(%rip), %rsi     # 0xa7fa3
movq %rbx, %rdi
movl $0x25, %edx
movl $0x25, %ecx
xorl %eax, %eax
callq 0x42e0
leaq 0x85528(%rip), %rsi     # 0xa7fc5
movq %rbx, %rdi
movl $0x25, %edx
movl $0x25, %ecx
movl %r14d, %r8d
movl %ebp, %r9d
xorl %eax, %eax
callq 0x42e0
leaq 0x85523(%rip), %rdi     # 0xa7fe1
movl $0x25, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x26989
// File: /workspace/github_c_makefile_star2_O3/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 0x84b23(%rip), %rsi     # 0xa803b
xorl %eax, %eax
callq 0x42e0
movl %ebp, %edi
movl $0x3, %esi
movl $0x5, %edx
movl $0x3, %ecx
movl $0x4, %r8d
xorl %eax, %eax
callq 0x3aa8c
testl %eax, %eax
je 0x2355a
leaq 0x84b4b(%rip), %rdi     # 0xa8093
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
cmpl $0x5, %ebp
ja 0x2357c
movl %ebp, %eax
leaq 0x84918(%rip), %rcx     # 0xa7e80
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 0x3aa8c
testl %eax, %eax
je 0x235bb
leaq 0x84aed(%rip), %rdi     # 0xa8092
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_O3/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 0x23633
movl %r8d, %eax
movl %ecx, %r8d
movl %edx, %ecx
movl %esi, %edx
movl %r9d, %esi
leaq 0x8488a(%rip), %r9      # 0xa7e64
movslq (%r9,%rsi,4), %rsi
addq %r9, %rsi
jmpq *%rsi
leaq 0x84ab4(%rip), %rsi     # 0xa809e
jmp 0x2364d
movslq 0x8(%rsp), %rsi
leaq (%rsi,%rsi,2), %rsi
leaq 0xb15c4(%rip), %r9      # 0xd4bc0
movsd (%r9,%rsi,8), %xmm0
movsd 0x8(%r9,%rsi,8), %xmm1
movsd 0x10(%r9,%rsi,8), %xmm2
leaq 0x84b2d(%rip), %rsi     # 0xa8144
movl %eax, %r9d
movb $0x3, %al
jmp 0x42e0
leaq 0x84aaa(%rip), %rsi     # 0xa80d2
jmp 0x2364d
leaq 0x84af9(%rip), %rsi     # 0xa812a
jmp 0x2364d
retq
leaq 0x84a79(%rip), %rsi     # 0xa80b4
jmp 0x2364d
leaq 0x84aac(%rip), %rsi     # 0xa80f0
jmp 0x2364d
leaq 0x84abf(%rip), %rsi     # 0xa810c
movl %eax, %r9d
xorl %eax, %eax
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O3/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 0x1e348
movl %eax, %ebp
movq %r14, %rdi
callq 0x1cc46
movl %eax, %r12d
movq %r14, %rdi
callq 0x1cce7
movl %eax, %r15d
leaq 0x84583(%rip), %rdi     # 0xa7f0b
leaq 0x87fde(%rip), %rsi     # 0xab96d
callq 0x40f0
testq %rax, %rax
je 0x23a10
movq %rax, %rbx
addl %r12d, %r15d
movq %rax, %rdi
movl $0x294, %esi            # imm = 0x294
movl $0x294, %edx            # imm = 0x294
callq 0x22a5c
movq %r14, %rdi
callq 0x1e505
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x1e3e3
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x2368e
leaq 0x844d9(%rip), %rdi     # 0xa7eb6
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x84620(%rip), %rdi     # 0xa8016
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_O3/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 0x78753
movl %eax, %r15d
movq %r14, %rdi
callq 0x765d9
movl %eax, %r13d
movq %r14, %rdi
callq 0x76610
movl %eax, %r12d
leaq 0x826d4(%rip), %rdi     # 0xa7f0b
leaq 0x8612f(%rip), %rsi     # 0xab96d
callq 0x40f0
testq %rax, %rax
je 0x258d3
movq %rax, %rbx
addl %r13d, %r12d
movq %rax, %rdi
movl $0x294, %esi            # imm = 0x294
movl $0x294, %edx            # imm = 0x294
callq 0x22a5c
movq %r14, %rdi
callq 0x78679
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x78641
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x25560
movq %rbx, %rdi
callq 0x42a0
leaq 0x8260e(%rip), %rdi     # 0xa7eb6
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x82755(%rip), %rdi     # 0xa8016
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_O3/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 0x78753
movl %eax, %ebp
movq %r14, %rdi
callq 0x765d9
movl %eax, %r12d
movq %r14, %rdi
callq 0x76610
movl %eax, %r15d
leaq 0x82212(%rip), %rdi     # 0xa7f0b
leaq 0x85c6d(%rip), %rsi     # 0xab96d
callq 0x40f0
testq %rax, %rax
je 0x25d91
movq %rax, %rbx
addl %r12d, %r15d
movq %rax, %rdi
movl $0x294, %esi            # imm = 0x294
movl $0x294, %edx            # imm = 0x294
callq 0x22a5c
movq %r14, %rdi
callq 0x78679
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x78641
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r15d, %ecx
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x25aae
movq %rbx, %rdi
callq 0x42a0
leaq 0x82150(%rip), %rdi     # 0xa7eb6
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x82297(%rip), %rdi     # 0xa8016
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_O3/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 0x1e348
movl %eax, %ebp
movq %r14, %rdi
callq 0x1cc46
movl %eax, %r12d
movq %r14, %rdi
callq 0x1cce7
movl %eax, %r15d
leaq 0x82132(%rip), %rdi     # 0xa7f0b
leaq 0x85b8d(%rip), %rsi     # 0xab96d
callq 0x40f0
testq %rax, %rax
je 0x25e61
movq %rax, %rbx
addl %r12d, %r15d
movq %rax, %rdi
movl $0x294, %esi            # imm = 0x294
movl $0x294, %edx            # imm = 0x294
callq 0x22a5c
movq %r14, %rdi
callq 0x1e505
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x1e3e3
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x258e2
movq %rbx, %rdi
callq 0x42a0
leaq 0x82080(%rip), %rdi     # 0xa7eb6
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x821c7(%rip), %rdi     # 0xa8016
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
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/eps.c
// Function: write_dictionary
void write_dictionary(FILE* myfile)
{
 /*!Last Changed 12.09.2006*/
 FILE* infile;
 char myline[READLINELENGTH]; 
 infile = fopen("dictionary.txt", "r");
 if (!infile)
   return;
 while (fgets(myline, READLINELENGTH, infile))
  {
   fprintf(myfile, "%s", myline);
  }
 fclose(infile);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x7a120, %rsp          # imm = 0x7A120
movq %rdi, %rbx
leaq 0x81668(%rip), %rdi     # 0xa8007
leaq 0x84fb5(%rip), %rsi     # 0xab95b
callq 0x40f0
testq %rax, %rax
je 0x269f3
movq %rax, %r14
movq %rsp, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rax, %rdx
callq 0x4120
testq %rax, %rax
je 0x269eb
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x41f0
movq %r15, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r14, %rdx
callq 0x4120
testq %rax, %rax
jne 0x269cb
movq %r14, %rdi
callq 0x42a0
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/graphdata.c
// Function: count_data
int count_data(int *list, int *value_list, int list_count)
{
 /*!Last Changed 09.03.2001*/
 int i, j, count = 0;
 BOOLEAN found;
 for (i = 0; i < train.row; i++)
  {
   found = BOOLEAN_TRUE;
   for (j = 0; j < list_count; j++)
     if (train.data[i][list[j]] != value_list[j])
      {
       found = BOOLEAN_FALSE;
       break;
      }
   if (found)
     count++;
  }
 return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
leaq 0xae4e9(%rip), %rax     # 0xd54b8
movslq 0x8(%rax), %rcx
testq %rcx, %rcx
jle 0x27038
movq (%rax), %r8
movslq %edx, %r9
movl %r9d, %r10d
xorl %r11d, %r11d
xorl %eax, %eax
testl %edx, %edx
jle 0x27027
movq (%r8,%r11,8), %rbx
movslq (%rdi), %r14
movl (%rbx,%r14,4), %r14d
xorl %ebp, %ebp
cmpl (%rsi), %r14d
jne 0x2702c
movl $0x1, %r15d
movq %r15, %r14
cmpq %r15, %r10
je 0x2701c
movslq (%rdi,%r14,4), %r15
movl (%rbx,%r15,4), %ebp
leaq 0x1(%r14), %r15
cmpl (%rsi,%r14,4), %ebp
je 0x27002
xorl %ebp, %ebp
cmpq %r9, %r14
setge %bpl
jmp 0x2702c
movl $0x1, %ebp
addl %ebp, %eax
incq %r11
cmpq %rcx, %r11
jne 0x26fe6
jmp 0x2703a
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/graphdata.c
// Function: count_data_from_file
int count_data_from_file(char *file_name, int *list, char **value_list, int list_count)
{
/*!Last Changed 13.02.2001*/
 FILE *myfile;
 int i, j, count = 0;
 BOOLEAN found;
 char *st;
 char st1[3];
 char myline[READLINELENGTH];
 if ((myfile = fopen(file_name, "r")) == NULL)
   return 0;
 st1[0] = ' ';
 st1[1] = '\n';
 st1[2] = '\0';
 while (fgets(myline, READLINELENGTH, myfile))
  {
   st = strtok(myline, st1);
   found = BOOLEAN_TRUE;
   i = 0;
   while (st)
    {
     for (j = 0; j < list_count; j++)
       if (list[j] == i)
         if (strcmp(value_list[j], st) != 0)
          {
           found = BOOLEAN_FALSE;
           break;
          }
     if (!found)
       break;
     i++;
     st = strtok(NULL, st1);
    }
   if (found)
     count++;
  }
 fclose(myfile);
 return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a148, %rsp          # imm = 0x7A148
movl %ecx, 0xc(%rsp)
movq %rdx, %r14
movq %rsi, %r15
leaq 0x848f8(%rip), %rsi     # 0xab95b
callq 0x40f0
testq %rax, %rax
je 0x27147
movq %rax, %rbx
movw $0xa20, 0x9(%rsp)       # imm = 0xA20
movb $0x0, 0xb(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rax, %rdx
callq 0x4120
testq %rax, %rax
je 0x2714c
movl 0xc(%rsp), %r12d
xorl %r13d, %r13d
leaq 0x20(%rsp), %rbp
movq %rbx, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq %rbp, %rdi
leaq 0x9(%rsp), %rsi
callq 0x4280
movq %rax, %rbp
movl $0x1, %eax
testq %rbp, %rbp
je 0x2711f
xorl %ebx, %ebx
cmpl $0x0, 0xc(%rsp)
jle 0x270f6
xorl %r13d, %r13d
cmpl %ebx, (%r15,%r13,4)
jne 0x270ee
movq (%r14,%r13,8), %rdi
movq %rbp, %rsi
callq 0x4260
testl %eax, %eax
jne 0x27118
incq %r13
cmpq %r13, %r12
jne 0x270d8
incl %ebx
xorl %edi, %edi
leaq 0x9(%rsp), %rsi
callq 0x4280
movq %rax, %rbp
testq %rax, %rax
jne 0x270ce
movq 0x10(%rsp), %rbx
movl $0x1, %eax
jmp 0x2711f
xorl %eax, %eax
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r13
addl %eax, %r13d
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rbx, %rdx
callq 0x4120
testq %rax, %rax
jne 0x270ad
jmp 0x2714f
xorl %r13d, %r13d
jmp 0x27157
xorl %r13d, %r13d
movq %rbx, %rdi
callq 0x42a0
movl %r13d, %eax
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/graphdata.c
// Function: likelihood_of_data
double likelihood_of_data(bayesiangraphptr mygraph, Bndata mydata)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 25.02.2001*/
 int i, j, k, pos, value_pos, *parents, *list1;
 double result = 0;
 for (i = 0; i < mydata.row; i++)
   for (j = 0; j < mydata.col; j++)
    {
     value_pos = mydata.data[i][j];
     if (mygraph->nodes[j].parents)
      {
       parents = find_parents(mygraph,j);
       list1 = safemalloc(mygraph->nodes[j].parents * sizeof(int), "likelihood_of_data", 10);
       for (k = 0; k < mygraph->nodes[j].parents; k++)
         list1[k] = mydata.data[i][parents[k]];
       pos = table_pos(mygraph->nodes[j], list1);
       safe_free(parents);
       safe_free(list1);
      }
     else/*No parents*/
       pos = 0;
     if (mygraph->nodes[j].table[pos][value_pos] > 0)
       result += log2(mygraph->nodes[j].table[pos][value_pos]);
    }
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, 0x60(%rsp)
testl %edx, %edx
jle 0x274c6
movq %rdi, %r15
movq %rdx, %rax
shrq $0x20, %rax
movq %rax, 0x58(%rsp)
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movq $0x0, 0x50(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x48(%rsp)
movq %rdx, 0x68(%rsp)
cmpl $0x0, 0x58(%rsp)
jle 0x274a9
xorl %r13d, %r13d
movq 0x60(%rsp), %rax
movq 0x50(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq (%rax,%r13,4), %rdx
movq 0x8(%r15), %rax
leaq (,%r13,8), %r14
addq %r13, %r14
cmpl $0x0, 0x20(%rax,%r14,8)
je 0x2746c
movq %rdx, 0x70(%rsp)
movq %r15, %rdi
movl %r13d, %esi
callq 0x4e548
movq %rax, %rbp
movq 0x8(%r15), %rax
leaq (,%r13,8), %rcx
leaq (%rcx,%rcx,8), %r12
movslq 0x20(%rax,%r12), %rdi
shlq $0x2, %rdi
leaq 0x80ded(%rip), %rsi     # 0xa81e1
movl $0xa, %edx
callq 0x3a0e1
movq %rax, %rbx
movq 0x8(%r15), %rax
leaq (%rax,%r12), %rsi
cmpl $0x0, 0x20(%rax,%r12)
jle 0x27438
movq 0x60(%rsp), %rax
movq 0x50(%rsp), %rcx
movq (%rax,%rcx,8), %rax
xorl %ecx, %ecx
movslq (%rbp,%rcx,4), %rdx
movl (%rax,%rdx,4), %edx
movl %edx, (%rbx,%rcx,4)
incq %rcx
movslq 0x20(%rsi), %rdx
cmpq %rdx, %rcx
jl 0x27421
movl $0x9, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x4e515
movl %eax, %r12d
movq %rbp, %rdi
callq 0x3a180
movq %rbx, %rdi
callq 0x3a180
movslq %r12d, %rcx
movq 0x8(%r15), %rax
movq 0x70(%rsp), %rdx
jmp 0x2746e
xorl %ecx, %ecx
movq 0x38(%rax,%r14,8), %rax
movq (%rax,%rcx,8), %rax
movsd (%rax,%rdx,8), %xmm0
ucomisd 0x7e884(%rip), %xmm0    # 0xa5d08
jbe 0x2749b
callq 0x39bdc
movsd 0x48(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x48(%rsp)
incq %r13
cmpq 0x58(%rsp), %r13
jne 0x27394
movq 0x50(%rsp), %rcx
incq %rcx
movq 0x68(%rsp), %rdx
movq %rcx, 0x50(%rsp)
cmpq %rdx, %rcx
jne 0x27386
jmp 0x274d0
xorpd %xmm0, %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x48(%rsp), %xmm0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/graphdata.c
// Function: parent_value_combinations
int **parent_value_combinations(bayesiangraphptr mygraph, int *parents, int parentcount, int total_combinations)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 int i, j;
 int repeat, value, num_values, current_value;
 int **combinations;
 combinations = (int **) safemalloc (total_combinations * sizeof(int *), "parent_value_combinations", 4);
 for (i = 0; i < total_combinations; i++)
   combinations[i] = (int *) safemalloc (parentcount * sizeof(int), "parent_value_combinations", 6);
 num_values = 1;
 for (i = 0; i < parentcount; i++)
  {
   current_value = mygraph->nodes[parents[i]].value_count;
   num_values = num_values * current_value;
   repeat = (int) total_combinations / num_values;
   value = 0;
   for (j = 0; j < total_combinations; j++)
    {
     if (repeat > 0)
      {
       combinations[j][i] = value;
       repeat = repeat - 1;
      }
     else
      {
       repeat = (int) total_combinations / num_values;
       value = (value + 1) % current_value;
       combinations[j][i] = value;
       repeat = repeat -1;
      }
    }
  }
 return combinations;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movl %edx, 0x4(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movslq %ecx, %r14
leaq (,%r14,8), %rdi
leaq 0x80cdf(%rip), %rsi     # 0xa81f4
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r15
movl %ebx, %ebp
testl %r14d, %r14d
jle 0x27558
movslq 0x4(%rsp), %r13
shlq $0x2, %r13
xorl %r14d, %r14d
leaq 0x80cb8(%rip), %r12     # 0xa81f4
movq %r13, %rdi
movq %r12, %rsi
movl $0x6, %edx
callq 0x3a0e1
movq %rax, (%r15,%r14,8)
incq %r14
cmpq %r14, %rbp
jne 0x2753c
movl 0x4(%rsp), %eax
testl %eax, %eax
movq 0x10(%rsp), %r14
jle 0x275c9
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rsi
movl %eax, %edi
movl $0x1, %r8d
xorl %r9d, %r9d
movslq (%r14,%r9,4), %rax
leaq (%rax,%rax,8), %rax
movl 0x10(%rsi,%rax,8), %r10d
imull %r10d, %r8d
movl %ebx, %eax
cltd
idivl %r8d
testl %ebx, %ebx
jle 0x275c1
movl %eax, %ecx
xorl %r11d, %r11d
xorl %eax, %eax
movl %ecx, %r12d
testl %r12d, %r12d
jg 0x275ae
incl %eax
cltd
idivl %r10d
movl %ecx, %r12d
movl %edx, %eax
movq (%r15,%r11,8), %rdx
movl %eax, (%rdx,%r9,4)
decl %r12d
incq %r11
cmpq %r11, %rbp
jne 0x2759e
incq %r9
cmpq %rdi, %r9
jne 0x27579
movq %r15, %rax
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/graphdata.c
// Function: lnfact
double lnfact(int n)
{
 int i;
 double result;
 result = 0;
 for (i = n; i > 0; i--)
   result = result + log(i);
 return result;
}

// Assembly:
testl %edi, %edi
jle 0x27621
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
callq 0x4160
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
leal -0x1(%rbx), %eax
cmpl $0x1, %ebx
movl %eax, %ebx
ja 0x275e9
addq $0x10, %rsp
popq %rbx
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/graphdata.c
// Function: select_node_maximizes_K2_metric
int select_node_maximizes_K2_metric(bayesiangraphptr mygraph, int node, int *parents, int parentcount, int *nodeset, int nodecount)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 double metricvalue, maxvalue;
 int i, j, maxnode;
 int *currentparents;
 BOOLEAN found;
 currentparents = (int *) safemalloc((parentcount + 1) * sizeof(int), "select_node_maximizes_K2_metric", 4);
 maxvalue = -LONG_MAX;
 maxnode = -1;
 for (i = 0; i < parentcount; i++)
   currentparents[i] = parents[i];
 for (i = 0; i < nodecount; i++)
  {
   found = BOOLEAN_FALSE;
   for (j = 0; j < parentcount; j++)
     if (nodeset[i] == parents[j])
      {
       found = BOOLEAN_TRUE;
       break;
      }
   currentparents[parentcount] = nodeset[i];
   if (!found)
    {
     metricvalue = calculate_K2_metric(mygraph, node, currentparents, parentcount + 1);
     if (metricvalue > maxvalue)
      {
       maxvalue = metricvalue;
       maxnode = nodeset[i];
      }
    }
  }
	safe_free(currentparents);
 return maxnode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %r12d
movq %r8, %rbx
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, 0x14(%rsp)
movq %rdi, 0x30(%rsp)
movslq %ecx, %rax
movq %rax, 0x18(%rsp)
leaq 0x4(,%rax,4), %rdi
leaq 0x8095d(%rip), %rsi     # 0xa8222
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r13
movl %r14d, %ebp
movq %r14, 0x28(%rsp)
testl %r14d, %r14d
jle 0x278f2
xorl %eax, %eax
movl (%r15,%rax,4), %ecx
movl %ecx, (%r13,%rax,4)
incq %rax
cmpq %rax, %rbp
jne 0x278e1
testl %r12d, %r12d
jle 0x27988
movq 0x28(%rsp), %rax
incl %eax
movl %eax, 0x10(%rsp)
movl %r12d, %r12d
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movsd 0x7e4af(%rip), %xmm0    # 0xa5dc8
movsd %xmm0, 0x20(%rsp)
xorl %r14d, %r14d
movl (%rbx,%r14,4), %eax
cmpl $0x0, 0x28(%rsp)
jle 0x2793d
xorl %ecx, %ecx
cmpl (%r15,%rcx,4), %eax
je 0x27974
incq %rcx
cmpq %rcx, %rbp
jne 0x2792f
movq 0x18(%rsp), %rcx
movl %eax, (%r13,%rcx,4)
movq 0x30(%rsp), %rdi
movl 0x14(%rsp), %esi
movq %r13, %rdx
movl 0x10(%rsp), %ecx
callq 0x27625
ucomisd 0x20(%rsp), %xmm0
jbe 0x2797e
movl (%rbx,%r14,4), %eax
movl %eax, 0xc(%rsp)
movsd %xmm0, 0x20(%rsp)
jmp 0x2797e
movq 0x18(%rsp), %rcx
movl %eax, (%r13,%rcx,4)
incq %r14
cmpq %r12, %r14
jne 0x27922
jmp 0x27990
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movq %r13, %rdi
callq 0x3a180
movl 0xc(%rsp), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/hmm.c
// Function: empty_hmm
Hmmptr empty_hmm(int statecount, HMM_STATE_TYPE statetype, HMM_MODEL_TYPE hmmtype)
{
 /*!Last Changed 22.01.2007*/
 Hmmptr result;
 result = safemalloc(sizeof(Hmm), "empty_hmm", 2);
 result->states = safemalloc(statecount * sizeof(State), "empty_hmm", 3);
 result->statecount = statecount;
 result->statetype = statetype;
 result->hmmtype = hmmtype;
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
leaq 0x80875(%rip), %r15     # 0xa8334
movl $0x18, %edi
movq %r15, %rsi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %r12
movslq %r14d, %r14
movq %r14, %rdi
shlq $0x5, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq 0x3a0e1
movq %rax, (%r12)
movl %r14d, 0x8(%r12)
movl %ebp, 0xc(%r12)
movl %ebx, 0x10(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/hmm.c
// Function: free_hmm
void free_hmm(Hmmptr hmm)
{
 /*!Last Changed 25.02.2007 added free_state_model*/
 /*!Last Changed 22.01.2007*/
 int i;
 for (i = 0; i < hmm->statecount; i++)
  {
   free_state_model(hmm->states[i].b, hmm->statetype);
   safe_free(hmm->states[i].a_dot_j);
   safe_free(hmm->states[i].a_i_dot);
  }  
 safe_free(hmm->states);
 safe_free(hmm);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x27fd7
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x18(%rax,%r14), %rdi
movl 0xc(%rbx), %esi
callq 0x27fec
movq (%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x3a180
movq (%rbx), %rax
movq 0x8(%rax,%r14), %rdi
callq 0x3a180
incq %r15
movslq 0x8(%rbx), %rax
addq $0x20, %r14
cmpq %rax, %r15
jl 0x27f9e
movq (%rbx), %rdi
callq 0x3a180
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3a180