LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: sum_hmm
void sum_hmm(Hmmptr desthmm, Hmmptr srchmm)
{
 /*!Last Changed 15.03.2007*/
 int i;
 for (i = 0; i < srchmm->statecount; i++)
  {
    desthmm->states[i].pi += srchmm->states[i].pi;
    add_arrays(desthmm->states[i].a_dot_j, srchmm->states[i].a_dot_j, srchmm->statecount);
    add_arrays(desthmm->states[i].a_i_dot, srchmm->states[i].a_i_dot, srchmm->statecount);
    sum_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)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x39eee
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
addsd 0x10(%rax), %xmm0
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
movl 0x8(%rax), %edx
callq 0x4f970
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
movl 0x8(%rax), %edx
callq 0x4f970
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 0x39f00
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x39df7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: add_probability_conserving
double* add_probability_conserving(double* prob, int count, int added)
{
 /*!Last Changed 05.04.2007*/
 double* result;
 int i;
 result = alloc(prob, (count + added) * sizeof(double), count + added);
 for (i = 0; i < count; i++)
   result[i] *= (count + 0.0) / (count + added);
 for (i = count; i < count + added; i++)
   result[i] = 1.0 / (count + added);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movslq %eax, %rsi
shlq $0x3, %rsi
movl -0xc(%rbp), %edx
addl -0x10(%rbp), %edx
callq 0x52d10
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3a748
cvtsi2sdl -0xc(%rbp), %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3a709
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jge 0x3a789
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
cvtsi2sd %eax, %xmm1
movsd 0xa78ab(%rip), %xmm0    # 0xe2018
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3a74e
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: random_gaussian
void random_gaussian(Gaussianptr g, Instanceptr traindata)
{
 /*!Last Changed 07.04.2007*/
 int numrealfeatures = current_dataset->multifeaturecount - 1;
 int size, index, seqlen, i, t;
 matrix m;
 Instanceptr datapoint, tmp;
 size = data_size(traindata);
 index = myrand() % size;
 datapoint = data_x(traindata, index);
 seqlen = frame_count(datapoint);
 m = matrix_alloc(seqlen, numrealfeatures);
 tmp = datapoint;
 t = 0;
 while (tmp)
  {
   for (i = 0; i < numrealfeatures; i++)
     m.values[t][i] = real_feature(tmp, i);
   if (t == 0)
     tmp = tmp->sublist;
   else
     tmp = tmp->next;
   t++;
  }
 g->mean = matrix_average_columns(m);
 g->covariance = identity(numrealfeatures);
 matrix_free(m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xcaea9(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x449f0
movl %eax, -0x18(%rbp)
movb $0x0, %al
callq 0x54550
cltd
idivl -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x46c40
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x42ac0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x57fc0
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x28(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x3aa7b
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3aa50
movq -0x48(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x42c40
movq -0x30(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3aa1c
cmpl $0x0, -0x28(%rbp)
jne 0x3aa64
movq -0x48(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x3aa70
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3aa0e
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x5b3e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x14(%rbp), %edi
callq 0x59f70
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x59ea0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: get_component_count
int get_component_count(State s, HMM_STATE_TYPE statetype)
{
 /*!Last Changed 06.04.2007*/
 if (statetype == STATE_GAUSSIAN_MIXTURE)
   return ((Gaussianmixtureptr) s.b)->componentcount;
 else 
   if (statetype == STATE_DIRICHLET_MIXTURE)
     return ((Dirichletmixtureptr) s.b)->componentcount;
   else
     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl %edi, -0x8(%rbp)
cmpl $0x2, -0x8(%rbp)
jne 0x3b1d5
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3b1f2
cmpl $0x4, -0x8(%rbp)
jne 0x3b1eb
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3b1f2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: multinomial_multivariate
double multinomial_multivariate(Instanceptr inst, Multinomialptr m)
{
 /*!Last Changed 26.02.2007*/
 double prod = 1.0;
 int i, j = 0;
 for (i = 0; i < current_dataset->featurecount; i++)
   if (current_dataset->features[i].type == STRING)
    {
     prod *= m->prob[j][inst->values[i].stringindex];
     j++; 
    } 
 return prod;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd 0xa6794(%rip), %xmm0    # 0xe2018
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0xc9f9f(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0x3b912
leaq 0xc9f8d(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x1c(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x3b905
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movslq (%rcx,%rdx,8), %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3b907
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3b897
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: gaussian_mixture_multivariate
double gaussian_mixture_multivariate(Instanceptr inst, Gaussianmixtureptr gm)
{
 /*!Last Changed 26.02.2007*/
 double sum = 0.0;
 int i;
 for (i = 0; i < gm->componentcount; i++)
   sum += gm->weights[i] * gaussian_multivariate(inst, gm->components[i].mean, gm->components[i].covariance);
 return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x3be8e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
callq 0xc24d0
movaps %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3be0f
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: dirichlet_mixture_multivariate
double dirichlet_mixture_multivariate(Instanceptr inst, Dirichletmixtureptr dm)
{
 /*!Last Changed 28.02.2007*/
 double sum = 0.0;
 int i;
 for (i = 0; i < dm->componentcount; i++)
   sum += dm->weights[i] * dirichlet(inst, dm->components[i].alpha);
 return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x3bfae
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2dd30
movaps %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3bf4f
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: calc_obslikMix
double calc_obslikMix(Hmmptr hmm, Instanceptr inst, int stateindex, int componentindex)
{
 /*!Last Changed 26.03.2007*/
 double obslik;
 Gaussianmixtureptr gm;
 Dirichletmixtureptr dm;
 switch (hmm->statetype)
  {
   case  STATE_GAUSSIAN_MIXTURE:gm = (Gaussianmixtureptr) (hmm->states[stateindex].b);
                                obslik = get_gaussian_mixture_multivariate_component(inst, gm, componentindex);
                                break;
   case STATE_DIRICHLET_MIXTURE:dm = (Dirichletmixtureptr) (hmm->states[stateindex].b);
                                obslik = get_dirichlet_mixture_multivariate_component(inst, dm, componentindex);
                                break;
   default                     :obslik = 1.0;
                                break;
  }
 return obslik;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x2, %eax
je 0x3c1c1
jmp 0x3c1b7
movl -0x34(%rbp), %eax
subl $0x4, %eax
je 0x3c1f2
jmp 0x3c223
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x3bea0
movsd %xmm0, -0x20(%rbp)
jmp 0x3c230
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x3bfc0
movsd %xmm0, -0x20(%rbp)
jmp 0x3c230
movsd 0xa5ded(%rip), %xmm0    # 0xe2018
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: calc_gamma
void calc_gamma(Hmmptr hmm, int seqlen, double **alpha, double **beta, double **gamma)
{
 /*!Last Changed 26.03.2007*/
 int i, j, t;
 double denominator;
 for (t = 0; t < seqlen; t++) 
  {
   denominator = 0.0;
   for (j = 0; j < hmm->statecount; j++) 
    {
     gamma[t][j] = alpha[t][j] * beta[t][j];
     denominator += gamma[t][j];
    }
   for (i = 0; i < hmm->statecount; i++) 
     gamma[t][i] = gamma[t][i] / denominator;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3d78b
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x3d72e
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3d6b9
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x3d77b
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd -0x40(%rbp), %xmm0
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3d735
jmp 0x3d77d
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3d69e
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: calc_gammaMix
void calc_gammaMix(Hmmptr hmm, Instanceptr traindata, int seqlen, double **gamma, double ***gammaMix)
{
 /*!Last Changed 26.03.2007*/
 int j, t, m;
 int componentcount;
 double obslik, obslikMix;
 Instanceptr inst = traindata;
 for (t = 0; t < seqlen; t++) 
  {
   for (j = 0; j < hmm->statecount; j++) 
    {
     obslik = calc_obslik(hmm, inst, j);
     componentcount = get_component_count(hmm->states[j], hmm->statetype);
     for (m = 0; m < componentcount; m++)
      {        
       obslikMix = calc_obslikMix(hmm, inst, j, m);
       gammaMix[t][j][m] = gamma[t][j] * obslikMix / obslik;
      }
    }
   if (t == 0)
     inst = inst->sublist;
   else
     inst = inst->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3dac3
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x3da93
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x3c030
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x3b1b0
movl %eax, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x3da83
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x2c(%rbp), %edx
movl -0x34(%rbp), %ecx
callq 0x3c190
movsd %xmm0, -0x48(%rbp)
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd -0x48(%rbp), %xmm0
divsd -0x40(%rbp), %xmm0
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3da1c
jmp 0x3da85
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3d9ad
cmpl $0x0, -0x30(%rbp)
jne 0x3daa7
movq -0x50(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x3dab3
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x3dab5
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3d99a
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: printcontemission
void printcontemission(FILE *controlfile, Gaussianptr g)
{
 int ft, ft2;
 int numrealfeatures = current_dataset->multifeaturecount - 1;
 fprintf(controlfile, "\n mean\n");
 for (ft = 0; ft < numrealfeatures; ft++)
  {
	  fprintf(controlfile, "%.14f ", g->mean[ft]);
  }
 fprintf(controlfile,"\n\ncovariance\n");
 for (ft = 0; ft < numrealfeatures; ft++)
  {
   for (ft2 = 0; ft2 < numrealfeatures; ft2++)
	    fprintf(controlfile, "%.14f ", g->covariance.values[ft][ft2]);
   fprintf(controlfile,"\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xc7d59(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa77ce(%rip), %rsi     # 0xe52cf
movb $0x0, %al
callq 0x4280
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3db44
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0xa780c(%rip), %rsi     # 0xe533e
movb $0x1, %al
callq 0x4280
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3db0f
movq -0x8(%rbp), %rdi
leaq 0xa76a6(%rip), %rsi     # 0xe51f5
movb $0x0, %al
callq 0x4280
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3dbc7
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3dbaa
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0xa77a6(%rip), %rsi     # 0xe533e
movb $0x1, %al
callq 0x4280
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3db6c
movq -0x8(%rbp), %rdi
leaq 0xa8186(%rip), %rsi     # 0xe5d3b
movb $0x0, %al
callq 0x4280
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3db5d
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: printcontobservation
void printcontobservation(FILE *controlfile, Instanceptr inst)
{
 int i;
 int numrealfeatures = current_dataset->multifeaturecount - 1;
 Instanceptr inst1 = inst;
 fprintf(controlfile, "observation\n ");
 for (i = 0; i < numrealfeatures; i++)
  {
	  fprintf(controlfile, "inst :%f feature:%d \n ", real_feature(inst1, i), i);
  }
 fprintf(controlfile, "\n\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xc75d9(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa6fd9(%rip), %rsi     # 0xe5262
movb $0x0, %al
callq 0x4280
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x3e2d3
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x42c40
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0xa6faf(%rip), %rsi     # 0xe5270
movb $0x1, %al
callq 0x4280
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3e297
movq -0x8(%rbp), %rdi
leaq 0xa5e83(%rip), %rsi     # 0xe4161
movb $0x0, %al
callq 0x4280
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: printcontinstance
void printcontinstance(FILE *controlfile, Instanceptr inst)
{
 int i, instindex;
 Instanceptr inst1 = inst;
 int numrealfeatures = current_dataset->multifeaturecount - 1;
 fprintf(controlfile, "instance\n");
 instindex = 0;
 for (i = 0; i < numrealfeatures; i++)
  {
 	 fprintf(controlfile, "instance %d\n", instindex);
	  fprintf(controlfile, "inst :%f feature:%d \n ", real_feature(inst1, i), i);
  }
 instindex++;
 inst1 = inst1->sublist;
 while (inst1)
  {
 	 for (i = 0; i < numrealfeatures; i++)
 		 {
 			 fprintf(controlfile, "instance %d\n", instindex);
 			 fprintf(controlfile, "inst :%f feature:%d \n", real_feature(inst1, i), i);
 		 }
 		instindex++;
 		inst1 = inst1->next;
  }
 fprintf(controlfile, "\n\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xc7531(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa6f5e(%rip), %rsi     # 0xe5287
movb $0x0, %al
callq 0x4280
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x3e38f
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0xa6f3d(%rip), %rsi     # 0xe5291
movb $0x0, %al
callq 0x4280
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x42c40
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0xa6ef3(%rip), %rsi     # 0xe5270
movb $0x1, %al
callq 0x4280
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3e33e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3e41a
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x3e403
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0xa6ec9(%rip), %rsi     # 0xe5291
movb $0x0, %al
callq 0x4280
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x42c40
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0xa6ead(%rip), %rsi     # 0xe529e
movb $0x1, %al
callq 0x4280
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3e3b2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3e3a4
movq -0x8(%rbp), %rdi
leaq 0xa5d3c(%rip), %rsi     # 0xe4161
movb $0x0, %al
callq 0x4280
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: printgamma
void printgamma(FILE *controlfile, double **gamma, Hmmptr hmm, int seqlen)
{
 int i, t;
 fprintf(controlfile, "\ngamma:\n");
 for (t = 0; t < seqlen; t++)
  {
 	 fprintf(controlfile, "%d ", t);
 	 for (i = 0; i < hmm->statecount; i++)
 		  fprintf(controlfile, "%.14f ", gamma[t][i]);
 	 fprintf(controlfile, "\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa6e52(%rip), %rsi     # 0xe52b4
movb $0x0, %al
callq 0x4280
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3e4ef
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %edx
leaq 0xae00f(%rip), %rsi     # 0xec495
movb $0x0, %al
callq 0x4280
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x3e4d2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0xa6e7e(%rip), %rsi     # 0xe533e
movb $0x1, %al
callq 0x4280
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3e494
movq -0x8(%rbp), %rdi
leaq 0xa785e(%rip), %rsi     # 0xe5d3b
movb $0x0, %al
callq 0x4280
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3e470
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: best_hmm_for_single
Hmmptr best_hmm_for_single(Instanceptr traindata, Instanceptr cvdata, Hmm_parameterptr p)
{
 /*!Last Changed 14.04.2007*/
 double ll, bestll;
 Hmmptr hmm, besthmm;
 hmm = random_hmm(2, p->statetype, 1, p->hmmtype, traindata); 
 baumwelch(hmm, traindata, p->iteration);
 ll = bestll = loglikelihood_of_hmm(hmm, cvdata);
 while (ll >= bestll)
  {
   bestll = ll;
   besthmm = clone_hmm(hmm);
   free_hmm(hmm);
   hmm = apply_operator(besthmm, 0, p, traindata);
   ll = loglikelihood_of_hmm(hmm, cvdata);  
  }
 free_hmm(hmm);
 return besthmm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %r8
movl $0x2, %edi
movl $0x1, %edx
callq 0x38060
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x3dbd0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3e7e0
movsd %xmm0, -0x28(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jb 0x3e7ca
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x39170
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x386d0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rcx
xorl %esi, %esi
callq 0x3e8d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3e7e0
movsd %xmm0, -0x20(%rbp)
jmp 0x3e773
movq -0x30(%rbp), %rdi
callq 0x386d0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: loglikelihood_of_hmm
double loglikelihood_of_hmm(Hmmptr hmm, Instanceptr data)
{
 /*!Last Changed 04.04.2007*/
 double **alpha, *scale, ll, total_loglikelihood = 0.0;
 int seqlen, count = 0;
 Instanceptr inst;
 inst = data;
 while (inst)
  {
   seqlen = frame_count(inst);
   alpha = (double **) safemalloc_2d(sizeof(double*), sizeof(double), seqlen, hmm->statecount, "loglikelihood_of_hmm", 5);
   scale = safecalloc(seqlen, sizeof(double), "loglikelihood_of_hmm", 6);
   calc_fwd(hmm, inst, alpha, &ll, scale);   
   free_2d((void **) alpha, seqlen);
   safe_free(scale);
   total_loglikelihood += ll;
   inst = inst->next;
   count++;
  }
 return total_loglikelihood / count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x3e8bb
movq -0x40(%rbp), %rdi
callq 0x42ac0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movl $0x8, %esi
leaq 0xa6b5c(%rip), %r8      # 0xe5390
movl $0x5, %r9d
movq %rsi, %rdi
callq 0x53120
movq %rax, -0x18(%rbp)
movslq -0x34(%rbp), %rdi
movl $0x8, %esi
leaq 0xa6b3a(%rip), %rdx     # 0xe5390
movl $0x6, %ecx
callq 0x52f40
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %r8
leaq -0x28(%rbp), %rcx
callq 0x3d1c0
movq -0x18(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x52e20
movq -0x20(%rbp), %rdi
callq 0x52e80
movsd -0x28(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x3e807
movsd -0x30(%rbp), %xmm0
cvtsi2sdl -0x38(%rbp), %xmm1
divsd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: apply_operator
Hmmptr apply_operator(Hmmptr hmm, int operatortype, Hmm_parameterptr p, Instanceptr traindata)
{
 /*!Last Changed 14.04.2007*/
 Hmmptr result;
 int statecount, componentcount;
 if (p->weightfreezing)
  {
   result = clone_hmm(hmm);
   if (in_list(operatortype, 2, ADD_ONE_STATE, ADD_ONE_BOTH))
     add_state(result, 1, traindata);
   if (in_list(operatortype, 2, ADD_ONE_COMPONENT, ADD_ONE_BOTH))
     add_component(result, 1, traindata);
  }
 else
  {
   statecount = hmm->statecount;
   componentcount = get_component_count(hmm->states[0], hmm->statetype);
   if (in_list(operatortype, 2, ADD_ONE_STATE, ADD_ONE_BOTH))
     statecount++;
   if (in_list(operatortype, 2, ADD_ONE_COMPONENT, ADD_ONE_BOTH))
     componentcount++;
   result = random_hmm(statecount, p->statetype, componentcount, p->hmmtype, traindata);
  }
 baumwelch(result, traindata, p->iteration);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x3e95a
movq -0x8(%rbp), %rdi
callq 0x39170
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
movl $0x2, %ecx
xorl %edx, %edx
movl %ecx, %esi
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0x3e928
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x1, %esi
callq 0x3ab30
movl -0xc(%rbp), %edi
movl $0x2, %ecx
movl $0x1, %edx
movl %ecx, %esi
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0x3e955
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x1, %esi
callq 0x3a7a0
jmp 0x3ea01
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x3b1b0
movl %eax, -0x30(%rbp)
movl -0xc(%rbp), %edi
movl $0x2, %ecx
xorl %edx, %edx
movl %ecx, %esi
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0x3e9bd
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %edi
movl $0x2, %ecx
movl $0x1, %edx
movl %ecx, %esi
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0x3e9e1
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %edi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movl -0x30(%rbp), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %r8
callq 0x38060
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x3dbd0
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: best_hmm_for_mixture
Hmmptr best_hmm_for_mixture(Instanceptr traindata, Instanceptr cvdata, Hmm_parameterptr p)
{
 /*!Last Changed 14.04.2007*/
 HMM_OPERATOR_TYPE bestone = ADD_ONE_STATE;
 int i;
 double ll[HMM_OPERATORS], bestll;
 Hmmptr hmm[HMM_OPERATORS], besthmm;
 hmm[ADD_ONE_STATE] = random_hmm(2, p->statetype, 1, p->hmmtype, traindata);
 hmm[ADD_ONE_COMPONENT] = clone_hmm(hmm[ADD_ONE_STATE]);
 hmm[ADD_ONE_BOTH] = clone_hmm(hmm[ADD_ONE_STATE]);
 baumwelch(hmm[ADD_ONE_STATE], traindata, p->iteration);
 ll[ADD_ONE_STATE] = bestll = loglikelihood_of_hmm(hmm[ADD_ONE_STATE], cvdata);
 while (bestone != NO_CHANGE)
  {
   besthmm = clone_hmm(hmm[bestone]);
   for (i = 0; i < HMM_OPERATORS; i++)
    {
     free_hmm(hmm[i]);
     hmm[i] = apply_operator(besthmm, i, p, traindata);
    }
   bestone = NO_CHANGE;
   for (i = 0; i < HMM_OPERATORS; i++)
    {     
     ll[i] = loglikelihood_of_hmm(hmm[i], cvdata);  
     if (ll[i] > bestll)
      {
       bestone = i;
       bestll = ll[i];
      }
    }
  }
 for (i = 0; i < HMM_OPERATORS; i++)
   free_hmm(hmm[i]);
 return besthmm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %r8
movl $0x2, %edi
movl $0x1, %edx
callq 0x38060
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x39170
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rdi
callq 0x39170
movq %rax, -0x50(%rbp)
movq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x3dbd0
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3e7e0
movsd %xmm0, -0x48(%rbp)
movsd %xmm0, -0x40(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x3eb6e
movslq -0x1c(%rbp), %rax
movq -0x60(%rbp,%rax,8), %rdi
callq 0x39170
movq %rax, -0x68(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jge 0x3eb06
movslq -0x20(%rbp), %rax
movq -0x60(%rbp,%rax,8), %rdi
callq 0x386d0
movq -0x68(%rbp), %rdi
movl -0x20(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rcx
callq 0x3e8d0
movq %rax, %rcx
movslq -0x20(%rbp), %rax
movq %rcx, -0x60(%rbp,%rax,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3eac7
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jge 0x3eb69
movslq -0x20(%rbp), %rax
movq -0x60(%rbp,%rax,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x3e7e0
movslq -0x20(%rbp), %rax
movsd %xmm0, -0x40(%rbp,%rax,8)
movslq -0x20(%rbp), %rax
movsd -0x40(%rbp,%rax,8), %xmm0
ucomisd -0x48(%rbp), %xmm0
jbe 0x3eb5c
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movslq -0x20(%rbp), %rax
movsd -0x40(%rbp,%rax,8), %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x3eb5e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3eb14
jmp 0x3eaa4
movl $0x0, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jge 0x3eb94
movslq -0x20(%rbp), %rax
movq -0x60(%rbp,%rax,8), %rdi
callq 0x386d0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3eb75
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: hmm_error_rate
double hmm_error_rate(Hmmptr* model, Instanceptr data)
{
 /*!Last Changed 14.04.2007*/
 int wrong = 0, count = 0, real, predicted;
 Instanceptr tmp = data;
 while (tmp)
  {
   real = give_classno(tmp);
   predicted = test_hmm_instance(tmp, model);
   if (real != predicted)
     wrong++;
   tmp = tmp->next;
   count++;
  }
 return wrong / (count + 0.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3ee81
movq -0x28(%rbp), %rdi
callq 0x43530
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3eea0
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0x3ee6a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3ee36
cvtsi2sdl -0x14(%rbp), %xmm0
cvtsi2sdl -0x18(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/hmm.c
// Function: test_hmm_instance
int test_hmm_instance(Instanceptr inst, Hmmptr* hmmarray)
{
 /*!Last Changed 14.04.2007*/
 int i, maxclass = -1, seqlen;
 double maxll, ll, **alpha, *scale;
 seqlen = frame_count(inst);
 for (i = 0; i < current_dataset->classno; i++)
  {
   alpha = (double **) safemalloc_2d(sizeof(double*), sizeof(double), seqlen, hmmarray[i]->statecount, "test_hmm_instance", 6);
   scale = safecalloc(seqlen, sizeof(double), "test_hmm_instance", 7);
   calc_fwd(hmmarray[i], inst, alpha, &ll, scale);
   if (maxclass == -1 || ll > maxll)
    {
     maxll = ll;
     maxclass = i;
    }
   free_2d((void **) alpha, seqlen);
   safe_free(scale);
  }
 return maxclass;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0x42ac0
movl %eax, -0x1c(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0xc696c(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x3ef94
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x8(%rax), %ecx
movl $0x8, %esi
leaq 0xa6480(%rip), %r8      # 0xe537e
movl $0x6, %r9d
movq %rsi, %rdi
callq 0x53120
movq %rax, -0x38(%rbp)
movslq -0x1c(%rbp), %rdi
movl $0x8, %esi
leaq 0xa645e(%rip), %rdx     # 0xe537e
movl $0x7, %ecx
callq 0x52f40
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %r8
leaq -0x30(%rbp), %rcx
callq 0x3d1c0
cmpl $-0x1, -0x18(%rbp)
je 0x3ef61
movsd -0x30(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x3ef71
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x52e20
movq -0x40(%rbp), %rdi
callq 0x52e80
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3eeca
movl -0x18(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/image.c
// Function: add_legend
void add_legend(char ch, char* st)
{
 /*!Last Changed 19.09.2006 legendcount increased*/
 /*!Last Changed 23.01.2005*/
 int count = img.imagelegend.legendcount; 
 img.imagelegend.colors = alloc(img.imagelegend.colors, (count + 1) * sizeof(int), count + 1);
 img.imagelegend.colors[count] = 0;
 img.imagelegend.types = alloc(img.imagelegend.types, (count + 1) * sizeof(char), count + 1);
 img.imagelegend.types[count] = ch;
 img.imagelegend.names = alloc(img.imagelegend.names, (count + 1) * sizeof(char *), count + 1);
 img.imagelegend.names[count] = strcopy(img.imagelegend.names[count], st);
 img.imagelegend.legendcount++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x3a30cf(%rip), %rax    # 0x3e2088
movl 0xec(%rax), %eax
movl %eax, -0x14(%rbp)
leaq 0x3a30bf(%rip), %rax    # 0x3e2088
movq 0xf0(%rax), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x52d10
movq %rax, %rcx
leaq 0x3a3096(%rip), %rax    # 0x3e2088
movq %rcx, 0xf0(%rax)
leaq 0x3a3088(%rip), %rax    # 0x3e2088
movq 0xf0(%rax), %rax
movslq -0x14(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
leaq 0x3a306f(%rip), %rax    # 0x3e2088
movq 0xf8(%rax), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x0, %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x52d10
movq %rax, %rcx
leaq 0x3a3046(%rip), %rax    # 0x3e2088
movq %rcx, 0xf8(%rax)
movb -0x1(%rbp), %dl
leaq 0x3a3035(%rip), %rax    # 0x3e2088
movq 0xf8(%rax), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
leaq 0x3a3020(%rip), %rax    # 0x3e2088
movq 0x100(%rax), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x3, %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x52d10
movq %rax, %rcx
leaq 0x3a2ff7(%rip), %rax    # 0x3e2088
movq %rcx, 0x100(%rax)
leaq 0x3a2fe9(%rip), %rax    # 0x3e2088
movq 0x100(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x54ba0
movq %rax, %rdx
leaq 0x3a2fc7(%rip), %rax    # 0x3e2088
movq 0x100(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
leaq 0x3a2fb1(%rip), %rax    # 0x3e2088
movl 0xec(%rax), %ecx
addl $0x1, %ecx
leaq 0x3a2fa1(%rip), %rax    # 0x3e2088
movl %ecx, 0xec(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/image.c
// Function: check_x_range
void check_x_range(Point p)
{
 /*!Last Changed 23.01.2005*/
 if (p.x < img.xaxis.lim.min)
   img.xaxis.lim.min = p.x;
 else
   if (p.x > img.xaxis.lim.max)
     img.xaxis.lim.max = p.x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd -0x10(%rbp), %xmm1
leaq 0x3a0b0e(%rip), %rax    # 0x3e2088
movsd 0x10(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x41598
movsd -0x10(%rbp), %xmm0
leaq 0x3a0af7(%rip), %rax    # 0x3e2088
movsd %xmm0, 0x10(%rax)
jmp 0x415be
movsd -0x10(%rbp), %xmm0
leaq 0x3a0ae4(%rip), %rax    # 0x3e2088
ucomisd 0x18(%rax), %xmm0
jbe 0x415bc
movsd -0x10(%rbp), %xmm0
leaq 0x3a0ad1(%rip), %rax    # 0x3e2088
movsd %xmm0, 0x18(%rax)
jmp 0x415be
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/image.c
// Function: check_y_range
void check_y_range(Point p)
{
 /*!Last Changed 23.01.2005*/
 if (p.y < img.yaxis.lim.min)
   img.yaxis.lim.min = p.y;
 else
   if (p.y > img.yaxis.lim.max)
     img.yaxis.lim.max = p.y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd -0x8(%rbp), %xmm1
leaq 0x3a0aae(%rip), %rax    # 0x3e2088
movsd 0x80(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x415fe
movsd -0x8(%rbp), %xmm0
leaq 0x3a0a94(%rip), %rax    # 0x3e2088
movsd %xmm0, 0x80(%rax)
jmp 0x4162a
movsd -0x8(%rbp), %xmm0
leaq 0x3a0a7e(%rip), %rax    # 0x3e2088
ucomisd 0x88(%rax), %xmm0
jbe 0x41628
movsd -0x8(%rbp), %xmm0
leaq 0x3a0a68(%rip), %rax    # 0x3e2088
movsd %xmm0, 0x88(%rax)
jmp 0x4162a
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/image.c
// Function: object_count
int object_count(int type, int groupindex)
{
 /*!Last Changed 21.09.2006 added groupindex*/
 /*!Last Changed 11.07.2005*/
 int i, count = 0;
 for (i = 0; i < img.objectcount; i++)
   if (img.objects[i].type == type && img.objects[i].groupindex == groupindex)
     count++;
 return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x3a0086(%rip), %rcx    # 0x3e2088
cmpl 0x124(%rcx), %eax
jge 0x42061
leaq 0x3a0077(%rip), %rax    # 0x3e2088
movq 0x128(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x42054
leaq 0x3a0057(%rip), %rax    # 0x3e2088
movq 0x128(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x42054
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x42056
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x41ff8
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/image.c
// Function: position_in_multi_plot
int position_in_multi_plot(int groupindex, int index, int groupcount, int elementcount, double* barwidth)
{
 /*!Last Changed 28.03.2007 fixed error by replacing groupcount with elementcount*/
 /*!Last Changed 21.09.2006*/
 double singlewidth, emptywidth;
 singlewidth = epsaxis / (groupcount + 0.0);
 emptywidth = singlewidth * ((sqrt(5) - 1) / ((elementcount + 2) * sqrt(5) + (elementcount - 2))); 
 *barwidth = singlewidth * ((sqrt(5) + 1) / ((elementcount + 2) * sqrt(5) + (elementcount - 2)));
 return MARGIN + (int) (singlewidth * groupindex + emptywidth + index * (*barwidth));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm1
xorps %xmm0, %xmm0
addsd %xmm0, %xmm1
movsd 0xa2884(%rip), %xmm0    # 0xe4980
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0xa2789(%rip), %xmm0    # 0xe48a0
callq 0x42a0
movsd 0x9fef4(%rip), %xmm1    # 0xe2018
subsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movl -0x10(%rbp), %eax
addl $0x2, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd 0xa275c(%rip), %xmm0    # 0xe48a0
callq 0x42a0
movsd -0x58(%rbp), %xmm2
movsd -0x50(%rbp), %xmm1
movaps %xmm0, %xmm4
movsd -0x48(%rbp), %xmm0
movl -0x10(%rbp), %eax
subl $0x2, %eax
cvtsi2sd %eax, %xmm3
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
divsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0xa2714(%rip), %xmm0    # 0xe48a0
callq 0x42a0
movsd 0x9fe7f(%rip), %xmm1    # 0xe2018
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x10(%rbp), %eax
addl $0x2, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0xa26e7(%rip), %xmm0    # 0xe48a0
callq 0x42a0
movsd -0x40(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
movaps %xmm0, %xmm4
movsd -0x30(%rbp), %xmm0
movl -0x10(%rbp), %eax
subl $0x2, %eax
cvtsi2sd %eax, %xmm3
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
divsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm1
cvtsi2sdl -0x4(%rbp), %xmm2
movsd -0x28(%rbp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvtsi2sdl -0x8(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd (%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl $0x50, %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/image.c
// Function: export_image
void export_image()
{
 switch (get_parameter_l("imagetype"))
  {
        case IMAGE_EPS:export_image_as_eps("image.eps");
                       break;
   case IMAGE_PSTRICKS:export_image_as_pstricks("image.txt");
                       break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xa325f(%rip), %rdi     # 0xe54ee
callq 0x792b0
movl %eax, %ecx
movl %ecx, -0x4(%rbp)
testl %eax, %eax
je 0x422a9
jmp 0x4229f
movl -0x4(%rbp), %eax
subl $0x1, %eax
je 0x422b7
jmp 0x422c3
leaq 0xa27a3(%rip), %rdi     # 0xe4a53
callq 0x30330
jmp 0x422c3
leaq 0xa323a(%rip), %rdi     # 0xe54f8
callq 0x9b270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/instance.c
// Function: frame_count
int frame_count(Instanceptr inst)
{
	/*!Last Changed 07.01.2007*/
	int count = 1;
	Instanceptr tmp = inst->sublist;
	while (tmp)
	 {
		 tmp = tmp->next;
			count++;
	 }
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x42af9
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x42adb
movl -0xc(%rbp), %eax
popq %rbp
retq
nop