LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x1e618
movapd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x1e0c5
movsd 0x18(%rsp), %xmm3
movapd %xmm0, %xmm1
subsd %xmm3, %xmm1
andpd 0x779e4(%rip), %xmm1    # 0x961e0
movsd 0x794a4(%rip), %xmm2    # 0x97ca8
ucomisd %xmm1, %xmm2
jbe 0x1e816
movapd 0x20(%rsp), %xmm0
addq $0x50, %rsp
popq %rbx
retq
movapd %xmm3, %xmm4
cmpltsd %xmm0, %xmm4
movapd %xmm0, %xmm1
mulsd 0x79485(%rip), %xmm1    # 0x97cb0
movsd 0x79485(%rip), %xmm2    # 0x97cb8
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
andpd %xmm4, %xmm2
andnpd %xmm0, %xmm4
orpd %xmm2, %xmm4
ucomisd %xmm4, %xmm3
movapd %xmm4, 0x30(%rsp)
jbe 0x1e8a9
movapd %xmm3, %xmm0
subsd %xmm4, %xmm0
movsd 0x76cbd(%rip), %xmm2    # 0x95520
movapd %xmm2, %xmm1
subsd %xmm3, %xmm1
mulsd %xmm0, %xmm1
subsd %xmm4, %xmm2
divsd %xmm2, %xmm1
mulsd 0x79449(%rip), %xmm1    # 0x97cc8
addsd %xmm3, %xmm1
movsd 0x79435(%rip), %xmm0    # 0x97cc0
ucomisd %xmm1, %xmm0
ja 0x1e8b1
ucomisd 0x79437(%rip), %xmm1    # 0x97cd0
movapd %xmm1, %xmm0
jbe 0x1e8b1
movsd 0x79429(%rip), %xmm0    # 0x97cd0
jmp 0x1e8b1
movsd 0x7940f(%rip), %xmm0    # 0x97cc0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x1e618
movapd %xmm0, %xmm3
pushq $0x7
popq %rbx
movapd 0x20(%rsp), %xmm7
movapd %xmm7, %xmm0
subl $0x1, %ebx
jb 0x1e810
movapd %xmm3, %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movapd %xmm7, 0x20(%rsp)
movapd %xmm3, 0x40(%rsp)
callq 0x1e0c5
movapd 0x40(%rsp), %xmm10
movapd 0x20(%rsp), %xmm7
movapd %xmm0, %xmm1
movapd 0x30(%rsp), %xmm8
movapd %xmm8, %xmm3
movsd 0x18(%rsp), %xmm6
subsd %xmm6, %xmm3
movapd %xmm0, %xmm2
subsd %xmm6, %xmm2
movapd %xmm10, %xmm4
mulsd %xmm3, %xmm4
movapd %xmm2, %xmm0
mulsd %xmm7, %xmm0
subsd %xmm4, %xmm0
movapd %xmm2, %xmm4
subsd %xmm3, %xmm4
divsd %xmm4, %xmm0
movapd 0x7788a(%rip), %xmm9    # 0x961e0
andpd %xmm9, %xmm3
andpd %xmm9, %xmm2
movapd %xmm2, %xmm4
cmpnlesd %xmm3, %xmm4
movapd %xmm4, %xmm5
andnpd %xmm1, %xmm5
andpd %xmm8, %xmm4
orpd %xmm5, %xmm4
movapd %xmm4, %xmm1
subsd %xmm6, %xmm1
andpd %xmm9, %xmm1
movsd 0x79349(%rip), %xmm5    # 0x97cd8
ucomisd %xmm1, %xmm5
ja 0x1e810
cmpnlesd %xmm3, %xmm2
andpd %xmm2, %xmm7
andnpd %xmm10, %xmm2
orpd %xmm2, %xmm7
movapd %xmm4, 0x30(%rsp)
movapd %xmm0, %xmm3
jmp 0x1e8d3
// File: /workspace/github_c_makefile_star2_O2/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 0x77313(%rip), %xmm1    # 0x95d20
ucomisd %xmm0, %xmm1
jbe 0x1ea2f
addsd %xmm0, %xmm0
pushq $0x1
popq %rdi
callq 0x1dde6
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1ea5b
sqrtsd %xmm0, %xmm0
jmp 0x1ea6e
movsd 0x76ae9(%rip), %xmm1    # 0x95520
subsd %xmm0, %xmm1
addsd %xmm1, %xmm1
pushq $0x1
popq %rdi
movapd %xmm1, %xmm0
callq 0x1dde6
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1ea61
sqrtsd %xmm0, %xmm0
jmp 0x1ea66
popq %rax
jmp 0x4300
callq 0x4300
xorpd 0x77762(%rip), %xmm0    # 0x961d0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
cvtsi2sd %esi, %xmm0
divsd %xmm0, %xmm2
sqrtsd %xmm2, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
movapd %xmm3, %xmm1
jae 0x1eacd
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 0x7920b(%rip), %xmm1    # 0x97ce0
ucomisd %xmm0, %xmm2
jae 0x1eaf4
movapd %xmm2, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x4300
movsd 0x8(%rsp), %xmm1
movapd %xmm0, %xmm3
movsd 0x791ec(%rip), %xmm0    # 0x97ce8
divsd %xmm3, %xmm0
addsd %xmm0, %xmm1
mulsd 0x10(%rsp), %xmm1
movsd 0x78f5e(%rip), %xmm0    # 0x97a70
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
xorpd %xmm0, %xmm0
pushq $0x1
popq %rbx
movsd 0x769f1(%rip), %xmm1    # 0x95520
leaq 0x78eda(%rip), %r14     # 0x97a10
cmpl $0x66, %ebx
je 0x1eb92
xorl %r15d, %r15d
testb $0x1, %bl
sete %r15b
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm1, 0x8(%rsp)
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 0x76992(%rip), %xmm1    # 0x95520
incl %ebx
jmp 0x1eb36
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xae9ce(%rip), %rcx     # 0xcd870
movq (%rcx), %rcx
imulq $0x340, %rax, %rdx      # imm = 0x340
movl 0x30f08(%rcx,%rdx), %ecx
cmpl $0x2, %ecx
je 0x1eeec
cmpl $0x1, %ecx
je 0x1eeda
testl %ecx, %ecx
jne 0x1ef16
cmpb $0x3e, %sil
je 0x1ef1a
movzbl %sil, %ecx
cmpl $0x3c, %ecx
jne 0x1ef16
movq (%rdi), %rcx
cvtsi2sdl (%rcx,%rax,8), %xmm1
jmp 0x1ef03
movq (%rdi), %rcx
cvtsi2sdl (%rcx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x1ef09
jp 0x1ef09
jmp 0x1ef16
cmpb $0x3e, %sil
je 0x1ef0c
movzbl %sil, %ecx
cmpl $0x3c, %ecx
jne 0x1ef16
movq (%rdi), %rcx
movsd (%rcx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x1ef16
xorl %eax, %eax
retq
movq (%rdi), %rcx
ucomisd (%rcx,%rax,8), %xmm0
ja 0x1ef09
pushq $0x1
popq %rax
retq
movq (%rdi), %rcx
cvtsi2sdl (%rcx,%rax,8), %xmm1
ucomisd %xmm1, %xmm0
ja 0x1ef09
jmp 0x1ef16
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %r14d
shlq $0x4, %r14
xorl %r13d, %r13d
xorl %ebx, %ebx
cmpq %r13, %r14
je 0x1ef79
movq (%r15,%r13), %rsi
movsd 0x8(%r15,%r13), %xmm0
movq %r12, %rdi
callq 0x1ee94
testl %eax, %eax
je 0x1ef73
incl %ebx
cmpl %ebp, %ebx
jge 0x1ef7d
addq $0x10, %r13
jmp 0x1ef51
xorl %eax, %eax
jmp 0x1ef80
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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)
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
xorl %ebx, %ebx
testl %edx, %edx
cmovlel %ebx, %r15d
xorl %ebp, %ebp
cmpq %rbx, %r15
je 0x1efe2
movq (%r12,%rbx,8), %rsi
movl (%r14,%rbx,4), %edx
movq %r13, %rdi
movl 0x4(%rsp), %ecx
callq 0x1ef2a
testl %eax, %eax
jne 0x1efdd
cmpl (%rsp), %ebp
jge 0x1efe7
incl %ebp
incq %rbx
jmp 0x1efb9
pushq $0x1
popq %rax
jmp 0x1efe9
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_O2/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
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0xae85c(%rip), %rax     # 0xcd870
movq (%rax), %rax
movslq 0x10(%rax), %rdi
leaq 0x78ce6(%rip), %rdx     # 0x97d08
pushq $0x4
popq %rsi
pushq $0x2
popq %rcx
callq 0x35067
movq %rax, %r12
xorl %r13d, %r13d
movslq 0x20(%r14), %rax
cmpq %rax, %r13
jge 0x1f076
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq (%rax,%r13,8), %rsi
movl (%rcx,%r13,4), %edx
movq 0x18(%r14), %rax
movq (%rax,%r13,8), %rcx
movq %r15, %rdi
movl %ebp, %r8d
movl %ebx, %r9d
callq 0x1ef8f
testl %eax, %eax
je 0x1f071
movq 0x10(%r14), %rax
movslq (%rax,%r13,4), %rax
incl (%r12,%rax,4)
incq %r13
jmp 0x1f033
leaq 0xae7f3(%rip), %rax     # 0xcd870
movq (%rax), %rax
movl 0x10(%rax), %esi
movq %r12, %rdi
callq 0x336b5
movl %eax, %ebx
movq %r12, %rdi
callq 0x34ff7
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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, 0x10(%rsp)
movq %rdi, %r14
movl $0x7fffffff, 0xc(%rsp)  # imm = 0x7FFFFFFF
xorl %ebp, %ebp
cmpl $0x19, %ebp
ja 0x1f129
pushq $0x1
popq %r15
cmpl $0x15, %r15d
je 0x1f124
xorl %ebx, %ebx
movq 0x10(%rsp), %r12
testq %r12, %r12
je 0x1f10d
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x1eff8
movl %eax, %r13d
movq %r12, %rdi
callq 0x2b47e
xorl %ecx, %ecx
cmpl %eax, %r13d
setne %cl
addl %ecx, %ebx
movq 0x10(%r12), %r12
jmp 0x1f0dc
cmpl 0xc(%rsp), %ebx
jge 0x1f11f
movl %r15d, 0x24(%r14)
movl %ebp, 0x28(%r14)
movl %ebx, 0xc(%rsp)
incl %r15d
jmp 0x1f0cf
addl $0x5, %ebp
jmp 0x1f0c6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x77f27(%rip), %rsi     # 0x97f09
pushq $0x25
popq %r15
movl %r15d, %edx
xorl %eax, %eax
callq 0x42e0
leaq 0x77f2c(%rip), %rsi     # 0x97f23
movq %rbx, %rdi
movl %r15d, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x42e0
leaq 0x77f37(%rip), %rsi     # 0x97f45
movq %rbx, %rdi
movl %r15d, %edx
movl %r15d, %ecx
movl %r14d, %r8d
movl %ebp, %r9d
xorl %eax, %eax
callq 0x42e0
leaq 0x77f36(%rip), %rdi     # 0x97f61
pushq $0x25
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x42c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x236a2
// File: /workspace/github_c_makefile_star2_O2/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 0x7765f(%rip), %rsi     # 0x97fbb
xorl %eax, %eax
callq 0x42e0
pushq $0x5
popq %rdx
pushq $0x3
popq %rcx
pushq $0x4
popq %r8
movl %ebp, %edi
movl %ecx, %esi
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0x20991
leaq 0x77690(%rip), %rdi     # 0x98013
pushq $0xa
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x42c0
cmpl $0x5, %ebp
ja 0x209b3
movl %ebp, %eax
leaq 0x77461(%rip), %rcx     # 0x97e00
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x42e0
pushq $0x5
popq %rdx
pushq $0x3
popq %rcx
pushq $0x4
popq %r8
movl %ebp, %edi
movl %ecx, %esi
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0x209e5
leaq 0x7763f(%rip), %rdi     # 0x98012
pushq $0xb
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x42c0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x20a5d
movl %r8d, %eax
movl %ecx, %r8d
movl %edx, %ecx
movl %esi, %edx
movl %r9d, %esi
leaq 0x773e0(%rip), %r9      # 0x97de4
movslq (%r9,%rsi,4), %rsi
addq %r9, %rsi
jmpq *%rsi
leaq 0x7760a(%rip), %rsi     # 0x9801e
jmp 0x20a77
movslq 0x8(%rsp), %rsi
imulq $0x18, %rsi, %rsi
leaq 0xac19a(%rip), %r9      # 0xccbc0
movsd (%rsi,%r9), %xmm0
movsd 0x8(%rsi,%r9), %xmm1
movsd 0x10(%rsi,%r9), %xmm2
leaq 0x77683(%rip), %rsi     # 0x980c4
movl %eax, %r9d
movb $0x3, %al
jmp 0x42e0
leaq 0x77600(%rip), %rsi     # 0x98052
jmp 0x20a77
leaq 0x7764f(%rip), %rsi     # 0x980aa
jmp 0x20a77
retq
leaq 0x775cf(%rip), %rsi     # 0x98034
jmp 0x20a77
leaq 0x77602(%rip), %rsi     # 0x98070
jmp 0x20a77
leaq 0x77615(%rip), %rsi     # 0x9808c
movl %eax, %r9d
xorl %eax, %eax
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
andl $0x0, 0xc(%rsp)
callq 0x1bdbf
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1a834
movl %eax, %r12d
movq %rbx, %rdi
callq 0x1a8d0
movl %eax, %r15d
leaq 0x77144(%rip), %rdi     # 0x97e8b
leaq 0x7ab43(%rip), %rsi     # 0x9b891
callq 0x40f0
testq %rax, %rax
je 0x20da5
movq %rax, %r14
addl %r12d, %r15d
movq %rax, %rdi
movl $0x294, %esi            # imm = 0x294
movl $0x294, %edx            # imm = 0x294
callq 0x1ffcc
movq %rbx, %rdi
callq 0x1bf81
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x1be67
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x20abd
movq %r14, %rdi
callq 0x20a81
movq %r14, %rdi
callq 0x42a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %ebx
movq %rdi, %r14
andl $0x0, 0x4(%rsp)
callq 0x6e370
movl %eax, %ebp
movq %r14, %rdi
callq 0x6c571
movl %eax, %r13d
movq %r14, %rdi
callq 0x6c59d
movl %eax, %r12d
leaq 0x7560f(%rip), %rdi     # 0x97e8b
leaq 0x7900e(%rip), %rsi     # 0x9b891
callq 0x40f0
testq %rax, %rax
je 0x228e9
movq %rax, %r15
addl %r13d, %r12d
movq %rax, %rdi
movl $0x294, %esi            # imm = 0x294
movl $0x294, %edx            # imm = 0x294
callq 0x1ffcc
movq %r14, %rdi
callq 0x6e2a6
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x6e271
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r12d, %ecx
movl %ebx, %r8d
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x22602
movq %r15, %rdi
callq 0x42a0
movq %r15, %rdi
callq 0x20a81
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/eps.c
// Function: plot_decision_model_at_node
void plot_decision_model_at_node(FILE* outfile, Decisionnodeptr rootnode, int maxdepth, int maxwidth)
{
 int radius = (epsaxis + MARGIN) / (WIDTHFACTOR * maxwidth), node_width = (epsaxis + MARGIN) / maxwidth, node_height = img.height / maxdepth;
 Point p1, parent;
 if (rootnode)
  {
   p1.x = MARGIN / 2 + (rootnode->x + 0.5) * node_width;
   p1.y = img.height - (rootnode->y + 0.5) * node_height + MARGIN / 2 + 2 * radius;
   plot_decision_leaf_model(outfile, rootnode, p1, radius);
   if (rootnode->parent)
    {
     parent.x = MARGIN / 2 + (rootnode->parent->x + 0.5) * node_width;
     parent.y = img.height - (rootnode->parent->y + 0.5) * node_height + MARGIN / 2 + 2 * radius;
     write_line(outfile, p1.x, p1.y - 2 * radius, parent.x, parent.y - (2 * WIDTHFACTOR + 1.5) * radius);
    }   
   plot_decision_model_at_node(outfile, rootnode->left, maxdepth, maxwidth);
   plot_decision_model_at_node(outfile, rootnode->right, maxdepth, maxwidth);
  }  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
leal (%rbx,%rbx), %ecx
movl $0x244, %eax            # imm = 0x244
xorl %edx, %edx
idivl %ecx
movl %eax, %r15d
leal (%r15,%r15), %eax
cvtsi2sd %eax, %xmm5
movq %rdi, %r12
cvtsi2sd %r15d, %xmm0
leaq 0x387785(%rip), %r13    # 0x3aa0b8
movsd 0x733e5(%rip), %xmm2    # 0x95d20
movsd 0x7542d(%rip), %xmm3    # 0x97d70
mulsd 0x7542d(%rip), %xmm0    # 0x97d78
movsd %xmm0, 0x10(%rsp)
movsd %xmm5, 0x8(%rsp)
testq %r14, %r14
je 0x22a8a
movl (%r13), %ecx
movl %ecx, %eax
cltd
idivl %ebp
movl %eax, %esi
movl $0x244, %eax            # imm = 0x244
xorl %edx, %edx
idivl %ebx
cvtsi2sdl 0x134(%r14), %xmm0
addsd %xmm2, %xmm0
cvtsi2sd %eax, %xmm1
movsd %xmm1, 0x20(%rsp)
mulsd %xmm1, %xmm0
cvtsi2sd %ecx, %xmm1
cvtsi2sdl 0x138(%r14), %xmm4
addsd %xmm3, %xmm0
addsd %xmm2, %xmm4
cvtsi2sd %esi, %xmm2
movsd %xmm2, 0x18(%rsp)
mulsd %xmm2, %xmm4
subsd %xmm4, %xmm1
addsd %xmm3, %xmm1
addsd %xmm5, %xmm1
movq %r12, %rdi
movq %r14, %rsi
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movl %r15d, %edx
callq 0x20db2
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x22a5c
cvtsi2sdl 0x134(%rax), %xmm0
movsd 0x7332f(%rip), %xmm4    # 0x95d20
addsd %xmm4, %xmm0
mulsd 0x20(%rsp), %xmm0
cvtsi2sdl (%r13), %xmm1
cvtsi2sdl 0x138(%rax), %xmm2
movsd 0x7535f(%rip), %xmm3    # 0x97d70
addsd %xmm3, %xmm0
addsd %xmm4, %xmm2
mulsd 0x18(%rsp), %xmm2
subsd %xmm2, %xmm1
addsd %xmm3, %xmm1
movsd 0x8(%rsp), %xmm2
addsd %xmm2, %xmm1
cvttsd2si 0x30(%rsp), %esi
addsd 0x10(%rsp), %xmm1
movsd 0x28(%rsp), %xmm3
subsd %xmm2, %xmm3
cvttsd2si %xmm3, %edx
cvttsd2si %xmm0, %ecx
cvttsd2si %xmm1, %r8d
movq %r12, %rdi
callq 0x20866
movq (%r14), %rsi
movq %r12, %rdi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x228f8
movq 0x8(%r14), %r14
movsd 0x8(%rsp), %xmm5
movsd 0x732a3(%rip), %xmm2    # 0x95d20
movsd 0x752eb(%rip), %xmm3    # 0x97d70
jmp 0x22957
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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, %rbx
andl $0x0, 0xc(%rsp)
callq 0x6e370
movl %eax, %ebp
movq %rbx, %rdi
callq 0x6c571
movl %eax, %r12d
movq %rbx, %rdi
callq 0x6c59d
movl %eax, %r15d
leaq 0x751da(%rip), %rdi     # 0x97e8b
leaq 0x78bd9(%rip), %rsi     # 0x9b891
callq 0x40f0
testq %rax, %rax
je 0x22d1b
movq %rax, %r14
addl %r12d, %r15d
movq %rax, %rdi
movl $0x294, %esi            # imm = 0x294
movl $0x294, %edx            # imm = 0x294
callq 0x1ffcc
movq %rbx, %rdi
callq 0x6e2a6
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x6e271
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %r15d, %ecx
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x22a99
movq %r14, %rdi
callq 0x42a0
movq %r14, %rdi
callq 0x20a81
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
andl $0x0, 0xc(%rsp)
callq 0x1bdbf
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1a834
movl %eax, %r12d
movq %rbx, %rdi
callq 0x1a8d0
movl %eax, %r15d
leaq 0x7512b(%rip), %rdi     # 0x97e8b
leaq 0x78b2a(%rip), %rsi     # 0x9b891
callq 0x40f0
testq %rax, %rax
je 0x22dbe
movq %rax, %r14
addl %r12d, %r15d
movq %rax, %rdi
movl $0x294, %esi            # imm = 0x294
movl $0x294, %edx            # imm = 0x294
callq 0x1ffcc
movq %rbx, %rdi
callq 0x1bf81
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x1be67
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x228f8
movq %r14, %rdi
callq 0x42a0
movq %r14, %rdi
callq 0x20a81
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/eps.c
// Function: rank_plot
void rank_plot(char** names, int filecount)
{
 FILE* myfile, *outfile;
 int obs, i, barheight = MARGIN, bargap = SMALLMARGIN, gap = SMALLMARGIN, count = file_length(names[0]), barwidth = epsaxis / (count * filecount) - bargap;
 outfile = fopen("image.eps", "w");
 if (!outfile)
   return; 
 write_image_header(outfile, 2 * MARGIN + epsaxis, (barheight + gap) * filecount + gap);
 for (i = 0; i < filecount; i++)
   write_line(outfile, MARGIN, (barheight + gap) * i + gap, epsaxis + MARGIN, (barheight + gap) * i + gap);
 for (i = 0; i < filecount; i++)
  {
   myfile = fopen(names[i], "r");
   if (!myfile)
    { 
     printf(m1274, names[i]);
     return;
    }
   while (fscanf(myfile, "%d\n", &obs) != EOF)
     write_rectangle(outfile, MARGIN + (barwidth + bargap) * (obs - 1), (barheight + gap) * i + gap, MARGIN + (barwidth + bargap) * (obs - 1) + barwidth, (barheight + gap) * i + 0.75 * barheight, FILL_COLOR, i % COLORCOUNT);
   fclose(myfile);
  }  
 write_image_footer(outfile);
 fclose(outfile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movq %rdi, 0x18(%rsp)
movq (%rdi), %rdi
callq 0x33f62
movl %eax, %ecx
imull %ebx, %ecx
xorl %r12d, %r12d
movl $0x1f4, %eax            # imm = 0x1F4
xorl %edx, %edx
idivl %ecx
movl %eax, %r13d
leaq 0x74ddf(%rip), %rdi     # 0x97e8b
leaq 0x787de(%rip), %rsi     # 0x9b891
callq 0x40f0
testq %rax, %rax
je 0x231ed
movq %rax, %r15
movq %r13, %r14
leal -0x5(%r13), %eax
movq %rax, 0x30(%rsp)
imull $0x55, %ebx, %edx
addl $0x5, %edx
movq %r15, %rdi
movl $0x294, %esi            # imm = 0x294
callq 0x1ffcc
testl %ebx, %ebx
cmovgl %ebx, %r12d
pushq $0x5
popq %rbx
pushq $0x50
popq %rbp
movl %r12d, %r13d
subl $0x1, %r13d
jb 0x23111
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
movl $0x244, %ecx            # imm = 0x244
movl %ebx, %r8d
callq 0x20866
addl $0x55, %ebx
jmp 0x230f2
movl %r12d, %eax
movq %rax, 0x20(%rsp)
xorl %ebp, %ebp
cmpq 0x20(%rsp), %rbp
je 0x231c4
movq 0x18(%rsp), %rax
movq (%rax,%rbp,8), %rdi
leaq 0x78749(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x231d6
movq %rax, %r12
imull $0x55, %ebp, %ebx
addl $0x3c, %ebx
movl %ebp, %eax
xorl %edx, %edx
pushq $0xc
popq %rcx
divl %ecx
movl %edx, %r13d
movq %rbp, 0x28(%rsp)
imull $0x55, %ebp, %ebp
addl $0x5, %ebp
movq %r12, %rdi
leaq 0x7d3d7(%rip), %rsi     # 0xa0545
leaq 0x14(%rsp), %rdx
xorl %eax, %eax
callq 0x4070
cmpl $-0x1, %eax
je 0x231af
movl 0x14(%rsp), %eax
decl %eax
imull %r14d, %eax
movq 0x30(%rsp), %rcx
addl %eax, %ecx
addl $0x50, %ecx
movl %eax, %esi
addl $0x50, %esi
movl %r13d, (%rsp)
movq %r15, %rdi
movl %ebp, %edx
movl %ebx, %r8d
pushq $0x4
popq %r9
callq 0x209ea
jmp 0x23164
movq %r12, %rdi
callq 0x42a0
movq 0x28(%rsp), %rbp
incq %rbp
jmp 0x2311b
movq %r15, %rdi
callq 0x20a81
movq %r15, %rdi
callq 0x42a0
jmp 0x231ed
movq 0x18(%rsp), %rax
movq (%rax,%rbp,8), %rsi
leaq 0x73024(%rip), %rdi     # 0x9620a
xorl %eax, %eax
callq 0x4030
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 0x748cf(%rip), %rdi     # 0x97f87
leaq 0x781c0(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x236f9
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r14, %rdx
callq 0x4120
testq %rax, %rax
je 0x236f1
movq %r15, %rdi
movq %rbx, %rsi
callq 0x41f0
jmp 0x236cf
movq %r14, %rdi
callq 0x42a0
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/graphdata.c
// Function: load_data
int load_data(bayesiangraphptr mygraph, Bndata* mydata, char *f_name)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 07.03.2001*/
 FILE *myfile;
 int i, j, k = file_length(f_name);
 char *st;
 char st1[3];
 char myline[READLINELENGTH];
 if (k == 0)
   return 0;
 if (mydata->data)
   free_2d((void**)(void **)mydata->data, mydata->row);
 mydata->row = k;
 mydata->data = (int**) safemalloc_2d(sizeof(int *), sizeof(int), mydata->row, mydata->col, "load_data", 11);
 st1[0] = ' ';
 st1[1] = '\n';
 st1[2] = '\0';
 myfile = fopen(f_name, "r");
 if (!myfile)
   return 0;
 fgets(myline, READLINELENGTH, myfile);
 st = strtok(myline, st1);
 i = 0;
 while (st)
  {
   i++;
   st = strtok(NULL,st1);
  }
 mydata->col = i;
 fseek(myfile, 0, SEEK_SET);
 j = 0;
 while (fgets(myline, READLINELENGTH, myfile))
  {
   st = strtok(myline, st1);
   i = 0;
   while (st)
    {
     mydata->data[j][i] = listindex(st, mygraph->nodes[i].values, mygraph->nodes[i].value_count);
     i++;
     st = strtok(NULL, st1);
    }
   j++;
  }
 fclose(myfile);
 return k;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a138, %rsp          # imm = 0x7A138
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x33f62
xorl %r12d, %r12d
testl %eax, %eax
je 0x2386e
movl %eax, %ebp
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x23747
movl 0x8(%rbx), %esi
callq 0x34fc3
movl %ebp, 0x8(%rbx)
movl 0xc(%rbx), %ecx
leaq 0x749c6(%rip), %r8      # 0x9811a
pushq $0x8
popq %rdi
pushq $0x4
popq %rsi
pushq $0xb
popq %r9
movl %ebp, %edx
callq 0x351c3
movq %rax, (%rbx)
movw $0xa20, 0x1(%rsp)       # imm = 0xA20
movb $0x0, 0x3(%rsp)
leaq 0x78104(%rip), %rsi     # 0x9b87f
movq %r15, %rdi
callq 0x40f0
testq %rax, %rax
je 0x2386e
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rax, 0x8(%rsp)
movq %rax, %rdx
callq 0x4120
leaq 0x1(%rsp), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x4280
xorl %r15d, %r15d
testq %rax, %rax
je 0x237cd
incl %r15d
xorl %edi, %edi
movq %r12, %rsi
callq 0x4280
jmp 0x237b9
movl %ebp, 0x4(%rsp)
movl %r15d, 0xc(%rbx)
xorl %ebp, %ebp
movq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x40a0
leaq 0x10(%rsp), %r12
leaq 0x1(%rsp), %r13
movq %r12, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r15, %rdx
callq 0x4120
testq %rax, %rax
je 0x23861
movq %r12, %rdi
movq %r13, %rsi
callq 0x4280
pushq $0x10
popq %r15
xorl %r12d, %r12d
testq %rax, %rax
je 0x23852
movq 0x8(%r14), %rcx
movq -0x8(%rcx,%r15), %rsi
movl (%rcx,%r15), %edx
movq %rax, %rdi
callq 0x35f17
movq (%rbx), %rcx
movq (%rcx,%rbp,8), %rcx
movl %eax, (%rcx,%r12)
xorl %edi, %edi
movq %r13, %rsi
callq 0x4280
addq $0x4, %r12
addq $0x48, %r15
jmp 0x23819
incq %rbp
movq 0x8(%rsp), %r15
leaq 0x10(%rsp), %r12
jmp 0x237f2
movq %r15, %rdi
callq 0x42a0
movl 0x4(%rsp), %r12d
movl %r12d, %eax
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 %r14
pushq %rbx
leaq 0xa984c(%rip), %rax     # 0xcd4b8
movl 0x8(%rax), %ecx
movq (%rax), %r8
movslq %edx, %rdx
xorl %r9d, %r9d
testl %edx, %edx
movl $0x0, %r10d
cmovgl %edx, %r10d
testl %ecx, %ecx
cmovlel %r9d, %ecx
xorl %eax, %eax
cmpq %rcx, %r9
je 0x23cc0
xorl %ebx, %ebx
movq %rbx, %r11
cmpq %rbx, %r10
je 0x23cb1
movq (%r8,%r9,8), %rbx
movslq (%rdi,%r11,4), %r14
movl (%rbx,%r14,4), %ebp
leaq 0x1(%r11), %rbx
cmpl (%rsi,%r11,4), %ebp
je 0x23c93
xorl %ebx, %ebx
cmpq %rdx, %r11
setge %bl
addl %ebx, %eax
incq %r9
jmp 0x23c8c
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %ebx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x77b9a(%rip), %rsi     # 0x9b87f
callq 0x40f0
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x23d98
leaq 0xd(%rsp), %rax
movw $0xa20, (%rax)          # imm = 0xA20
movb $0x0, 0x2(%rax)
xorl %r12d, %r12d
testl %ebx, %ebx
cmovlel %r12d, %ebx
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq 0x10(%rsp), %rdx
callq 0x4120
testq %rax, %rax
je 0x23d8c
movq %r12, 0x18(%rsp)
movq %r13, %rdi
leaq 0xd(%rsp), %rsi
callq 0x4280
movq %rax, %r13
xorl %ebp, %ebp
testq %r13, %r13
je 0x23d7d
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x23d6a
cmpl %ebp, (%r15,%r12,4)
jne 0x23d65
movq (%r14,%r12,8), %rdi
movq %r13, %rsi
callq 0x4260
testl %eax, %eax
jne 0x23d7d
incq %r12
jmp 0x23d4a
incl %ebp
xorl %edi, %edi
leaq 0xd(%rsp), %rsi
callq 0x4280
movq %rax, %r13
jmp 0x23d42
cmpq $0x1, %r13
movq 0x18(%rsp), %r12
adcl $0x0, %r12d
jmp 0x23d0f
movq 0x10(%rsp), %rdi
callq 0x42a0
jmp 0x23d9b
xorl %r12d, %r12d
movl %r12d, %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_O2/olcaytaner[P]Isell/graphdata.c
// Function: guess_data
int guess_data(Bndata mydata, bayesiangraphptr mygraph)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 07.03.2001*/
 int i, j, k, pos, value_pos, *parents, *list1, result = 0, maxindex;
 double max;
 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), "guess_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;
     max = 0;
     maxindex = -1;
     for (k = 0; k < mygraph->nodes[j].parents; k++)
       if (mygraph->nodes[j].table[pos][k] > max)
        {
         max = mygraph->nodes[j].table[pos][k];
         maxindex = k;
        }
     if (maxindex == value_pos)
       result++;   
    }
 return result;   
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r13
movq %rdi, %r14
movq %rsi, %rax
shrq $0x20, %rax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movq %rax, 0x68(%rsp)
testl %esi, %esi
movl $0x0, %eax
cmovgl %esi, %eax
movq %rax, 0x58(%rsp)
xorl %ebx, %ebx
xorl %eax, %eax
movq %rdx, 0x60(%rsp)
cmpq 0x58(%rsp), %rbx
je 0x23f25
xorl %r10d, %r10d
cmpq 0x68(%rsp), %r10
je 0x23f1d
movq (%r14,%rbx,8), %rcx
movl (%rcx,%r10,4), %r11d
movq 0x8(%r13), %rdx
imulq $0x48, %r10, %r15
cmpl $0x0, 0x20(%rdx,%r15)
je 0x23ec6
movl %r11d, 0x50(%rsp)
movl %eax, 0x54(%rsp)
movq %r13, %rdi
movq %r10, 0x70(%rsp)
movl %r10d, %esi
callq 0x47301
movq %rax, %rbp
movq 0x8(%r13), %rax
movslq 0x20(%rax,%r15), %rdi
shlq $0x2, %rdi
leaq 0x74302(%rip), %rsi     # 0x98156
pushq $0xa
popq %rdx
callq 0x34f59
movq %rax, %r12
movq 0x8(%r13), %rsi
addq %r15, %rsi
xorl %eax, %eax
movslq 0x20(%rsi), %rcx
cmpq %rcx, %rax
jge 0x23e86
movq (%r14,%rbx,8), %rcx
movslq (%rbp,%rax,4), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, (%r12,%rax,4)
incq %rax
jmp 0x23e68
pushq $0x9
popq %rcx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %r12, %rdi
callq 0x472d4
movl %eax, %r13d
movq %rbp, %rdi
callq 0x34ff7
movq %r12, %rdi
callq 0x34ff7
movslq %r13d, %r9
movq 0x60(%rsp), %r13
movq 0x8(%r13), %rdx
movl 0x54(%rsp), %eax
movq 0x70(%rsp), %r10
movl 0x50(%rsp), %r11d
jmp 0x23ec9
xorl %r9d, %r9d
movl 0x20(%rdx,%r15), %ecx
testl %ecx, %ecx
movl $0x0, %esi
cmovlel %esi, %ecx
addq %r15, %rdx
xorpd %xmm0, %xmm0
xorl %edi, %edi
pushq $-0x1
popq %rsi
cmpq %rdi, %rcx
je 0x23f0b
movq 0x38(%rdx), %r8
movq (%r8,%r9,8), %r8
movsd (%r8,%rdi,8), %xmm1
ucomisd %xmm0, %xmm1
cmoval %edi, %esi
maxsd %xmm0, %xmm1
incq %rdi
movapd %xmm1, %xmm0
jmp 0x23ee4
xorl %ecx, %ecx
cmpl %r11d, %esi
sete %cl
addl %ecx, %eax
incq %r10
jmp 0x23dfd
incq %rbx
jmp 0x23def
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, %r15
movq %rdx, %rax
shrq $0x20, %rax
xorl %r14d, %r14d
testl %eax, %eax
cmovlel %r14d, %eax
movq %rax, 0x60(%rsp)
testl %edx, %edx
movl $0x0, %eax
cmovgl %edx, %eax
movq %rax, 0x50(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x48(%rsp)
movq %rdi, 0x58(%rsp)
cmpq 0x50(%rsp), %r14
je 0x2408b
xorl %r13d, %r13d
cmpq 0x60(%rsp), %r13
je 0x24083
movq (%rbx,%r14,8), %rax
movslq (%rax,%r13,4), %rdx
movq 0x8(%r15), %rax
imulq $0x48, %r13, %r12
cmpl $0x0, 0x20(%rax,%r12)
je 0x2404c
movq %rdx, 0x68(%rsp)
movq %r15, %rdi
movq %r13, 0x70(%rsp)
movl %r13d, %esi
callq 0x47301
movq %r15, %r13
movq %rax, %r15
movq 0x8(%r13), %rax
movslq 0x20(%rax,%r12), %rdi
shlq $0x2, %rdi
leaq 0x74182(%rip), %rsi     # 0x98161
pushq $0xa
popq %rdx
callq 0x34f59
movq %rax, %rbp
movq 0x8(%r13), %rsi
addq %r12, %rsi
xorl %eax, %eax
movslq 0x20(%rsi), %rcx
cmpq %rcx, %rax
jge 0x24010
movq (%rbx,%r14,8), %rcx
movslq (%r15,%rax,4), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, (%rbp,%rax,4)
incq %rax
jmp 0x23ff3
pushq $0x9
popq %rcx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbp, %rdi
callq 0x472d4
movl %eax, %r13d
movq %r15, %rdi
callq 0x34ff7
movq %rbp, %rdi
callq 0x34ff7
movslq %r13d, %rcx
movq 0x58(%rsp), %r15
movq 0x8(%r15), %rax
movq 0x70(%rsp), %r13
movq 0x68(%rsp), %rdx
jmp 0x2404e
xorl %ecx, %ecx
movq 0x38(%rax,%r12), %rax
movq (%rax,%rcx,8), %rax
movsd (%rax,%rdx,8), %xmm0
ucomisd 0x71cb4(%rip), %xmm0    # 0x95d18
jbe 0x2407b
callq 0x34d77
movsd 0x48(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x48(%rsp)
incq %r13
jmp 0x23f89
incq %r14
jmp 0x23f7b
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_O2/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 $0x28, %rsp
movl %ecx, %r12d
movl %edx, %r14d
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movslq %ecx, %rbx
leaq (,%rbx,8), %rdi
leaq 0x740a4(%rip), %rbp     # 0x98174
pushq $0x4
popq %rdx
movq %rbp, %rsi
callq 0x34f59
movq %rax, %r13
movq %r14, 0x20(%rsp)
movslq %r14d, %r15
shlq $0x2, %r15
xorl %r14d, %r14d
testl %ebx, %ebx
movl $0x0, %ebx
movl %r12d, 0xc(%rsp)
cmovgl %r12d, %ebx
pushq $0x6
popq %r12
cmpq %r14, %rbx
je 0x2411e
movq %r15, %rdi
movq %rbp, %rsi
movl %r12d, %edx
callq 0x34f59
movq %rax, (%r13,%r14,8)
incq %r14
jmp 0x24101
xorl %esi, %esi
movq 0x20(%rsp), %r14
testl %r14d, %r14d
cmovlel %esi, %r14d
pushq $0x1
popq %rdi
movl 0xc(%rsp), %r11d
movq 0x18(%rsp), %r15
movq 0x10(%rsp), %r12
cmpq %r14, %rsi
je 0x24193
movq 0x8(%r12), %rax
movslq (%r15,%rsi,4), %rcx
imulq $0x48, %rcx, %rcx
movl 0x10(%rax,%rcx), %r8d
imull %r8d, %edi
movl %r11d, %eax
cltd
idivl %edi
movl %eax, %ecx
xorl %r9d, %r9d
movl %eax, %r10d
xorl %eax, %eax
cmpq %r9, %rbx
je 0x2418e
testl %r10d, %r10d
jg 0x2417e
incl %eax
cltd
idivl %r8d
movl %ecx, %r10d
movl %edx, %eax
movq (%r13,%r9,8), %rdx
movl %eax, (%rdx,%rsi,4)
decl %r10d
incq %r9
jmp 0x24169
incq %rsi
jmp 0x2413e
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
xorps %xmm0, %xmm0
testl %ebx, %ebx
jle 0x241dc
movsd %xmm0, 0x8(%rsp)
cvtsi2sd %ebx, %xmm0
callq 0x4160
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
decl %ebx
jmp 0x241af
addq $0x10, %rsp
popq %rbx
retq