LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2
popq %rdi
pushq $0x1
popq %rdx
movq %r15, %r8
callq 0x2460f
movq %rax, %r12
movq %rax, 0x10(%rsp)
movq %rax, %rdi
callq 0x250b5
movq %rax, 0x18(%rsp)
movq %r12, %rdi
callq 0x250b5
movq %rax, 0x20(%rsp)
movl 0x8(%rbx), %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x27f37
movq %r12, %rdi
movq %r14, %rsi
callq 0x288d2
movsd %xmm0, 0x8(%rsp)
xorl %r13d, %r13d
cmpl $-0x1, %r13d
je 0x28b89
movslq %r13d, %rax
movq 0x10(%rsp,%rax,8), %rdi
callq 0x250b5
movq %rax, %r12
xorl %r13d, %r13d
cmpq $0x3, %r13
je 0x28b51
movq 0x10(%rsp,%r13,8), %rdi
callq 0x24a32
movq %r12, %rdi
movl %r13d, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x289aa
movq %rax, 0x10(%rsp,%r13,8)
incq %r13
jmp 0x28b26
xorl %ebp, %ebp
pushq $-0x1
popq %rax
movl %eax, %r13d
cmpq $0x3, %rbp
je 0x28b0d
movq 0x10(%rsp,%rbp,8), %rdi
movq %r14, %rsi
callq 0x288d2
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
cmoval %ebp, %r13d
maxsd %xmm1, %xmm0
incq %rbp
movsd %xmm0, 0x8(%rsp)
jmp 0x28b59
xorl %ebx, %ebx
cmpq $0x3, %rbx
je 0x28ba0
movq 0x10(%rsp,%rbx,8), %rdi
callq 0x24a32
incq %rbx
jmp 0x28b8b
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_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
testq %rbx, %rbx
je 0x28dd0
movq %rbx, %rdi
callq 0x2b47e
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28de7
xorl %ecx, %ecx
cmpl %eax, %ebp
setne %cl
addl %ecx, %r12d
movq 0x10(%rbx), %rbx
incl %r15d
jmp 0x28da3
cvtsi2sd %r12d, %xmm0
cvtsi2sd %r15d, %xmm1
divsd %xmm1, %xmm0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
callq 0x2adc0
cltq
movq %rax, (%rsp)
pushq $-0x1
popq %rbx
xorl %r13d, %r13d
movq 0x8(%rsp), %r15
movq (%rsp), %rbp
leaq 0xa4a50(%rip), %rax     # 0xcd870
movq (%rax), %rax
movslq 0x10(%rax), %rax
cmpq %rax, %r13
jge 0x28ed4
movq (%r15,%r13,8), %rax
movl 0x8(%rax), %ecx
movl %ebx, %r14d
pushq $0x8
popq %rbx
movq %rbx, %rdi
movq %rbx, %rsi
movl %ebp, %edx
leaq 0x6f912(%rip), %r12     # 0x9875e
movq %r12, %r8
pushq $0x6
popq %r9
callq 0x351c3
movq %rbp, %rdi
movq %rbx, %rsi
movl %r14d, %ebx
movq %rax, %r14
movq %r12, %rdx
pushq $0x7
popq %rcx
callq 0x35067
movq %rax, %r12
movq (%r15,%r13,8), %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
leaq 0x20(%rsp), %rcx
movq %rax, %r8
callq 0x27819
cmpl $-0x1, %ebx
sete %al
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm0, %xmm1
seta %cl
orb %al, %cl
testb %cl, %cl
jne 0x28eae
movapd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
cmovnel %r13d, %ebx
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x34fc3
movq %r12, %rdi
callq 0x34ff7
incq %r13
jmp 0x28e19
movl %ebx, %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_O2/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 0x3811bc(%rip), %r15    # 0x3aa0b8
movslq 0xec(%r15), %r12
movq 0xf0(%r15), %rdi
leaq 0x1(%r12), %r14
leaq 0x4(,%r12,4), %rsi
movl %r14d, %edx
callq 0x34f30
movq %rax, 0xf0(%r15)
andl $0x0, (%rax,%r12,4)
movq 0xf8(%r15), %rdi
movq %r14, %rsi
movl %r14d, %edx
callq 0x34f30
movq %rax, 0xf8(%r15)
movb %bpl, (%rax,%r12)
movq 0x100(%r15), %rdi
leaq 0x8(,%r12,8), %rsi
movl %r14d, %edx
callq 0x34f30
movq %rax, 0x100(%r15)
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq 0x3604c
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_O2/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 0x37fa0c(%rip), %rax    # 0x3aa0b8
movabsq $0x29400000294, %rcx    # imm = 0x29400000294
movq %rcx, (%rax)
andq $0x0, 0x120(%rax)
andl $0x0, 0x28(%rax)
andl $0x0, 0x98(%rax)
andq $0x0, 0x40(%rax)
andq $0x0, 0xb0(%rax)
pushq $0x1
popq %rcx
movl %ecx, 0x8(%rax)
movl %ecx, 0x78(%rax)
andl $0x0, 0x38(%rax)
andl $0x0, 0xa8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0xec(%rax)
movups %xmm0, 0xf8(%rax)
movaps 0x6e16b(%rip), %xmm0    # 0x98870
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x80(%rax)
andl $0x0, 0x58(%rax)
pushq $0x2
popq %rcx
movl %ecx, 0x48(%rax)
movabsq $0x4024000000000000, %rdx # imm = 0x4024000000000000
movq %rdx, 0x50(%rax)
andl $0x0, 0xc8(%rax)
movl %ecx, 0xb8(%rax)
movq %rdx, 0xc0(%rax)
andl $0x0, 0x70(%rax)
movl %ecx, 0x60(%rax)
movq %rdx, 0x68(%rax)
andl $0x0, 0xe0(%rax)
movl %ecx, 0xd0(%rax)
movq %rdx, 0xd8(%rax)
andl $0x0, 0x118(%rax)
movl %ecx, 0x108(%rax)
movq %rdx, 0x110(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x37f941(%rip), %rax    # 0x3aa0b8
movl 0x124(%rax), %r8d
movq 0x128(%rax), %rcx
xorl %edx, %edx
testl %r8d, %r8d
cmovlel %edx, %r8d
imulq $0x60, %r8, %r8
xorl %eax, %eax
cmpq %rdx, %r8
je 0x2a7b2
cmpl %edi, (%rcx,%rdx)
jne 0x2a7ac
xorl %r9d, %r9d
cmpl %esi, 0x20(%rcx,%rdx)
sete %r9b
addl %r9d, %eax
addq $0x60, %rdx
jmp 0x2a794
retq
// File: /workspace/github_c_makefile_star2_O2/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
leal 0x2(%rcx), %eax
cvtsi2sd %eax, %xmm1
addl $-0x2, %ecx
cvtsi2sd %ecx, %xmm2
mulsd 0x6e072(%rip), %xmm1    # 0x98858
addsd %xmm2, %xmm1
movsd 0x6e06e(%rip), %xmm2    # 0x98860
divsd %xmm1, %xmm2
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movapd 0x6e07e(%rip), %xmm1    # 0x98880
divpd %xmm0, %xmm1
mulsd %xmm1, %xmm2
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
mulsd %xmm1, %xmm0
movsd %xmm0, (%r8)
cvtsi2sd %edi, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
cvtsi2sd %esi, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm3, %xmm1
cvttsd2si %xmm1, %eax
addl $0x50, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa2a8a(%rip), %r14     # 0xcd870
movq (%r14), %rax
movslq 0x1c0(%rax), %rdi
shlq $0x4, %rdi
leaq 0x6dc31(%rip), %rsi     # 0x98a2c
pushq $0x3
popq %rdx
callq 0x34f59
movq (%r14), %rcx
movl 0x1c0(%rcx), %edx
cmpl $0x2, %edx
pushq $0x1
popq %rsi
cmovgel %edx, %esi
decl %esi
xorl %edi, %edi
xorpd %xmm0, %xmm0
xorl %r8d, %r8d
movslq %r8d, %rdx
cmpq %rdi, %rsi
je 0x2ae73
movslq 0x1407128(%rcx), %r9
xorl %r10d, %r10d
cmpq %r9, %rdi
setge %r10b
shlq $0x3, %r10
addq (%rbx), %r10
movsd (%r10,%rdi,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x2ae57
jp 0x2ae57
cmpl $0x3, 0x140713c(%rcx)
jne 0x2ae6e
movq %rdx, %r8
shlq $0x4, %r8
movl %edi, (%rax,%r8)
movsd %xmm1, 0x8(%rax,%r8)
incl %edx
movl %edx, %r8d
incq %rdi
jmp 0x2ae20
movq %rdx, %rsi
shlq $0x4, %rsi
orl $-0x1, (%rax,%rsi)
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 0x34f30
// File: /workspace/github_c_makefile_star2_O2/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 0x2afa9
movq %rdi, %rbx
leaq 0x6db5e(%rip), %r15     # 0x98a40
pushq $0x30
popq %rdi
pushq $0x5
popq %rdx
movq %r15, %rsi
callq 0x34f59
movq %rax, %r14
leaq 0xa2976(%rip), %r12     # 0xcd870
movq (%r12), %rax
movslq 0x1c0(%rax), %rdi
shlq $0x3, %rdi
pushq $0x6
popq %rdx
movq %r15, %rsi
callq 0x34f59
movq %rax, (%r14)
xorl %eax, %eax
movq (%r12), %rcx
movslq 0x1c0(%rcx), %rdx
cmpq %rdx, %rax
jge 0x2af5d
movl 0x1407128(%rcx), %edx
cmpq %rdx, %rax
jne 0x2af48
cmpl $0x0, 0x10(%rcx)
movq (%r14), %rcx
je 0x2af4b
movq (%rbx), %rdx
movl (%rdx,%rax,8), %edx
movl %edx, (%rcx,%rax,8)
jmp 0x2af58
movq (%r14), %rcx
movq (%rbx), %rdx
movsd (%rdx,%rax,8), %xmm0
movsd %xmm0, (%rcx,%rax,8)
incq %rax
jmp 0x2af19
andq $0x0, 0x10(%r14)
andq $0x0, 0x28(%r14)
cmpl $0x4, 0x140713c(%rcx)
jne 0x2afae
movslq 0x10(%rcx), %rdi
shlq $0x2, %rdi
leaq 0x6dac1(%rip), %rsi     # 0x98a40
pushq $0xf
popq %rdx
callq 0x34f59
movq %rax, 0x8(%r14)
movq (%r12), %rcx
xorl %edx, %edx
movslq 0x10(%rcx), %rsi
cmpq %rsi, %rdx
jge 0x2afb3
movq 0x8(%rbx), %rsi
movl (%rsi,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
jmp 0x2af91
xorl %r14d, %r14d
jmp 0x2afb3
andq $0x0, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xa289b(%rip), %r14     # 0xcd870
movq (%r14), %rdi
movl 0x1c0(%rdi), %r15d
decl %r15d
callq 0x126ea
leal 0x1(%rax), %edi
callq 0x140fd
xorl %esi, %esi
testl %r15d, %r15d
movl $0x0, %ecx
cmovgl %r15d, %ecx
xorl %edx, %edx
cmpq %rcx, %rsi
je 0x2b06b
movq %rsi, %rdi
cmpq %rdi, %r15
je 0x2b066
movq (%r14), %r8
movslq 0x1407128(%r8), %r9
xorl %r8d, %r8d
cmpl %r9d, %edx
sete %r8b
leal (%rdx,%r8), %r10d
xorl %r11d, %r11d
cmpq %r9, %rsi
setge %r11b
movq (%rbx), %r12
leaq (%r12,%rsi,8), %r13
movsd (%r13,%r11,8), %xmm0
xorl %r11d, %r11d
cmpq %r9, %rdi
setge %r11b
leaq (%r12,%r11,8), %r9
mulsd (%r9,%rdi,8), %xmm0
movq (%rax), %r9
movslq %r10d, %r10
movsd %xmm0, (%r9,%r10,8)
addl %r8d, %edx
incl %edx
incq %rdi
jmp 0x2b007
incq %rsi
jmp 0x2afff
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x2b0b6
movq (%r14), %rdi
movslq 0x1407128(%rdi), %rdi
xorl %r8d, %r8d
cmpl %edi, %edx
sete %r8b
leal (%rdx,%r8), %r9d
xorl %r10d, %r10d
cmpq %rdi, %rsi
setge %r10b
shlq $0x3, %r10
addq (%rbx), %r10
movsd (%r10,%rsi,8), %xmm0
movq (%rax), %rdi
movslq %r9d, %r9
movsd %xmm0, (%rdi,%r9,8)
addl %r8d, %edx
incl %edx
incq %rsi
jmp 0x2b06d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa279b(%rip), %rax     # 0xcd870
movq (%rax), %rax
movl 0x1c0(%rax), %r11d
decl %r11d
cmpl %esi, %r11d
jne 0x2b12b
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
xorpd %xmm0, %xmm0
cmpq %rcx, %rsi
je 0x2b202
movq (%rdx), %r8
movslq 0x1407128(%rax), %r9
xorl %r10d, %r10d
cmpq %r9, %rcx
setge %r10b
movsd (%r8,%rcx,8), %xmm1
shlq $0x3, %r10
addq (%rdi), %r10
mulsd (%r10,%rcx,8), %xmm1
addsd %xmm1, %xmm0
incq %rcx
jmp 0x2b0f2
xorl %esi, %esi
testl %r11d, %r11d
movl $0x0, %ecx
cmovgl %r11d, %ecx
movl %r11d, %r8d
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpq %rcx, %r9
je 0x2b1c0
movl %r11d, %r11d
movslq %r10d, %r10
movq %r9, %rbx
movq %r10, %r14
cmpq %rbx, %r8
je 0x2b1b2
movq (%rdx), %r15
movsd (%r15,%r14,8), %xmm1
movslq 0x1407128(%rax), %r15
xorl %r12d, %r12d
cmpq %r15, %r9
setge %r12b
movq (%rdi), %r13
leaq (,%r9,8), %rbp
addq %r13, %rbp
mulsd (%rbp,%r12,8), %xmm1
xorl %r12d, %r12d
cmpq %r15, %rbx
setge %r12b
leaq (,%r12,8), %r15
addq %r13, %r15
mulsd (%r15,%rbx,8), %xmm1
addsd %xmm1, %xmm0
incq %r14
incq %rbx
jmp 0x2b157
addq %r11, %r10
incq %r9
addl %r11d, %esi
decl %r11d
jmp 0x2b146
movslq %esi, %rsi
shlq $0x3, %rsi
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x2b202
movq (%rdx), %r9
addq %rsi, %r9
movslq 0x1407128(%rax), %r10
xorl %r11d, %r11d
cmpq %r10, %r8
setge %r11b
movsd (%r9,%r8,8), %xmm1
shlq $0x3, %r11
addq (%rdi), %r11
mulsd (%r11,%r8,8), %xmm1
addsd %xmm1, %xmm0
incq %r8
jmp 0x2b1ca
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa2655(%rip), %r14     # 0xcd870
movq (%r14), %rax
movl 0x1c0(%rax), %esi
decl %esi
pushq $0x1
popq %rdi
callq 0x380d3
movq (%r14), %rcx
movslq 0x1c0(%rcx), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rsi, %rdi
jge 0x2b26b
movl 0x1407128(%rcx), %r9d
cmpq %r9, %rdi
je 0x2b266
movq (%rbx), %r9
movsd (%r9,%rdi,8), %xmm0
movq (%rdx), %r9
movslq %r8d, %r8
movsd %xmm0, (%r9,%r8,8)
incl %r8d
incq %rdi
jmp 0x2b23d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa19d6(%rip), %rax     # 0xcd870
movq (%rax), %rax
movl 0x1c0(%rax), %edx
cmpl $0x2, %edx
pushq $0x1
popq %rcx
cmovgel %edx, %ecx
decl %ecx
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x2beec
movslq 0x1407128(%rax), %r8
xorl %r9d, %r9d
cmpq %r8, %rdx
setge %r9b
shll $0x3, %r9d
movq (%rdi), %r8
addq %r9, %r8
movsd (%r8,%rdx,8), %xmm1
addq (%rsi), %r9
mulsd (%r9,%rdx,8), %xmm1
addsd %xmm1, %xmm0
incq %rdx
jmp 0x2beb4
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x37e0b0(%rip), %rax    # 0x3a9fa4
cmpl $0x0, (%rax)
leaq 0xa1972(%rip), %rax     # 0xcd870
movq (%rax), %rax
je 0x2bf5a
movl 0x1c0(%rax), %edx
cmpl $0x2, %edx
pushq $0x1
popq %rcx
cmovgel %edx, %ecx
decl %ecx
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x2bfe2
movslq 0x1407128(%rax), %r8
xorl %r9d, %r9d
cmpq %r8, %rdx
setge %r9b
shll $0x3, %r9d
movq (%rdi), %r8
addq %r9, %r8
movsd (%r8,%rdx,8), %xmm1
addq (%rsi), %r9
subsd (%r9,%rdx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
jmp 0x2bf1a
movl 0x1bc(%rax), %ecx
addq $0x30f08, %rax          # imm = 0x30F08
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
xorpd %xmm0, %xmm0
movsd 0x695a7(%rip), %xmm1    # 0x95520
cmpq %rdx, %rcx
je 0x2bfe2
movl (%rax), %r8d
cmpl $0x2, %r8d
je 0x2bfbd
cmpl $0x1, %r8d
je 0x2bfa7
testl %r8d, %r8d
jne 0x2bfd7
movq (%rdi), %r8
movl (%r8,%rdx,8), %r8d
movq (%rsi), %r9
subl (%r9,%rdx,8), %r8d
cvtsi2sd %r8d, %xmm2
jmp 0x2bfcf
movq (%rdi), %r8
movl (%r8,%rdx,8), %r8d
movq (%rsi), %r9
cmpl (%r9,%rdx,8), %r8d
je 0x2bfd7
addsd %xmm1, %xmm0
jmp 0x2bfd7
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
jmp 0x2bf79
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2c05b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rdi
movq 0x10(%rbx), %r14
callq 0x34ff7
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2c036
callq 0x2c010
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2c044
callq 0x34ff7
movq %rbx, %rdi
callq 0x34ff7
movq %r14, %rbx
testq %r14, %r14
jne 0x2c01c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
callq 0x2afc2
movq %rax, %r14
movq %rax, %r15
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x2c086
movq %rbx, %rdi
callq 0x2afc2
movq %rax, 0x10(%r15)
jmp 0x2c06c
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
testq %rbx, %rbx
je 0x2c0c3
incl %ebp
movq %rbx, %rdi
callq 0x2b4a0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq 0x10(%rbx), %rbx
jmp 0x2c0a0
xorpd %xmm0, %xmm0
testl %ebp, %ebp
je 0x2c0dc
cvtsi2sd %ebp, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
xorpd %xmm0, %xmm0
testq %rbx, %rbx
je 0x2c12a
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0x2b4a0
subsd 0x8(%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
movq 0x10(%rbx), %rbx
jmp 0x2c0f5
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
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
testq %r14, %r14
je 0x2c412
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x2b273
movq 0x10(%r14), %r14
jmp 0x2c3f4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa143d(%rip), %r12     # 0xcd870
leaq 0x6c68d(%rip), %r15     # 0x98ac7
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x2c46b
movq (%r12), %r13
movq %rbx, %rdi
callq 0x2b47e
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
jmp 0x2c43c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 $0xc8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x693b5(%rip), %rdi     # 0x9584d
callq 0x4cdcf
leaq 0x70(%rsp), %r15
movsd %xmm0, 0x18(%r15)
leaq 0x693a7(%rip), %rdi     # 0x95856
callq 0x4cd35
movl %eax, 0x8(%r15)
leaq 0x693a1(%rip), %rdi     # 0x95860
callq 0x4cdcf
movsd %xmm0, 0x10(%r15)
leaq 0x69371(%rip), %rdi     # 0x95842
callq 0x4cf11
movl %eax, 0x4(%r15)
pushq $0xb
popq %r12
leaq 0x74200(%rip), %r13     # 0xa06e5
movq %rbx, 0x60(%rsp)
movq %rbx, %rdi
testq %rdi, %rdi
je 0x2c551
movq %rdi, 0x68(%rsp)
callq 0x2add8
movq %rax, %rbp
movq 0x60(%rsp), %rbx
testq %rbx, %rbx
je 0x2c53b
movq %rbx, %rdi
callq 0x2add8
movq %r12, %rcx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbp, %rdi
movq %rax, %rsi
callq 0x8591e
movq %r14, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x42e0
movq 0x10(%rbx), %rbx
jmp 0x2c504
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x4150
movq 0x68(%rsp), %rdi
movq 0x10(%rdi), %rdi
jmp 0x2c4ed
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x37da27(%rip), %rax    # 0x3a9fa4
cmpl $0x0, (%rax)
je 0x2c5af
movl 0x1c0(%r14), %eax
cmpl $0x2, %eax
pushq $0x1
popq %r12
cmovll %r12d, %eax
decl %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x2c5e1
cmpl $0x1, 0x18864(%r14,%rcx,4)
sbbl $-0x1, %r12d
incq %rcx
jmp 0x2c598
movl 0x1bc(%r14), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
imulq $0x340, %rcx, %rcx      # imm = 0x340
xorl %r12d, %r12d
cmpq %rax, %rcx
je 0x2c5e1
cmpl $0x1, 0x30f24(%r14,%rax)
sbbl $-0x1, %r12d
addq $0x340, %rax            # imm = 0x340
jmp 0x2c5c7
leaq 0x6aa73(%rip), %rdi     # 0x9705b
callq 0x4cf11
cmpl $0x4, %eax
jne 0x2c610
movq %rbx, %rdi
callq 0x2c3cc
leaq 0x69831(%rip), %rsi     # 0x95e32
movq %r15, %rdi
movl %eax, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, 0x10(%r14)
je 0x2c628
leaq 0x6c4b0(%rip), %rdi     # 0x98ace
callq 0x4d088
movq %rax, %r12
jmp 0x2c628
movsbl %bpl, %ebp
testq %rbx, %rbx
je 0x2c65f
cmpl $0x0, 0x10(%r14)
je 0x2c649
movq %rbx, %rdi
callq 0x2b47e
cltq
cmpl $0x0, (%r12,%rax,4)
je 0x2c659
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2b4ba
movq 0x10(%rbx), %rbx
jmp 0x2c62c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2c71e
testq %r8, %r8
je 0x2c70a
movq %r8, (%rdi)
movq -0x8(%rsi,%rax,8), %rcx
decq %rax
incq %rax
cmpl %edx, %eax
jge 0x2c749
movq %rcx, %rdi
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x2c730
movq (%rsi,%rax,8), %rcx
movq %rcx, 0x10(%rdi)
movq %rdi, %rcx
jmp 0x2c729
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq (%rsi), %rax
testq %rax, %rax
je 0x2c7e3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x2c77f
movq %rcx, %r13
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x2c771
jmp 0x2c782
xorl %r13d, %r13d
xorl %ebp, %ebp
testq %rax, %rax
je 0x2c7cb
movq %rax, %r12
movq %rax, %rdi
callq 0x2b47e
cmpl %ebx, %eax
je 0x2c7a2
movq 0x10(%r12), %rax
movq %r12, %rbp
jmp 0x2c784
leaq 0x10(%r13), %rax
testq %r13, %r13
cmoveq %r15, %rax
movq %r12, (%rax)
movq 0x10(%r12), %rax
testq %rbp, %rbp
je 0x2c7c3
movq %rax, 0x10(%rbp)
movq %r12, %r13
jmp 0x2c784
movq %rax, (%r14)
movq %r12, %r13
jmp 0x2c782
testq %r13, %r13
je 0x2c7d5
andq $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_O2/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
callq 0x2c3cc
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0x6c2e5(%rip), %rsi     # 0x98ae0
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %rcx
testq %rbx, %rbx
je 0x2c818
movq %rbx, (%rcx)
movq 0x10(%rbx), %rbx
addq $0x8, %rcx
jmp 0x2c806
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x2c850
movq %rbx, %rdi
callq 0x2aec7
movq %rax, %rcx
testq %r15, %r15
je 0x2c844
movq %rax, 0x10(%r15)
movq %r14, %rcx
movq 0x10(%rbx), %rbx
movq %rax, %r15
movq %rcx, %r14
jmp 0x2c828
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: bootstrap_sample_without_stratification
Instanceptr bootstrap_sample_without_stratification(Instanceptr list)
{
 /*!Last Changed 19.02.2005*/
 int size, *array, i;
 Instanceptr* instancearray, result, tmp, newinstance, current;
 size = data_size(list);
 array = bootstrap_array(size);
 instancearray = create_array_of_instances(list);
 result = copy_of_instance(instancearray[array[0]]);
 current = result;
 for (i = 1; i < size; i++)
  {
   tmp = instancearray[array[i]];
   newinstance = copy_of_instance(tmp);
   current->next = newinstance;
   current = newinstance;
  }
 safe_free(instancearray);
 safe_free(array);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x2c3cc
movl %eax, %ebp
movl %eax, %edi
callq 0x35c0c
movq %rax, %rbx
movq %r14, %rdi
callq 0x2c7e4
movq %rax, %r14
movslq (%rbx), %rax
movq (%r14,%rax,8), %rdi
callq 0x2aec7
movq %rax, %r15
movslq %ebp, %r12
pushq $0x1
popq %r13
movq %rax, %rbp
cmpq %r12, %r13
jge 0x2c8b7
movslq (%rbx,%r13,4), %rax
movq (%r14,%rax,8), %rdi
callq 0x2aec7
movq %rax, 0x10(%rbp)
incq %r13
jmp 0x2c899
movq %r14, %rdi
callq 0x34ff7
movq %rbx, %rdi
callq 0x34ff7
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist_according_partition
void divide_instancelist_according_partition(Instanceptr* parentlist, Instanceptr* list1, Instanceptr* list2, Partition p)
{
 /* Last Changed 21.09.2004*/
 int i = 0, *classassignments, classno;
 Instanceptr ptmp, pnext, next1 = NULL, next2 = NULL;
 classassignments = find_class_assignments(p);
 ptmp = (*parentlist);
 while (ptmp)
  {
   pnext = ptmp->next;
   classno = give_classno(ptmp);
   if (classassignments[classno] == LEFT)
    {
     if (!next1)
       *list1 = ptmp;
     else
       next1->next = ptmp;
     next1 = ptmp;
    }
   else
    {
     if (!next2)
       *list2 = ptmp;
     else
       next2->next = ptmp;
     next2 = ptmp;
    }
   ptmp = pnext;
   i++;
  }
 if (next1)
   next1->next = NULL;
 if (next2)
   next2->next = NULL;
 (*parentlist) = NULL;
 safe_free(classassignments);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x60(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x4dc2f
movq %rax, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq (%rbx), %r13
xorl %ebx, %ebx
xorl %ebp, %ebp
testq %r13, %r13
je 0x2c95e
movq 0x10(%r13), %r14
movq %r13, %rdi
callq 0x2b47e
cltq
movq 0x18(%rsp), %rcx
cmpl $0x0, (%rcx,%rax,4)
movq %rbp, %rax
cmoveq %rbx, %rax
movq %r15, %rcx
cmoveq %r12, %rcx
cmoveq %r13, %rbx
cmovneq %r13, %rbp
leaq 0x10(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq %r13, (%rdx)
movq %r14, %r13
jmp 0x2c919
testq %rbx, %rbx
je 0x2c968
andq $0x0, 0x10(%rbx)
testq %rbp, %rbp
je 0x2c972
andq $0x0, 0x10(%rbp)
movq 0x20(%rsp), %rax
andq $0x0, (%rax)
movq 0x18(%rsp), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist_according_to_soft_split
void divide_instancelist_according_to_soft_split(Instanceptr* parentlist, Instanceptr* list1, Instanceptr* list2, matrix w)
{
 Instanceptr ptmp, pnext, next1 = NULL, next2 = NULL;
 *list1 = NULL;
 *list2 = NULL;
 ptmp = (*parentlist);
 while (ptmp)
 {
  pnext = ptmp->next;
  if (linear_fit_value(w, ptmp) > 0)
   {
    if (!next1)
      *list1 = ptmp;
    else
      next1->next = ptmp;
    next1 = ptmp;
   }
  else
   {
    if (!next2)
      *list2 = ptmp;
    else
      next2->next = ptmp;
    next2 = ptmp;
   }
  ptmp = pnext;
 }
 if (next1)
   next1->next = NULL;
 if (next2)
   next2->next = NULL;
 (*parentlist) = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %r13
andq $0x0, (%rsi)
andq $0x0, (%rdx)
movq %rdi, (%rsp)
movq (%rdi), %rbp
xorl %r14d, %r14d
xorl %ebx, %ebx
testq %rbp, %rbp
je 0x2ca11
movq 0x10(%rbp), %r15
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rbp, %rdx
callq 0x6ce0c
ucomisd 0x69330(%rip), %xmm0    # 0x95d18
movq %rbx, %rax
cmovaq %r14, %rax
movq %r12, %rcx
cmovaq %r13, %rcx
cmovaq %rbp, %r14
cmovbeq %rbp, %rbx
leaq 0x10(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq %rbp, (%rdx)
movq %r15, %rbp
jmp 0x2c9c5
testq %r14, %r14
je 0x2ca1b
andq $0x0, 0x10(%r14)
testq %rbx, %rbx
je 0x2ca25
andq $0x0, 0x10(%rbx)
movq (%rsp), %rax
andq $0x0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist_according_centers
void divide_instancelist_according_centers(Instanceptr* parentlist, Instanceptr* list1, Instanceptr* list2, Instanceptr leftcenter, Instanceptr rightcenter, int quadratic)
{
 /*!Last Changed 03.04.2005*/
 /*!Last Changed 24.03.2005*/
 Instanceptr ptmp, pnext, next1 = NULL, next2 = NULL;
 CHILD_TYPE result;
 *list1 = NULL;
 *list2 = NULL;
 ptmp = (*parentlist);
 while (ptmp)
  {
   pnext = ptmp->next;
   if (quadratic)
     result = nearest_center_in_regression_tree(ptmp, QUADRATIC, leftcenter, rightcenter);
   else
     result = nearest_center_in_regression_tree(ptmp, LINEAR, leftcenter, rightcenter);
   if (result == LEFTCHILD)
    {
     if (!next1)
       *list1 = ptmp;
     else
       next1->next = ptmp;
     next1 = ptmp;
    }
   else
    {
     if (!next2)
       *list2 = ptmp;
     else
       next2->next = ptmp;
     next2 = ptmp;
    }
   ptmp = pnext;
  }
 if (next1)
   next1->next = NULL;
 if (next2)
   next2->next = NULL;
 (*parentlist) = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
andq $0x0, (%rsi)
movq %rdx, %r13
andq $0x0, (%rdx)
movq %rdi, 0x8(%rsp)
movq (%rdi), %rbp
xorl %r14d, %r14d
cmpl $0x1, %r9d
movl $0x0, %ebx
adcl $-0x3, %ebx
xorl %r15d, %r15d
testq %rbp, %rbp
je 0x2cac8
movq 0x10(%rbp), %r12
movq %rbp, %rdi
movl %ebx, %esi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x6c404
testl %eax, %eax
movq %r15, %rax
cmoveq %r14, %rax
movq %r13, %rcx
cmoveq 0x10(%rsp), %rcx
cmoveq %rbp, %r14
cmovneq %rbp, %r15
leaq 0x10(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq %rbp, (%rdx)
movq %r12, %rbp
jmp 0x2ca7e
testq %r14, %r14
je 0x2cad2
andq $0x0, 0x10(%r14)
testq %r15, %r15
je 0x2cadc
andq $0x0, 0x10(%r15)
movq 0x8(%rsp), %rax
andq $0x0, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist_according_to_split
void divide_instancelist_according_to_split(Instanceptr* parentlist, Instanceptr* list1, Instanceptr* list2, int fno, double split)
{
 /*!Last Changed 09.12.2004*/
 Instanceptr ptmp, pnext, next1 = NULL, next2 = NULL;
 ptmp = (*parentlist);
 while (ptmp)
  {
   pnext = ptmp->next;
   if (ptmp->values[fno].floatvalue <= split)
    {
     if (!next1)
       *list1 = ptmp;
     else
       next1->next = ptmp;
     next1 = ptmp;
    }
   else
    {
     if (!next2)
       *list2 = ptmp;
     else
       next2->next = ptmp;
     next2 = ptmp;
    }
   ptmp = pnext;
  }
 if (next1)
   next1->next = NULL;
 if (next2)
   next2->next = NULL;
 (*parentlist) = NULL;
}

// Assembly:
pushq %rbx
movq (%rdi), %r8
movslq %ecx, %rcx
xorl %r9d, %r9d
xorl %eax, %eax
testq %r8, %r8
je 0x2cb3e
movq (%r8), %r10
ucomisd (%r10,%rcx,8), %xmm0
movq %rsi, %r10
cmovbq %rdx, %r10
movq %r8, %r11
cmovbq %r9, %r11
cmovbq %rax, %r9
cmovbq %r8, %rax
leaq 0x10(%r9), %rbx
testq %r9, %r9
cmoveq %r10, %rbx
movq 0x10(%r8), %r9
movq %r8, (%rbx)
movq %r9, %r8
movq %r11, %r9
jmp 0x2cb00
testq %r9, %r9
je 0x2cb48
andq $0x0, 0x10(%r9)
testq %rax, %rax
je 0x2cb52
andq $0x0, 0x10(%rax)
andq $0x0, (%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist_one_vs_one_with_copy
void divide_instancelist_one_vs_one_with_copy(Instanceptr parentlist, Instanceptr* list, int positive, int negative)
{
 Instanceptr tmp, inst, next = NULL;
 tmp = parentlist;
 while (tmp)
  {
   if (give_classno(tmp) == positive)
    {
     inst = copy_of_instance(tmp);
     inst->values[current_dataset->classdefno].stringindex = 0;
     if (!next)
       *list = inst;
     else
       next->next = inst;
     next = inst;
    }
   else
     if (give_classno(tmp) == negative)
      {
       inst = copy_of_instance(tmp);
       inst->values[current_dataset->classdefno].stringindex = 1;
       if (!next)
         *list = inst;
       else
         next->next = inst;
       next = inst;
      }
   tmp = tmp->next;
  }
 if (next)
   next->next = NULL;
 else
   *list = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
xorl %r13d, %r13d
leaq 0xa0cf8(%rip), %r12     # 0xcd870
testq %r15, %r15
je 0x2cbe8
movq %r15, %rdi
callq 0x2b47e
movq %r15, %rdi
cmpl %r14d, %eax
jne 0x2cba6
callq 0x2aec7
movq (%rax), %rcx
movq (%r12), %rdx
movslq 0x1407128(%rdx), %rdx
andl $0x0, (%rcx,%rdx,8)
jmp 0x2cbcc
callq 0x2b47e
cmpl %ebp, %eax
jne 0x2cbdc
movq %r15, %rdi
callq 0x2aec7
movq (%rax), %rcx
movq (%r12), %rdx
movslq 0x1407128(%rdx), %rdx
movl $0x1, (%rcx,%rdx,8)
testq %r13, %r13
je 0x2cbd7
movq %rax, 0x10(%r13)
jmp 0x2cbdf
movq %rax, (%rbx)
jmp 0x2cbdf
movq %r13, %rax
movq 0x10(%r15), %r15
movq %rax, %r13
jmp 0x2cb78
leaq 0x10(%r13), %rax
testq %r13, %r13
cmoveq %rbx, %rax
andq $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist_one_vs_one
void divide_instancelist_one_vs_one(Instanceptr* parentlist, Instanceptr* list, int positive, int negative)
{
 Instanceptr ptmp, pnext, next1 = NULL, next = NULL;
 ptmp = (*parentlist);
 while (ptmp)
  {
   pnext = ptmp->next;
   if (give_classno(ptmp) == positive)
    {
     if (!next1)
       *list = ptmp;
     else
       next1->next = ptmp;
     next1 = ptmp;
    }
   else
     if (give_classno(ptmp) == negative)
      {
       if (!next1)
         *list = ptmp;
       else
         next1->next = ptmp;
       next1 = ptmp;
      }
     else
      {
       if (!next)
         *parentlist = ptmp;
       else
         next->next = ptmp;
       next = ptmp;
      }
   ptmp = pnext;
  }
 if (next1)
   next1->next = NULL;
 if (next)
   next->next = NULL;
 else
   *parentlist = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
movq (%rdi), %r12
xorl %ebp, %ebp
xorl %r13d, %r13d
testq %r12, %r12
je 0x2cc8a
movq 0x10(%r12), %rbx
movq %r12, %rdi
callq 0x2b47e
cmpl %r14d, %eax
jne 0x2cc4a
movq %r15, %rax
movq %r12, %rcx
jmp 0x2cc74
movq %r12, %rdi
callq 0x2b47e
cmpl 0xc(%rsp), %eax
movq %r13, %rdx
cmoveq %rbp, %rdx
movq 0x10(%rsp), %rax
cmoveq %r15, %rax
movq %rbp, %rcx
cmoveq %r12, %rcx
cmovneq %r12, %r13
movq %rdx, %rbp
leaq 0x10(%rbp), %rdx
testq %rbp, %rbp
cmoveq %rax, %rdx
movq %r12, (%rdx)
movq %rbx, %r12
movq %rcx, %rbp
jmp 0x2cc2b
testq %rbp, %rbp
je 0x2cc94
andq $0x0, 0x10(%rbp)
leaq 0x10(%r13), %rax
testq %r13, %r13
cmoveq 0x10(%rsp), %rax
andq $0x0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq