LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa7013(%rip), %rax     # 0xd2870
movq (%rax), %rax
movl 0x1c0(%rax), %r12d
leal -0x1(%r12), %r15d
leaq 0x79e1c(%rip), %rdi     # 0xa568f
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
movq %r12, 0x10(%rsp)
cmpl $0x2, %r12d
jl 0x2b8cf
leaq 0x79e02(%rip), %r13     # 0xa5699
leaq 0x79dda(%rip), %r12     # 0xa5678
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x42e0
movq %r14, %rdi
movl %ebp, %esi
callq 0x2e4b6
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movb $0x1, %al
callq 0x42e0
incl %ebp
cmpl %ebp, %r15d
jne 0x2b8a0
movl %r15d, 0xc(%rsp)
movq 0x28(%r14), %r14
testq %r14, %r14
je 0x2b939
movl $0x1, %ebp
leaq 0x79db0(%rip), %r12     # 0xa5699
movl 0xc(%rsp), %r15d
cmpl $0x2, 0x10(%rsp)
jl 0x2b92e
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x42e0
movq %r14, %rdi
movl %r13d, %esi
callq 0x2e4b6
movq %rbx, %rdi
leaq 0x79d8a(%rip), %rsi     # 0xa56a6
movl %r13d, %edx
movb $0x1, %al
callq 0x42e0
incl %r13d
cmpl %r13d, %r15d
jne 0x2b8f8
incl %ebp
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x2b8ee
leaq 0x789e4(%rip), %rdi     # 0xa4324
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42c0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x79d3f(%rip), %rdi     # 0xa56bc
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x42c0
testl %ebp, %ebp
jle 0x2b9f7
movl %ebp, %eax
movq %rax, (%rsp)
leaq 0x79da6(%rip), %r13     # 0xa5746
xorl %ebp, %ebp
movq %r15, %rdi
leaq 0x81301(%rip), %rsi     # 0xaccad
movl %ebp, %edx
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, 0x8(%rbx)
jle 0x2b9e1
xorl %r12d, %r12d
movq (%r14,%rbp,8), %rax
movsd (%rax,%r12,8), %xmm0
movq %r15, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x42e0
incq %r12
movslq 0x8(%rbx), %rax
cmpq %rax, %r12
jl 0x2b9be
movl $0xa, %edi
movq %r15, %rsi
callq 0x4150
incq %rbp
cmpq (%rsp), %rbp
jne 0x2b9a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdx), %ecx
movl 0x4(%rdx), %esi
movl $0x2, %edi
movl $0x1, %edx
movq %r15, %r8
callq 0x27426
movq %rax, %r12
movl 0x8(%rbx), %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2b24a
movq %r12, %rdi
movq %r14, %rsi
callq 0x2bcb0
ucomisd %xmm0, %xmm0
jp 0x2bcae
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0x2803c
movq %rax, %r13
movq %r12, %rdi
callq 0x2787b
movq %r13, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x2bd8c
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x2bcb0
ucomisd 0x8(%rsp), %xmm0
jae 0x2bc56
movq %r12, %rdi
callq 0x2787b
movq %r13, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2bc95
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x2bd83
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x2e3d4
movl %eax, %ebp
movl 0x8(%r14), %ecx
movl $0x8, %edi
movl $0x8, %esi
movl %eax, %edx
leaq 0x79a9d(%rip), %r12     # 0xa5798
movq %r12, %r8
movl $0x5, %r9d
callq 0x393b5
movq %rax, %r13
movslq %ebp, %rbp
movl $0x8, %esi
movq %rbp, %rdi
movq %r12, %rdx
movl $0x6, %ecx
callq 0x39210
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
leaq 0x10(%rsp), %rcx
movq %rax, %r8
callq 0x2aaea
movq %r13, %rdi
movl %ebp, %esi
callq 0x3915f
movq %r12, %rdi
callq 0x39194
movsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movq 0x10(%rbx), %rbx
incl %r15d
testq %rbx, %rbx
jne 0x2bcd4
cvtsi2sd %r15d, %xmm1
divsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsd 0x76f85(%rip), %xmm0    # 0xa2d10
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
cmpl $0x0, 0xc(%rdx)
je 0x2be05
callq 0x2803c
movq %rax, %r15
movl %ebp, %edi
movl $0x2, %esi
xorl %edx, %edx
movl $0x2, %ecx
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
je 0x2bdd3
movq %r15, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x28ffe
movl %ebp, %edi
movl $0x2, %esi
movl $0x1, %edx
movl $0x2, %ecx
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
je 0x2be77
movq %r15, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x28d4f
jmp 0x2be77
movl 0x8(%rdi), %r15d
movl 0xc(%rdi), %eax
cmpl $0x4, %eax
je 0x2be19
xorl %r12d, %r12d
cmpl $0x2, %eax
jne 0x2be24
movq (%rdi), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %r12d
movl %ebp, %edi
movl $0x2, %esi
xorl %edx, %edx
movl $0x2, %ecx
xorl %eax, %eax
callq 0x39a80
cmpl $0x1, %eax
sbbl $-0x1, %r15d
movl %ebp, %edi
movl $0x2, %esi
movl $0x1, %edx
movl $0x2, %ecx
xorl %eax, %eax
callq 0x39a80
cmpl $0x1, %eax
sbbl $-0x1, %r12d
movl (%r14), %ecx
movl 0x4(%r14), %esi
movl %r15d, %edi
movl %r12d, %edx
movq %rbx, %r8
callq 0x27426
movq %rax, %r15
movl 0x8(%r14), %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2b24a
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdx), %ecx
movl 0x4(%rdx), %esi
movl $0x2, %edi
movl $0x1, %edx
movq %r15, %r8
callq 0x27426
movq %rax, %r12
movq %rax, 0x10(%rsp)
movq %rax, %rdi
callq 0x2803c
movq %rax, 0x18(%rsp)
movq %r12, %rdi
callq 0x2803c
movq %rax, 0x20(%rsp)
movl 0x8(%rbx), %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2b24a
movq %r12, %rdi
movq %r14, %rsi
callq 0x2bcb0
xorl %r13d, %r13d
movsd %xmm0, 0x8(%rsp)
movslq %r13d, %rax
movq 0x10(%rsp,%rax,8), %rdi
callq 0x2803c
movq %rax, %r12
xorl %r13d, %r13d
movq 0x10(%rsp,%r13,8), %rdi
callq 0x2787b
movq %r12, %rdi
movl %r13d, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x2bd8c
movq %rax, 0x10(%rsp,%r13,8)
incq %r13
cmpq $0x3, %r13
jne 0x2bf17
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
xorl %ebp, %ebp
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp,%rbp,8), %rdi
movq %r14, %rsi
callq 0x2bcb0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
cmoval %ebp, %r13d
maxsd %xmm1, %xmm0
incq %rbp
cmpq $0x3, %rbp
jne 0x2bf4e
cmpl $-0x1, %r13d
jne 0x2befe
xorl %ebx, %ebx
movq 0x10(%rsp,%rbx,8), %rdi
callq 0x2787b
incq %rbx
cmpq $0x3, %rbx
jne 0x2bf88
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x2c204
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x2eaca
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c20d
xorl %ecx, %ecx
cmpl %eax, %ebp
setne %cl
addl %ecx, %r15d
movq 0x10(%rbx), %rbx
incl %r12d
testq %rbx, %rbx
jne 0x2c1c2
cvtsi2sd %r15d, %xmm0
cvtsi2sd %r12d, %xmm1
divsd %xmm1, %xmm0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movsd 0x76b04(%rip), %xmm0    # 0xa2d10
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
callq 0x2e3d4
movl %eax, %ebp
leaq 0xa663f(%rip), %rax     # 0xd2870
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jle 0x2c309
movslq %ebp, %rax
movq %rax, 0x8(%rsp)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
xorl %r13d, %r13d
movq (%rbx,%r13,8), %rax
movl 0x8(%rax), %ecx
movl $0x8, %edi
movl $0x8, %esi
movl %ebp, %edx
leaq 0x7951d(%rip), %r12     # 0xa5786
movq %r12, %r8
movl $0x6, %r9d
callq 0x393b5
movq %rax, %r14
movl $0x8, %esi
movq 0x8(%rsp), %rdi
movq %r12, %rdx
movl $0x7, %ecx
callq 0x39210
movq %rax, %r12
movq (%rbx,%r13,8), %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
leaq 0x20(%rsp), %rcx
movq %rax, %r8
callq 0x2aaea
cmpl $-0x1, %r15d
sete %al
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm0, %xmm1
seta %cl
orb %al, %cl
testb %cl, %cl
jne 0x2c2d1
movapd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
cmovnel %r13d, %r15d
movq %r14, %rdi
movl %ebp, %esi
callq 0x3915f
movq %r12, %rdi
callq 0x39194
incq %r13
leaq 0xa6579(%rip), %rax     # 0xd2870
movq (%rax), %rax
movslq 0x10(%rax), %rax
cmpq %rax, %r13
jl 0x2c24f
jmp 0x2c30f
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x382d80(%rip), %r15    # 0x3af0b8
movslq 0xec(%r15), %r12
movq 0xf0(%r15), %rdi
leaq 0x1(%r12), %r14
leaq 0x4(,%r12,4), %rsi
movl %r14d, %edx
callq 0x390c8
movq %rax, 0xf0(%r15)
movl $0x0, (%rax,%r12,4)
movq 0xf8(%r15), %rdi
movq %r14, %rsi
movl %r14d, %edx
callq 0x390c8
movq %rax, 0xf8(%r15)
movb %bpl, (%rax,%r12)
movq 0x100(%r15), %rdi
leaq 0x8(,%r12,8), %rsi
movl %r14d, %edx
callq 0x390c8
movq %rax, 0x100(%r15)
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq 0x3a404
movq 0x100(%r15), %rcx
movq %rax, (%rcx,%r12,8)
incl 0xec(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/image.c
// Function: initialize_image
void initialize_image()
{
 /*!Last Changed 23.01.2005*/
 img.height = epsaxis + 2 * MARGIN;
 img.width = epsaxis + 2 * MARGIN;
 img.groupcoloring = ALL_SAME;
 img.xaxis.limitsset = 0;
 img.yaxis.limitsset = 0;
 img.xaxis.label = NULL;
 img.yaxis.label = NULL;
 img.xaxis.available = 1;
 img.yaxis.available = 1;
 img.xaxis.namesavailable = 0;
 img.yaxis.namesavailable = 0;
 img.imagelegend.legendcount = 0;
 img.imagelegend.colors = NULL;
 img.imagelegend.types = NULL;
 img.imagelegend.names = NULL;
 img.objectcount = 0;
 img.xaxis.lim.min = -1;
 img.xaxis.lim.max = -2;
 img.yaxis.lim.min = -1;
 img.yaxis.lim.max = -2;
 initialize_font(&(img.xaxis.axisfnt), 0, TIMES, 10.0);
 initialize_font(&(img.yaxis.axisfnt), 0, TIMES, 10.0);
 initialize_font(&(img.xaxis.labelfnt), 0, TIMES, 10.0);
 initialize_font(&(img.yaxis.labelfnt), 0, TIMES, 10.0);
 initialize_font(&(img.imagelegend.fnt), 0, TIMES, 10.0);
}

// Assembly:
leaq 0x381449(%rip), %rax    # 0x3af0b8
movabsq $0x29400000294, %rcx    # imm = 0x29400000294
movq %rcx, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x120(%rax)
movl %ecx, 0x28(%rax)
movl %ecx, 0x98(%rax)
movq %rcx, 0x40(%rax)
movq %rcx, 0xb0(%rax)
movl $0x1, %edx
movl %edx, 0x8(%rax)
movl %edx, 0x78(%rax)
movl %ecx, 0x38(%rax)
movl %ecx, 0xa8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0xec(%rax)
movups %xmm0, 0xf8(%rax)
movabsq $-0x4010000000000000, %rdx # imm = 0xBFF0000000000000
movq %rdx, 0x10(%rax)
movabsq $-0x4000000000000000, %rsi # imm = 0xC000000000000000
movq %rsi, 0x18(%rax)
movq %rdx, 0x80(%rax)
movq %rsi, 0x88(%rax)
movl %ecx, 0x58(%rax)
movl $0x2, %edx
movl %edx, 0x48(%rax)
movabsq $0x4024000000000000, %rsi # imm = 0x4024000000000000
movq %rsi, 0x50(%rax)
movl %ecx, 0xc8(%rax)
movl %edx, 0xb8(%rax)
movq %rsi, 0xc0(%rax)
movl %ecx, 0x70(%rax)
movl %edx, 0x60(%rax)
movq %rsi, 0x68(%rax)
movl %ecx, 0xe0(%rax)
movl %edx, 0xd0(%rax)
movq %rsi, 0xd8(%rax)
movl %ecx, 0x118(%rax)
movl %edx, 0x108(%rax)
movq %rsi, 0x110(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x38136c(%rip), %rcx    # 0x3af0b8
movslq 0x124(%rcx), %rax
testq %rax, %rax
jle 0x2dd8b
movq 0x128(%rcx), %rcx
shlq $0x5, %rax
leaq (%rax,%rax,2), %rdx
xorl %r8d, %r8d
xorl %eax, %eax
cmpl %edi, (%rcx,%r8)
jne 0x2dd81
xorl %r9d, %r9d
cmpl %esi, 0x20(%rcx,%r8)
sete %r9b
addl %r9d, %eax
addq $0x60, %r8
cmpq %r8, %rdx
jne 0x2dd6c
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cvtsi2sd %edx, %xmm0
movsd 0x76fcf(%rip), %xmm1    # 0xa4d90
divsd %xmm0, %xmm1
leal 0x2(%rcx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
addl $-0x2, %ecx
cvtsi2sd %ecx, %xmm2
mulsd 0x77aa2(%rip), %xmm0    # 0xa5880
addsd %xmm2, %xmm0
movsd 0x77a9e(%rip), %xmm2    # 0xa5888
divsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
movsd 0x77a96(%rip), %xmm3    # 0xa5890
divsd %xmm0, %xmm3
mulsd %xmm1, %xmm3
movsd %xmm3, (%r8)
xorps %xmm0, %xmm0
cvtsi2sd %edi, %xmm0
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
mulsd %xmm3, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
addl $0x50, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instance.c
// Function: instance_to_svmnode
Svm_nodeptr instance_to_svmnode(Instanceptr inst)
{
	/*!Last Changed 02.05.2005*/
	int i, j = 0;
	Svm_nodeptr result;
 double value;
	result = safemalloc(sizeof(Svm_node) * current_dataset->multifeaturecount, "instance_to_svmnode", 3);
	for (i = 0; i < current_dataset->multifeaturecount - 1; i++)
	 {
   value = real_feature(inst, i);
   if (value != 0.0 || current_dataset->storetype == STORE_KERNEL)
    {
  		 result[j].index = i;
		  	result[j].value = value;
     j++;
    }
	 }
	result[j].index = -1;
	result[j].value = -1;
 j++;
 result = alloc(result, sizeof(Svm_node) * j, j);
	return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa4477(%rip), %r14     # 0xd2870
movq (%r14), %rax
movslq 0x1c0(%rax), %rdi
shlq $0x4, %rdi
leaq 0x77626(%rip), %rsi     # 0xa5a34
movl $0x3, %edx
callq 0x390f5
movq (%r14), %rcx
movl 0x1c0(%rcx), %edx
xorl %edi, %edi
cmpl $0x2, %edx
jl 0x2e481
decl %edx
movslq 0x1407128(%rcx), %rsi
movq (%rbx), %r8
xorl %r9d, %r9d
xorpd %xmm0, %xmm0
xorl %edi, %edi
xorl %r10d, %r10d
cmpq %rsi, %r9
setge %r10b
leaq (%r8,%r10,8), %r10
movsd (%r10,%r9,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x2e462
jp 0x2e462
cmpl $0x3, 0x140713c(%rcx)
jne 0x2e479
movslq %edi, %rdi
movq %rdi, %r10
shlq $0x4, %r10
movl %r9d, (%rax,%r10)
movsd %xmm1, 0x8(%rax,%r10)
incl %edi
incq %r9
cmpq %r9, %rdx
jne 0x2e43d
movslq %edi, %rdx
movq %rdx, %rsi
shlq $0x4, %rsi
movl $0xffffffff, (%rax,%rsi) # imm = 0xFFFFFFFF
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, 0x8(%rax,%rsi)
incl %edx
addq $0x10, %rsi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x390c8
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instance.c
// Function: copy_of_instance
Instanceptr copy_of_instance(Instanceptr inst)
{
	/*!Last Changed 19.02.2005*/
	Instanceptr currentinstance;
	int i;
	if (!inst)
		 return NULL;
 currentinstance = (Instanceptr)safemalloc(sizeof(Instance), "copy_of_instance", 5);
 currentinstance->values = (union value*)safemalloc(current_dataset->multifeaturecount * sizeof(union value), "copy_of_instance", 6);
	for (i = 0; i < current_dataset->multifeaturecount; i++)
		 if (i != current_dataset->classdefno || current_dataset->classno == 0)
				 currentinstance->values[i].floatvalue = inst->values[i].floatvalue;
			else	 
				 currentinstance->values[i].stringindex = inst->values[i].stringindex;
 currentinstance->next = NULL;
 currentinstance->sublist = NULL;
 if (current_dataset->storetype == STORE_MULTILABEL)
  {
   currentinstance->class_labels = safemalloc(current_dataset->classno * sizeof(int), "copy_of_instance", 15);
   for (i = 0; i < current_dataset->classno; i++)
     currentinstance->class_labels[i] = inst->class_labels[i];  
  }
 else
   currentinstance->class_labels = NULL;
	return currentinstance;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2e5d6
movq %rdi, %r14
leaq 0x77552(%rip), %r15     # 0xa5a48
movl $0x30, %edi
movq %r15, %rsi
movl $0x5, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0xa435e(%rip), %r12     # 0xd2870
movq (%r12), %rax
movslq 0x1c0(%rax), %rdi
shlq $0x3, %rdi
movq %r15, %rsi
movl $0x6, %edx
callq 0x390f5
movq %rax, (%rbx)
movq (%r12), %rax
cmpl $0x0, 0x1c0(%rax)
jle 0x2e582
xorl %ecx, %ecx
movl 0x1407128(%rax), %edx
cmpq %rdx, %rcx
jne 0x2e55f
cmpl $0x0, 0x10(%rax)
je 0x2e55f
movq (%r14), %rax
movl (%rax,%rcx,8), %eax
movq (%rbx), %rdx
movl %eax, (%rdx,%rcx,8)
jmp 0x2e56f
movq (%r14), %rax
movsd (%rax,%rcx,8), %xmm0
movq (%rbx), %rax
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
movq (%r12), %rax
movslq 0x1c0(%rax), %rdx
cmpq %rdx, %rcx
jl 0x2e540
xorl %ecx, %ecx
movq %rcx, 0x10(%rbx)
movq %rcx, 0x28(%rbx)
cmpl $0x4, 0x140713c(%rax)
jne 0x2e5da
movslq 0x10(%rax), %rdi
shlq $0x2, %rdi
leaq 0x774a4(%rip), %rsi     # 0xa5a48
movl $0xf, %edx
callq 0x390f5
movq %rax, 0x8(%rbx)
movq (%r12), %rcx
cmpl $0x0, 0x10(%rcx)
jle 0x2e5e2
movq 0x8(%r14), %rdx
xorl %esi, %esi
movl (%rdx,%rsi,4), %edi
movl %edi, (%rax,%rsi,4)
incq %rsi
movslq 0x10(%rcx), %rdi
cmpq %rdi, %rsi
jl 0x2e5c2
jmp 0x2e5e2
xorl %ebx, %ebx
jmp 0x2e5e2
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instance.c
// Function: generate_2d_copy_of_instance
Instanceptr generate_2d_copy_of_instance(Instanceptr inst)
{
	/*!Last Changed 24.03.2005*/
 Instanceptr newinst;
	int i, j, x, dim = current_dataset->multifeaturecount - 1;
	newinst = empty_instance(multifeaturecount_2d(current_dataset) + 1);
	x = 0;
 for (i = 0; i < dim; i++)
	  for (j = i; j < dim; j++)
				{
				 if (x == current_dataset->classdefno)
						 x++;
		  	newinst->values[x].floatvalue = (double) (real_feature(inst, i) * real_feature(inst, j));
					x++;
				}
 for (i = 0; i < dim; i++)
		{
			if (x == current_dataset->classdefno)
					x++;
			newinst->values[x].floatvalue = (double) real_feature(inst, i);
			x++;
		}
	return newinst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa426a(%rip), %r14     # 0xd2870
movq (%r14), %rdi
movl 0x1c0(%rdi), %r15d
leal -0x1(%r15), %ebp
callq 0x13726
leal 0x1(%rax), %edi
callq 0x152fc
xorl %edx, %edx
movl %ebp, %ecx
cmpl $0x2, %r15d
jl 0x2e6a2
movslq %ebp, %rsi
xorl %edi, %edi
xorl %edx, %edx
movq %rdi, %r8
movq (%r14), %r9
movslq 0x1407128(%r9), %r10
xorl %r9d, %r9d
cmpl %r10d, %edx
sete %r9b
leal (%rdx,%r9), %r11d
xorl %r12d, %r12d
cmpq %r10, %rdi
setge %r12b
movq (%rbx), %r13
leaq (,%rdi,8), %rbp
addq %r13, %rbp
movsd (%rbp,%r12,8), %xmm0
xorl %r12d, %r12d
cmpq %r10, %r8
setge %r12b
leaq (%r13,%r12,8), %r10
mulsd (%r10,%r8,8), %xmm0
movq (%rax), %r10
movslq %r11d, %r11
movsd %xmm0, (%r10,%r11,8)
addl %r9d, %edx
incl %edx
incq %r8
cmpq %rsi, %r8
jl 0x2e635
incq %rdi
cmpq %rcx, %rdi
jne 0x2e632
cmpl $0x2, %r15d
jl 0x2e6f1
xorl %esi, %esi
movq (%r14), %rdi
movslq 0x1407128(%rdi), %rdi
xorl %r8d, %r8d
cmpl %edi, %edx
sete %r8b
xorl %r9d, %r9d
cmpq %rdi, %rsi
setge %r9b
shlq $0x3, %r9
addq (%rbx), %r9
leal (%rdx,%r8), %edi
movsd (%r9,%rsi,8), %xmm0
movq (%rax), %r9
movslq %edi, %rdi
movsd %xmm0, (%r9,%rdi,8)
addl %r8d, %edx
incl %edx
incq %rsi
cmpq %rsi, %rcx
jne 0x2e6aa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instance.c
// Function: multiply_with_matrix
double multiply_with_matrix(Instanceptr inst, matrix m)
{
	/*!Last Changed 29.01.2005*/
	/*!Last Changed 09.01.2004*/
	double result = 0;
	int x, i, j = 0, dim = current_dataset->multifeaturecount - 1;
	if (m.col == dim) /*LINEAR MODEL*/
	 {
  	for (i = 0; i < dim; i++)
		  	result += m.values[0][i] * real_feature(inst, i);
	 }
	else /* QUADRATIC MODEL */
	 {
		 x = 0;
		 for (i = 0; i < dim; i++)
  			for (j = i; j < dim; j++)
					 {
						 result += m.values[0][x] * real_feature(inst, i) * real_feature(inst, j);
							x++;
					 }
   for (i = 0; i < dim; i++)
			 {
				 result += m.values[0][x] * real_feature(inst, i);
					x++;
			 }
	 }
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
shrq $0x20, %rsi
leaq 0xa415b(%rip), %rax     # 0xd2870
movq (%rax), %rcx
movslq 0x1c0(%rcx), %r8
movq %r8, %r9
decq %r9
cmpl %esi, %r9d
jne 0x2e774
xorpd %xmm0, %xmm0
cmpl $0x2, %r8d
jl 0x2e846
movq (%rdx), %rax
movslq 0x1407128(%rcx), %rcx
movl %r9d, %edx
movq (%rdi), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rcx, %rdi
setge %r8b
movsd (%rax,%rdi,8), %xmm1
leaq (%rsi,%r8,8), %r8
mulsd (%r8,%rdi,8), %xmm1
addsd %xmm1, %xmm0
incq %rdi
cmpq %rdi, %rdx
jne 0x2e74a
jmp 0x2e846
movl %r9d, %eax
cmpl $0x2, %r8d
jl 0x2e802
movq (%rdx), %r10
movslq 0x1407128(%rcx), %r11
movq (%rdi), %rbx
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
movabsq $0x100000000, %r15      # imm = 0x100000000
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r11, %r14
setge %r13b
movq %r12, %rsi
shlq $0x20, %rsi
movslq %r12d, %r12
leaq (%rbx,%r14,8), %rbp
movsd (%rbp,%r13,8), %xmm1
movq %r14, %r13
movsd (%r10,%r12,8), %xmm2
mulsd %xmm1, %xmm2
xorl %ebp, %ebp
cmpq %r11, %r13
setge %bpl
leaq (%rbx,%rbp,8), %rbp
mulsd (%rbp,%r13,8), %xmm2
addsd %xmm2, %xmm0
incq %r12
incq %r13
addq %r15, %rsi
cmpq %r9, %r13
jl 0x2e7c4
incq %r14
cmpq %rax, %r14
jne 0x2e7a2
sarq $0x20, %rsi
jmp 0x2e808
xorpd %xmm0, %xmm0
xorl %esi, %esi
cmpl $0x2, %r8d
jl 0x2e846
movslq 0x1407128(%rcx), %rcx
movq (%rdi), %rdi
shlq $0x3, %rsi
addq (%rdx), %rsi
xorl %edx, %edx
xorl %r8d, %r8d
cmpq %rcx, %rdx
setge %r8b
movsd (%rsi,%rdx,8), %xmm1
leaq (%rdi,%r8,8), %r8
mulsd (%r8,%rdx,8), %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x2e821
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instance.c
// Function: instance_to_matrix
matrix instance_to_matrix(Instanceptr inst)
{
	/*!Last Changed 09.01.2004*/
	int i, j = 0;
	matrix result;
	result = matrix_alloc(1, current_dataset->multifeaturecount - 1);
	for (i = 0; i < current_dataset->multifeaturecount; i++)
		 if (i != current_dataset->classdefno)
			 {
				 result.values[0][j] = inst->values[i].floatvalue;
					j++;
			 }
 return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa4011(%rip), %r14     # 0xd2870
movq (%r14), %rax
movl 0x1c0(%rax), %esi
decl %esi
movl $0x1, %edi
callq 0x3c6e5
movq (%r14), %rsi
movslq 0x1c0(%rsi), %rcx
testq %rcx, %rcx
jle 0x2e8b3
movl 0x1407128(%rsi), %esi
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rdi, %rsi
je 0x2e8ab
movq (%rbx), %r9
movsd (%r9,%rdi,8), %xmm0
movq (%rdx), %r9
movslq %r8d, %r8
movsd %xmm0, (%r9,%r8,8)
incl %r8d
incq %rdi
cmpq %rdi, %rcx
jne 0x2e88e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instance.c
// Function: dot_product
double dot_product(Instanceptr inst1, Instanceptr inst2)
{
 int i;
 double sum = 0;
 for (i = 0; i < current_dataset->multifeaturecount - 1; i++)
   sum += real_feature(inst1, i) * real_feature(inst2, i);
 return sum;
}

// Assembly:
leaq 0xa33d7(%rip), %rax     # 0xd2870
movq (%rax), %rcx
movl 0x1c0(%rcx), %eax
xorpd %xmm0, %xmm0
cmpl $0x2, %eax
jl 0x2f4e9
decl %eax
movslq 0x1407128(%rcx), %rcx
movq (%rdi), %rdx
movq (%rsi), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rcx, %rdi
setge %r8b
shll $0x3, %r8d
leaq (%rdx,%r8), %r9
movsd (%r9,%rdi,8), %xmm1
addq %rsi, %r8
mulsd (%r8,%rdi,8), %xmm1
addsd %xmm1, %xmm0
incq %rdi
cmpq %rdi, %rax
jne 0x2f4bc
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instance.c
// Function: distance_between_instances
double distance_between_instances(Instanceptr inst1, Instanceptr inst2)
{
 int i;
 double res = 0;
 if (mustrealize)
  {
   for (i = 0; i < current_dataset->multifeaturecount - 1; i++)
     res = res + pow((real_feature(inst1, i) - real_feature(inst2, i)), 2);
  }
 else
  {
   for (i = 0; i < current_dataset->featurecount; i++)
     switch (current_dataset->features[i].type)
      {
       case INTEGER:res += pow((inst1->values[i].intvalue - inst2->values[i].intvalue), 2);
                    break;
       case    REAL:res += pow((inst1->values[i].floatvalue - inst2->values[i].floatvalue), 2);
                    break;
       case  STRING:if (inst1->values[i].stringindex != inst2->values[i].stringindex)
                      res += 1;
                    break;
      }
  }
 return res;
}

// Assembly:
leaq 0x37fab3(%rip), %rax    # 0x3aefa4
cmpl $0x0, (%rax)
leaq 0xa3375(%rip), %rax     # 0xd2870
movq (%rax), %rax
je 0x2f55a
movl 0x1c0(%rax), %ecx
xorpd %xmm0, %xmm0
cmpl $0x2, %ecx
jl 0x2f5e4
decl %ecx
movslq 0x1407128(%rax), %rax
movq (%rdi), %rdx
movq (%rsi), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rax, %rdi
setge %r8b
shll $0x3, %r8d
leaq (%rdx,%r8), %r9
movsd (%r9,%rdi,8), %xmm1
addq %rsi, %r8
subsd (%r8,%rdi,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdi
cmpq %rdi, %rcx
jne 0x2f524
jmp 0x2f5e4
movslq 0x1bc(%rax), %rcx
testq %rcx, %rcx
jle 0x2f5e5
addq $0x30f08, %rax          # imm = 0x30F08
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd 0x72fa6(%rip), %xmm1    # 0xa2520
movl (%rax), %r8d
cmpl $0x2, %r8d
je 0x2f5bc
cmpl $0x1, %r8d
je 0x2f5a6
testl %r8d, %r8d
jne 0x2f5d6
movq (%rdi), %r8
movl (%r8,%rdx,8), %r8d
movq (%rsi), %r9
subl (%r9,%rdx,8), %r8d
xorps %xmm2, %xmm2
cvtsi2sd %r8d, %xmm2
jmp 0x2f5ce
movq (%rdi), %r8
movl (%r8,%rdx,8), %r8d
movq (%rsi), %r9
cmpl (%r9,%rdx,8), %r8d
je 0x2f5d6
addsd %xmm1, %xmm0
jmp 0x2f5d6
movq (%rdi), %r8
movsd (%r8,%rdx,8), %xmm2
movq (%rsi), %r8
subsd (%r8,%rdx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rdx
addq $0x340, %rax            # imm = 0x340
cmpq %rdx, %rcx
jne 0x2f57a
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instance.c
// Function: deallocate
void deallocate(Instanceptr myptr)
{
	/*!Last Changed 07.01.2007 added sublist*/
 Instanceptr tmp;
 if (myptr)
  {
   while(myptr)
    {
     tmp = myptr->next;
     safe_free(myptr->values);
					if (myptr->sublist)
						 deallocate(myptr->sublist);
     if (myptr->class_labels)
       safe_free(myptr->class_labels);
     safe_free(myptr);
     myptr = tmp;
    }
  }
}

// Assembly:
testq %rdi, %rdi
je 0x2f661
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rdi
movq 0x10(%rbx), %r14
callq 0x39194
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2f63c
callq 0x2f616
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2f64a
callq 0x39194
movq %rbx, %rdi
callq 0x39194
movq %r14, %rbx
testq %r14, %r14
jne 0x2f622
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: generate_2d_copy_of_instance_list
Instanceptr generate_2d_copy_of_instance_list(Instanceptr list)
{
 /*!Last Changed 23.03.2005*/
 Instanceptr result, tmp, newinst, newbefore;
 result = generate_2d_copy_of_instance(list);
 newbefore = result;
 tmp = list->next;
 while (tmp)
  {
   newinst = generate_2d_copy_of_instance(tmp);
   newbefore->next = newinst;
   newbefore = newinst;
   tmp = tmp->next;
  }
 return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x2e5f1
movq %rax, %rbx
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x2f698
movq %rbx, %r15
movq %r14, %rdi
callq 0x2e5f1
movq %rax, 0x10(%r15)
movq 0x10(%r14), %r14
movq %rax, %r15
testq %r14, %r14
jne 0x2f680
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: find_mean_of_regression_value
double find_mean_of_regression_value(Instanceptr instances)
{
 /*!Last Changed 09.12.2004*/
 double sum = 0;
 int count = 0;
 Instanceptr tmp;
 tmp = instances;
 while (tmp)
  {
   count++;
   sum += give_regressionvalue(tmp);
   tmp = tmp->next;
  }
 if (count != 0)
   return sum / count;
 return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2f6d5
movq %rdi, %rbx
xorpd %xmm1, %xmm1
xorl %ebp, %ebp
movsd %xmm1, (%rsp)
incl %ebp
movq %rbx, %rdi
callq 0x2eaee
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x2f6b2
jmp 0x2f6db
xorl %ebp, %ebp
xorpd %xmm1, %xmm1
testl %ebp, %ebp
xorpd %xmm0, %xmm0
je 0x2f6f2
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: find_variance_of_regression_value
double find_variance_of_regression_value(Instanceptr instances, double mean)
{
 /*!Last Changed 09.12.2004*/
 double sum = 0, value;
 Instanceptr tmp;
 int count = 0;
 tmp = instances;
 while (tmp)
  {
   count++;
   value = give_regressionvalue(tmp);
   sum = sum + (value - mean) * (value - mean);
   tmp = tmp->next;
  }
 return sum;
}

// Assembly:
testq %rdi, %rdi
je 0x2f751
pushq %rbx
subq $0x10, %rsp
movapd %xmm0, %xmm1
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x2eaee
movsd 0x8(%rsp), %xmm1
subsd %xmm1, %xmm0
mulsd %xmm0, %xmm0
movsd (%rsp), %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, (%rsp)
movsd (%rsp), %xmm0
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x2f714
addq $0x10, %rsp
popq %rbx
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: print_instance_list_with_extra_features
void print_instance_list_with_extra_features(FILE* outfile, char s, Datasetptr d, Instanceptr listptr, int extra_features)
{
 Instanceptr tmp;
 tmp = listptr;
 while (tmp)
  {
   print_instance_with_extra_features(outfile, s, d, tmp, extra_features);
   tmp = tmp->next;
  }
}

// Assembly:
testq %rcx, %rcx
je 0x2fa65
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movsbl %sil, %ebp
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x2e8bb
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x2fa41
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: print_class_information
void print_class_information(FILE* outfile, Instanceptr listptr)
{
 Instanceptr tmp;
 int index;
 tmp = listptr;
 index = 0;
 while (tmp)
  {
   fprintf(outfile, "%d %s\n", index, current_dataset->classes[give_classno(tmp)]);
   index++;
   tmp = tmp->next;
  }
}

// Assembly:
testq %rsi, %rsi
je 0x2fac7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa2ded(%rip), %r12     # 0xd2870
leaq 0x76045(%rip), %r15     # 0xa5acf
xorl %ebp, %ebp
movq (%r12), %r13
movq %rbx, %rdi
callq 0x2eaca
cltq
movq 0x18(%r13,%rax,8), %rcx
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x42e0
incl %ebp
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x2fa8c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: print_kernel_matrix
void print_kernel_matrix(FILE* outfile, Instanceptr listptr)
{
 Svm_parameter param;
 Svm_nodeptr node1, node2;
 Instanceptr tmp1, tmp2;
	param.coef0 = get_parameter_f("svmcoef0");
	param.degree = get_parameter_i("svmdegree");
	param.gamma = get_parameter_f("svmgamma");
	param.kernel_type = get_parameter_l("kerneltype");
 tmp1 = listptr;
 while (tmp1)
  {
   node1 = instance_to_svmnode(tmp1);
   tmp2 = listptr;
   while (tmp2)
    {
     node2 = instance_to_svmnode(tmp2);
     fprintf(outfile, "%.6f ", k_function(node1, node2, param));    
     tmp2 = tmp2->next;
    }
   fprintf(outfile, "\n");
   tmp1 = tmp1->next;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x72d67(%rip), %rdi     # 0xa284d
callq 0x534b6
movsd %xmm0, 0x78(%rsp)
leaq 0x72d5e(%rip), %rdi     # 0xa2856
callq 0x5341c
movl %eax, 0x68(%rsp)
leaq 0x72d58(%rip), %rdi     # 0xa2860
callq 0x534b6
movsd %xmm0, 0x70(%rsp)
leaq 0x72d28(%rip), %rdi     # 0xa2842
callq 0x535f7
movl %eax, 0x64(%rsp)
movq %rbx, 0x58(%rsp)
testq %rbx, %rbx
je 0x2fb9b
leaq 0x60(%rsp), %r15
leaq 0x7dbb0(%rip), %r12     # 0xad6e9
movq 0x58(%rsp), %r13
movq %r13, %rdi
callq 0x2e3eb
movq %rax, %rbp
movq 0x58(%rsp), %rbx
movq %rbx, %rdi
callq 0x2e3eb
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbp, %rdi
movq %rax, %rsi
callq 0x912a1
movq %r14, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x42e0
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x2fb4e
movl $0xa, %edi
movq %r14, %rsi
callq 0x4150
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x2fb3e
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: print_instance_list
void print_instance_list(FILE* outfile, char s, Datasetptr d, Instanceptr listptr)
{
 /*!Last Changed 15.03.2007 added dataset with selected features*/
 /*!Last Changed 19.04.2004*/
 int classno, colcount = 0, i;
 int* exported;
 Instanceptr tmp;
 if (mustrealize)
  {
   colcount++;
   for (i = 0; i < d->multifeaturecount - 1; i++)
      if (d->selected[i])
        colcount++;
  }
 else
   for (i = 0; i < d->featurecount; i++)
     if (d->features[i].selected)
       colcount++;
 if (get_parameter_l("namestype") == NAMES_AYSU)
   fprintf(outfile, "# %d %d\n", data_size(listptr), colcount);
 tmp = listptr;
 if (d->classno != 0)
   exported = (int *)get_parameter_a("is_class_exported");
 while (tmp)
  {
   if (d->classno != 0)
    {
     classno = give_classno(tmp);
     if (exported[classno])
       print_instance(outfile, s, d, tmp);
    }
   else
     print_instance(outfile, s, d, tmp);
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x37f3dd(%rip), %rax    # 0x3aefa4
cmpl $0x0, (%rax)
je 0x2fbf9
movl 0x1c0(%r14), %eax
movl $0x1, %r12d
cmpl $0x2, %eax
jl 0x2fc2f
decl %eax
xorl %ecx, %ecx
cmpl $0x1, 0x18864(%r14,%rcx,4)
sbbl $-0x1, %r12d
incq %rcx
cmpq %rcx, %rax
jne 0x2fbe2
jmp 0x2fc2f
movslq 0x1bc(%r14), %rax
testq %rax, %rax
jle 0x2fc2c
imulq $0x340, %rax, %rax      # imm = 0x340
xorl %ecx, %ecx
xorl %r12d, %r12d
cmpl $0x1, 0x30f24(%r14,%rcx)
sbbl $-0x1, %r12d
addq $0x340, %rcx            # imm = 0x340
cmpq %rcx, %rax
jne 0x2fc11
jmp 0x2fc2f
xorl %r12d, %r12d
leaq 0x74443(%rip), %rdi     # 0xa4079
callq 0x535f7
cmpl $0x4, %eax
jne 0x2fc69
xorl %edx, %edx
testq %rbx, %rbx
je 0x2fc55
movq %rbx, %rax
incl %edx
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x2fc4a
leaq 0x731ce(%rip), %rsi     # 0xa2e2a
movq %r15, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, 0x10(%r14)
je 0x2fc81
leaq 0x75e5f(%rip), %rdi     # 0xa5ad6
callq 0x53784
movq %rax, %r12
jmp 0x2fc81
testq %rbx, %rbx
je 0x2fcbb
movsbl %bpl, %ebp
cmpl $0x0, 0x10(%r14)
je 0x2fca2
movq %rbx, %rdi
callq 0x2eaca
cltq
cmpl $0x0, (%r12,%rax,4)
je 0x2fcb2
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2eb08
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x2fc8a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: create_list_from_exceptions
void create_list_from_exceptions(Instanceptr* list, Instanceptr* list2)
{
 /*!Last Changed 03.12.2004 changed*/
 /*!Last Changed 08.05.2004*/
 Instanceptr tmp1, tmp2 = NULL, tmp1before;
 if (list2 == NULL)
   return;
 tmp1 = *list2;
 tmp1before = NULL;
 *list = NULL;
 while (tmp1)
  {
   if (tmp1->isexception)
    {
     if (*list == NULL)
       *list = tmp1;
     else
       tmp2->next = tmp1;
     tmp2 = tmp1;
    }
   else
    {
     if (tmp1before)
       tmp1before->next = tmp1;
     else
       *list2 = tmp1;
     tmp1before = tmp1;
    }
   tmp1 = tmp1->next;
  }
 if (tmp2)
   tmp2->next = NULL;
 if (tmp1before)
   tmp1before->next = NULL;
}

// Assembly:
testq %rsi, %rsi
je 0x2fd33
movq (%rsi), %rdx
movq $0x0, (%rdi)
testq %rdx, %rdx
je 0x2fd15
xorl %eax, %eax
xorl %ecx, %ecx
cmpl $0x0, 0x20(%rdx)
je 0x2fcf0
movq (%rdi), %r8
movq %rcx, %r9
movq %rdi, %r10
movq %rdx, %rcx
jmp 0x2fcfc
movq %rax, %r8
movq %rax, %r9
movq %rsi, %r10
movq %rdx, %rax
addq $0x10, %r9
testq %r8, %r8
cmoveq %r10, %r9
movq %rdx, (%r9)
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
jne 0x2fcdc
jmp 0x2fd19
xorl %ecx, %ecx
xorl %eax, %eax
testq %rcx, %rcx
je 0x2fd26
movq $0x0, 0x10(%rcx)
testq %rax, %rax
je 0x2fd33
movq $0x0, 0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: reverse_instancelist
void reverse_instancelist(Instanceptr* list)
{
 /*!Last Changed 26.03.2007*/
 Instanceptr current, next, header = NULL;
 current = *list;
 while (current)
  {
   next = current->next;
   current->next = header;
   header = current;
   current = next;
  }
 *list = header;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x2fd53
xorl %edx, %edx
movq %rax, %rcx
movq 0x10(%rax), %rax
movq %rdx, 0x10(%rcx)
movq %rcx, %rdx
testq %rax, %rax
jne 0x2fd3e
jmp 0x2fd55
xorl %ecx, %ecx
movq %rcx, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: merge_instancelist_groups
void merge_instancelist_groups(Instanceptr* mergedlist, Instanceptr* lists, int count)
{
 /*!Last Changed 04.04.2007*/
 int i = 0, j;
 Instanceptr tmp;
 while (!lists[i] && i < count)
   i++;
 *mergedlist = lists[i];
 tmp = lists[i];
 for (j = i + 1; j < count; j++)
  {
   while (tmp->next) /*Go to the end of list[i - 1]*/
     tmp = tmp->next;
   tmp->next = lists[j];
  }
}

// Assembly:
movslq %edx, %rcx
xorl %eax, %eax
movq %rax, %r9
movq (%rsi,%rax,8), %r8
incq %rax
cmpq %rcx, %r9
jge 0x2fd93
testq %r8, %r8
je 0x2fd7f
movq %r8, (%rdi)
cmpl %edx, %eax
jge 0x2fdc0
movq -0x8(%rsi,%rax,8), %rdi
movl %edx, %ecx
movq %rdi, %rdx
movq %rdx, %rdi
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
jne 0x2fda4
movq (%rsi,%rax,8), %rdx
movq %rdx, 0x10(%rdi)
incq %rax
cmpq %rcx, %rax
jne 0x2fda1
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: merge_instancelist_without_outliers
void merge_instancelist_without_outliers(Instanceptr* list1, Instanceptr* list2, int classno)
{
 /*!Last Changed 20.06.2005*/
 int instance_classno;
 Instanceptr tmp1 = *list1, tmp2 = *list2, tmp2before = NULL;
 if (tmp2 == NULL)
   return;
 if (tmp1)
   while (tmp1->next != NULL)
     tmp1 = tmp1->next;
 while (tmp2)
  {
   instance_classno = give_classno(tmp2);
   if (instance_classno == classno)
    {
     if (tmp1)
       tmp1->next = tmp2;
     else
       *list1 = tmp2;
     tmp1 = tmp2;
     if (tmp2before)
       tmp2before->next = tmp2->next;
     else
       *list2 = tmp2->next;
    }
   else
     tmp2before = tmp2;
   tmp2 = tmp2->next;
  }
 if (tmp1)
   tmp1->next = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r12
testq %r12, %r12
je 0x2fe43
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
testq %rax, %rax
je 0x2fdf2
movq %rax, %r13
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x2fde4
jmp 0x2fdf5
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %r12, %rdi
callq 0x2eaca
cmpl %ebx, %eax
jne 0x2fe29
leaq 0x10(%r13), %rax
testq %r13, %r13
cmoveq %r15, %rax
movq %r12, (%rax)
leaq 0x10(%rbp), %rax
testq %rbp, %rbp
movq 0x10(%r12), %rcx
cmoveq %r14, %rax
movq %rcx, (%rax)
movq %r12, %r13
jmp 0x2fe2c
movq %r12, %rbp
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x2fdf7
testq %r13, %r13
je 0x2fe43
movq $0x0, 0x10(%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: create_array_of_instances
Instanceptr* create_array_of_instances(Instanceptr instances)
{
 /*!Last Changed 02.02.2004*/
 /*!Last Changed 26.01.2003*/
 Instanceptr* result, tmp = instances;
 int i, size;
 size = data_size(instances);
 result = safemalloc(size * sizeof(Instanceptr), "create_array_of_instances", 4);
 i = 0;
 while (tmp)
  {
   result[i] = tmp;
   i++;
   tmp = tmp->next;
  }
 return result;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x2fe6f
xorl %edi, %edi
movq %rbx, %rax
movq 0x10(%rax), %rax
addq $0x8, %rdi
testq %rax, %rax
jne 0x2fe60
jmp 0x2fe71
xorl %edi, %edi
leaq 0x75c70(%rip), %rsi     # 0xa5ae8
movl $0x4, %edx
callq 0x390f5
testq %rbx, %rbx
je 0x2fe9a
movq %rax, %rcx
movq %rbx, (%rcx)
movq 0x10(%rbx), %rbx
addq $0x8, %rcx
testq %rbx, %rbx
jne 0x2fe8a
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: copy_of_instancelist
Instanceptr copy_of_instancelist(Instanceptr list)
{
 Instanceptr tmp = list, newinstance, before = NULL, start = NULL;
 while (tmp)
  {
   newinstance = copy_of_instance(tmp);
   if (before)
     before->next = newinstance;
   else
     start = newinstance;
   before = newinstance;
   tmp = tmp->next;
  }
 return start;
}

// Assembly:
testq %rdi, %rdi
je 0x2fedb
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x2e4db
movq %rax, %rcx
testq %r15, %r15
je 0x2fec6
movq %rcx, 0x10(%r15)
movq %r14, %rax
movq 0x10(%rbx), %rbx
movq %rax, %r14
movq %rcx, %r15
testq %rbx, %rbx
jne 0x2feaf
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq