LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd 0xb59d9(%rip), %xmm0    # 0xe4828
movsd %xmm0, -0x30(%rbp)
movsd 0xb5a04(%rip), %xmm0    # 0xe4860
movsd %xmm0, -0x38(%rbp)
movsd 0xb59ef(%rip), %xmm0    # 0xe4858
movsd %xmm0, -0x40(%rbp)
movsd 0xb59da(%rip), %xmm0    # 0xe4850
movsd %xmm0, -0x48(%rbp)
movsd 0xb59c5(%rip), %xmm0    # 0xe4848
movsd %xmm0, -0x50(%rbp)
movsd 0xb59b0(%rip), %xmm0    # 0xe4840
movsd %xmm0, -0x58(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xb3b16(%rip), %xmm1    # 0xe29b8
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
callq 0x2efc0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2eeff
movsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd -0x28(%rbp), %xmm1
movsd -0x28(%rbp), %xmm3
movsd -0x28(%rbp), %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd -0x10(%rbp), %xmm1
movsd 0xb3b8e(%rip), %xmm2    # 0xe2a80
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x38(%rbp), %xmm1
movsd -0x40(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2ef6d
movsd -0x20(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
divsd -0x10(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd -0x50(%rbp), %xmm1
mulsd -0x28(%rbp), %xmm1
divsd -0x10(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0xb308a(%rip), %xmm1    # 0xe2018
subsd %xmm1, %xmm0
callq 0x4120
movsd -0x68(%rbp), %xmm1
movaps %xmm0, %xmm3
movsd -0x60(%rbp), %xmm0
movsd -0x58(%rbp), %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x10(%rbp)
movsd 0xb589b(%rip), %xmm0    # 0xe4870
movsd %xmm0, -0x18(%rbp)
movsd 0xb5886(%rip), %xmm0    # 0xe4868
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jae 0x2f00c
movsd -0x10(%rbp), %xmm0
movsd 0xb3012(%rip), %xmm1    # 0xe2018
ucomisd %xmm1, %xmm0
jb 0x2f016
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2f088
jmp 0x2f018
movsd -0x20(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movsd 0xb5716(%rip), %xmm1    # 0xe4740
ucomisd %xmm1, %xmm0
jbe 0x2f07e
movsd -0x28(%rbp), %xmm0
callq 0x2d930
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x2f057
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x2f061
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x20(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd 0xb3945(%rip), %xmm1    # 0xe29b8
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x2f018
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl -0x4(%rbp), %eax
imull -0x8(%rbp), %eax
cvtsi2sd %eax, %xmm0
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
cvtsi2sd %eax, %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x42a0
movsd 0xb53c6(%rip), %xmm1    # 0xe48b0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x42a0
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
movsd 0xb539b(%rip), %xmm1    # 0xe48a8
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0x65, -0x14(%rbp)
jg 0x2f5d6
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x2f588
movsd 0xb5365(%rip), %xmm0    # 0xe48b8
mulsd -0x28(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
mulsd %xmm1, %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x4060
movsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x2f5c6
movsd 0xb5328(%rip), %xmm0    # 0xe48b8
mulsd -0x28(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
mulsd %xmm1, %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x4060
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x2f5c8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2f52e
movsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq 0xd5e32(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
testl %eax, %eax
je 0x2fa47
jmp 0x2fa2c
movl -0x28(%rbp), %eax
subl $0x1, %eax
je 0x2fafd
jmp 0x2fa3a
movl -0x28(%rbp), %eax
subl $0x2, %eax
je 0x2faa5
jmp 0x2fb23
movsbl -0x14(%rbp), %eax
cmpl $0x3c, %eax
jne 0x2fa73
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,8), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x2fa73
movl $0x0, -0x4(%rbp)
jmp 0x2fb2a
movsbl -0x14(%rbp), %eax
cmpl $0x3e, %eax
jne 0x2faa3
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,8), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2faa3
movl $0x0, -0x4(%rbp)
jmp 0x2fb2a
jmp 0x2fb23
movsbl -0x14(%rbp), %eax
cmpl $0x3c, %eax
jne 0x2face
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x2face
movl $0x0, -0x4(%rbp)
jmp 0x2fb2a
movsbl -0x14(%rbp), %eax
cmpl $0x3e, %eax
jne 0x2fafb
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2fafb
movl $0x0, -0x4(%rbp)
jmp 0x2fb2a
jmp 0x2fb23
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,8), %xmm0
ucomisd -0x10(%rbp), %xmm0
jne 0x2fb18
jp 0x2fb18
jmp 0x2fb21
movl $0x0, -0x4(%rbp)
jmp 0x2fb2a
jmp 0x2fb23
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2fbba
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movsd -0x30(%rbp), %xmm0
callq 0x2f9f0
cmpl $0x0, %eax
je 0x2fbad
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x2fbab
movl $0x1, -0x4(%rbp)
jmp 0x2fbc1
jmp 0x2fbad
jmp 0x2fbaf
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2fb54
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2fc5e
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movl -0x2c(%rbp), %ecx
callq 0x2fb30
cmpl $0x0, %eax
jne 0x2fc51
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x30(%rbp), %eax
jle 0x2fc4f
movl $0x0, -0x4(%rbp)
jmp 0x2fc65
jmp 0x2fc51
jmp 0x2fc53
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2fbfd
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
leaq 0xd5bb3(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
movl $0x4, %esi
leaq 0xb4c70(%rip), %rdx     # 0xe4910
movl $0x2, %ecx
callq 0x52f40
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x2fd2f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movl -0x14(%rbp), %r8d
movl -0x18(%rbp), %r9d
callq 0x2fbd0
cmpl $0x0, %eax
je 0x2fd22
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x2fd24
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2fcb5
movq -0x28(%rbp), %rdi
leaq 0xd5b06(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x50070
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x52e80
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x7fffffff, -0x28(%rbp) # imm = 0x7FFFFFFF
movl $0x0, -0x20(%rbp)
cmpl $0x19, -0x20(%rbp)
jg 0x2fe30
movl $0x1, -0x1c(%rbp)
cmpl $0x14, -0x1c(%rbp)
jg 0x2fe20
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2fdee
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
callq 0x2fc70
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x43530
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
je 0x2fde0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2fda8
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x2fe10
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
jmp 0x2fe12
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2fd8f
jmp 0x2fe22
movl -0x20(%rbp), %eax
addl $0x5, %eax
movl %eax, -0x20(%rbp)
jmp 0x2fd7e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xb3064(%rip), %rsi     # 0xe4ad1
movl $0x25, %edx
movb $0x0, %al
callq 0x4280
movq -0x8(%rbp), %rdi
leaq 0xb3067(%rip), %rsi     # 0xe4aeb
movl $0x25, %ecx
movl %ecx, %edx
movb $0x0, %al
callq 0x4280
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %r8d
movl -0x10(%rbp), %r9d
leaq 0xb3068(%rip), %rsi     # 0xe4b0d
movl $0x25, %ecx
movl %ecx, %edx
movb $0x0, %al
callq 0x4280
movq -0x8(%rbp), %rdi
leaq 0xb306b(%rip), %rsi     # 0xe4b29
movb $0x0, %al
callq 0x4280
movq -0x8(%rbp), %rdi
callq 0x36940
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
leaq 0xb1f58(%rip), %rsi     # 0xe4b83
movb $0x0, %al
callq 0x4280
movl -0x1c(%rbp), %edi
movl $0x3, %ecx
movl $0x5, %edx
movl $0x4, %r8d
movl %ecx, %esi
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0x32c65
movq -0x8(%rbp), %rdi
leaq 0xb1f7d(%rip), %rsi     # 0xe4bdb
movb $0x0, %al
callq 0x4280
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
testl %eax, %eax
je 0x32ca3
jmp 0x32c71
movl -0x20(%rbp), %eax
subl $0x1, %eax
je 0x32cd3
jmp 0x32c7b
movl -0x20(%rbp), %eax
subl $0x2, %eax
je 0x32cbb
jmp 0x32c85
movl -0x20(%rbp), %eax
subl $0x3, %eax
je 0x32ca3
jmp 0x32c8f
movl -0x20(%rbp), %eax
subl $0x4, %eax
je 0x32cd3
jmp 0x32c99
movl -0x20(%rbp), %eax
subl $0x5, %eax
je 0x32cbb
jmp 0x32ce9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xb1f02(%rip), %rsi     # 0xe4bb4
movb $0x0, %al
callq 0x4280
jmp 0x32ce9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xb1ef7(%rip), %rsi     # 0xe4bc1
movb $0x0, %al
callq 0x4280
jmp 0x32ce9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xb1eeb(%rip), %rsi     # 0xe4bcd
movb $0x0, %al
callq 0x4280
movl -0x1c(%rbp), %edi
movl $0x3, %ecx
movl $0x5, %edx
movl $0x4, %r8d
movl %ecx, %esi
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0x32d1c
movq -0x8(%rbp), %rdi
leaq 0xb1ec5(%rip), %rsi     # 0xe4bda
movb $0x0, %al
callq 0x4280
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2b1f0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28ce0
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28de0
movl %eax, %ecx
movl -0x20(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
leaq 0xb17be(%rip), %rdi     # 0xe4a53
leaq 0xb4f22(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x332ae
jmp 0x332f9
movq -0x10(%rbp), %rdi
movl $0x294, %edx            # imm = 0x294
movl %edx, %esi
callq 0x31a50
movq -0x8(%rbp), %rdi
callq 0x2b4c0
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x2b310
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x32f00
movq -0x10(%rbp), %rdi
callq 0x32ec0
movq -0x10(%rbp), %rdi
callq 0x4250
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa8b50
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa5f20
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa5f80
movl %eax, %ecx
movl -0x38(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x34(%rbp)
leaq 0xaf461(%rip), %rdi     # 0xe4a53
leaq 0xb2bc5(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3560b
jmp 0x35664
movq -0x28(%rbp), %rdi
movl $0x294, %edx            # imm = 0x294
movl %edx, %esi
callq 0x31a50
movq -0x8(%rbp), %rdi
callq 0xa8a10
movq -0x8(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0xa89b0
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x30(%rbp), %edx
movl -0x34(%rbp), %ecx
movl -0xc(%rbp), %r8d
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x35290
movq -0x28(%rbp), %rdi
callq 0x4250
movq -0x28(%rbp), %rdi
callq 0x32ec0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa8b50
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa5f20
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa5f80
movl %eax, %ecx
movl -0x30(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x2c(%rbp)
leaq 0xaeed4(%rip), %rdi     # 0xe4a53
leaq 0xb2638(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x35b98
jmp 0x35bed
movq -0x20(%rbp), %rdi
movl $0x294, %edx            # imm = 0x294
movl %edx, %esi
callq 0x31a50
movq -0x8(%rbp), %rdi
callq 0xa8a10
movq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0xa89b0
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x28(%rbp), %edx
movl -0x2c(%rbp), %ecx
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x358a0
movq -0x20(%rbp), %rdi
callq 0x4250
movq -0x20(%rbp), %rdi
callq 0x32ec0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2b1f0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28ce0
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28de0
movl %eax, %ecx
movl -0x20(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
leaq 0xaee0e(%rip), %rdi     # 0xe4a53
leaq 0xb2572(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x35c5e
jmp 0x35ca9
movq -0x10(%rbp), %rdi
movl $0x294, %edx            # imm = 0x294
movl %edx, %esi
callq 0x31a50
movq -0x8(%rbp), %rdi
callq 0x2b4c0
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x2b310
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x35670
movq -0x10(%rbp), %rdi
callq 0x4250
movq -0x10(%rbp), %rdi
callq 0x32ec0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/eps.c
// Function: write_axis
void write_axis(FILE* myfile, int tickcount, int tickwidth, int p1, int p2, int p3, AXIS_TYPE axistype)
{
 /*!Last Changed 18.09.2006*/
 switch (axistype)
  {   
   case X_AXIS:fprintf(myfile, "%d %d %d %d %d xaxis\n", tickcount, tickwidth, p1, p2, p3);    
               break;
   case Y_AXIS:fprintf(myfile, "%d %d %d %d %d yaxis\n", tickcount, tickwidth, p1, p2, p3);    
               break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl 0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
testl %eax, %eax
je 0x368e6
jmp 0x368dc
movl -0x20(%rbp), %eax
subl $0x1, %eax
je 0x3690e
jmp 0x36934
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl -0x18(%rbp), %r9d
movl -0x1c(%rbp), %eax
leaq 0xae3b4(%rip), %rsi     # 0xe4cb6
movl %eax, (%rsp)
movb $0x0, %al
callq 0x4280
jmp 0x36934
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl -0x18(%rbp), %r9d
movl -0x1c(%rbp), %eax
leaq 0xae3a2(%rip), %rsi     # 0xe4ccc
movl %eax, (%rsp)
movb $0x0, %al
callq 0x4280
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x7a130, %rsp          # imm = 0x7A130
movq %rdi, -0x8(%rbp)
leaq 0xae1f9(%rip), %rdi     # 0xe4b4f
leaq 0xb1849(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3696f
jmp 0x369b0
jmp 0x36971
leaq -0x7a130(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x40f0
cmpq $0x0, %rax
je 0x369a7
movq -0x8(%rbp), %rdi
leaq -0x7a130(%rbp), %rdx
leaq 0xae0fa(%rip), %rsi     # 0xe4a98
movb $0x0, %al
callq 0x4280
jmp 0x36971
movq -0x10(%rbp), %rdi
callq 0x4250
addq $0x7a130, %rsp          # imm = 0x7A130
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
leaq 0xce261(%rip), %rcx     # 0x105488
cmpl 0x8(%rcx), %eax
jge 0x372a5
movl $0x1, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x37286
leaq 0xce23f(%rip), %rax     # 0x105488
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x37279
movl $0x0, -0x24(%rbp)
jmp 0x37286
jmp 0x3727b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3723a
cmpl $0x0, -0x24(%rbp)
je 0x37295
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x37297
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3721d
movl -0x20(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x7a170, %rsp          # imm = 0x7A170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xb0eca(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x372f7
movl $0x0, -0x4(%rbp)
jmp 0x373e3
movb $0x20, -0x4b(%rbp)
movb $0xa, -0x4a(%rbp)
movb $0x0, -0x49(%rbp)
leaq -0x7a170(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x40f0
cmpq $0x0, %rax
je 0x373d4
leaq -0x7a170(%rbp), %rdi
leaq -0x4b(%rbp), %rsi
callq 0x4230
movq %rax, -0x48(%rbp)
movl $0x1, -0x40(%rbp)
movl $0x0, -0x34(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x373c0
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x3739c
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x34(%rbp), %eax
jne 0x3738f
movq -0x20(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x48(%rbp), %rsi
callq 0x4210
cmpl $0x0, %eax
je 0x3738d
movl $0x0, -0x40(%rbp)
jmp 0x3739c
jmp 0x3738f
jmp 0x37391
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x37352
cmpl $0x0, -0x40(%rbp)
jne 0x373a4
jmp 0x373c0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
leaq -0x4b(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x4230
movq %rax, -0x48(%rbp)
jmp 0x37344
cmpl $0x0, -0x40(%rbp)
je 0x373cf
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x37303
movq -0x30(%rbp), %rdi
callq 0x4250
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x7a170, %rsp          # imm = 0x7A170
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x379ff
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
cvtsi2sdl -0x8(%rbp), %xmm0
callq 0x4120
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x379c9
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
leaq 0xad0d8(%rip), %rsi     # 0xe4d6a
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x58(%rbp)
movsd 0xaadb8(%rip), %xmm0    # 0xe2a60
movsd %xmm0, -0x40(%rbp)
movl $0xffffffff, -0x4c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x37ce4
movq -0x18(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x58(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x37cbb
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x37da8
movl $0x0, -0x5c(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x37d3b
movq -0x28(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x48(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x37d2e
movl $0x1, -0x5c(%rbp)
jmp 0x37d3b
jmp 0x37d30
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x37d05
movq -0x28(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x58(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
cmpl $0x0, -0x5c(%rbp)
jne 0x37d98
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x58(%rbp), %rdx
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
callq 0x37a10
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
ucomisd -0x40(%rbp), %xmm0
jbe 0x37d96
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x28(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4c(%rbp)
jmp 0x37d98
jmp 0x37d9a
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x37ceb
movq -0x58(%rbp), %rdi
callq 0x52e80
movl -0x4c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0x18, %edi
leaq 0xace93(%rip), %rsi     # 0xe4e90
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x5, %rdi
leaq 0xace76(%rip), %rsi     # 0xe4e90
movl $0x3, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x38751
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x38770
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x52e80
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x386e3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: alloc_hmm
Hmmptr alloc_hmm(int statecount, HMM_STATE_TYPE statetype, int componentcount, HMM_MODEL_TYPE hmmtype)
{
 /*!Last Changed 15.03.2007*/
 int i;
 Hmmptr desthmm = empty_hmm(statecount, statetype, hmmtype);
 for (i = 0; i < statecount; i++)
  {
    desthmm->states[i].pi = 0;
    desthmm->states[i].a_dot_j = safemalloc(sizeof(double) * statecount, "init_hmm", 6);
    desthmm->states[i].a_i_dot = safemalloc(sizeof(double) * statecount, "init_hmm", 7);
    desthmm->states[i].b = alloc_state_model(statetype, componentcount);
  } 
 return desthmm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x37fe0
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x38a08
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
leaq 0xac523(%rip), %rsi     # 0xe4ea5
movl $0x6, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
leaq 0xac4f2(%rip), %rsi     # 0xe4ea5
movl $0x7, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x38a20
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3894d
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: calloc_hmm
Hmmptr calloc_hmm(int statecount, HMM_STATE_TYPE statetype, int componentcount, HMM_MODEL_TYPE hmmtype)
{
 /*!Last Changed 15.03.2007*/
 int i;
 Hmmptr desthmm = empty_hmm(statecount, statetype, hmmtype);
 for (i = 0; i < statecount; i++)
  {
    desthmm->states[i].pi = 0;
    desthmm->states[i].a_dot_j = safecalloc(statecount, sizeof(double), "init_hmm", 6);
    desthmm->states[i].a_i_dot = safecalloc(statecount, sizeof(double), "init_hmm", 7);
    desthmm->states[i].b = calloc_state_model(statetype, componentcount);
  } 
 return desthmm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x37fe0
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x38e1a
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
leaq 0xac112(%rip), %rdx     # 0xe4ea5
movl $0x6, %ecx
callq 0x52f40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
leaq 0xac0e0(%rip), %rdx     # 0xe4ea5
movl $0x7, %ecx
callq 0x52f40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x38e30
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x38d5d
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: clone_hmm
Hmmptr clone_hmm(Hmmptr srchmm)
{
 /*!Last Changed 15.03.2007*/
 int i;
 Hmmptr desthmm = empty_hmm(srchmm->statecount, srchmm->statetype, srchmm->hmmtype);
 for (i = 0; i < srchmm->statecount; i++)
  {
    desthmm->states[i].pi = srchmm->states[i].pi;
    desthmm->states[i].a_dot_j = clone_array(srchmm->states[i].a_dot_j, srchmm->statecount);
    desthmm->states[i].a_i_dot = clone_array(srchmm->states[i].a_i_dot, srchmm->statecount);
    desthmm->states[i].b = clone_state_model(srchmm->states[i].b, srchmm->statetype);
  } 
 return desthmm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x37fe0
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x3929c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x4f9d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x4f9d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x392b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x391a1
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: init_hmm
void init_hmm(Hmmptr srchmm)
{
 /*!Last Changed 15.03.2007*/
 int i;
 for (i = 0; i < srchmm->statecount; i++)
  {
    srchmm->states[i].pi = 0;
    init_array(srchmm->states[i].a_dot_j, srchmm->statecount);
    init_array(srchmm->states[i].a_i_dot, srchmm->statecount);
    init_state_model(srchmm->states[i].b, srchmm->statetype);
  } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x397c0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x50650
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x50650
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x397d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x39723
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: copy_hmm
void copy_hmm(Hmmptr desthmm, Hmmptr srchmm)
{
 /*!Last Changed 15.03.2007*/
 int i;
 desthmm->hmmtype = srchmm->hmmtype;
 desthmm->statetype = srchmm->statetype;
 for (i = 0; i < srchmm->statecount; i++)
  {
    desthmm->states[i].pi = srchmm->states[i].pi;
    memcpy(desthmm->states[i].a_dot_j, srchmm->states[i].a_dot_j, srchmm->statecount * sizeof(double));
    memcpy(desthmm->states[i].a_i_dot, srchmm->states[i].a_i_dot, srchmm->statecount * sizeof(double));
    copy_state_model(desthmm->states[i].b, srchmm->states[i].b, srchmm->statetype);
  } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x39aff
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rdx
shlq $0x3, %rdx
callq 0x42b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rdx
shlq $0x3, %rdx
callq 0x42b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x39b10
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x39a03
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)