LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x3854e0(%rip), %r15    # 0x3b20b8
movslq 0xec(%r15), %r12
movq 0xf0(%r15), %rdi
leaq 0x1(%r12), %r14
leaq 0x4(,%r12,4), %rsi
movl %r14d, %edx
callq 0x3a0b4
movq %rax, 0xf0(%r15)
movl $0x0, (%rax,%r12,4)
movq 0xf8(%r15), %rdi
movq %r14, %rsi
movl %r14d, %edx
callq 0x3a0b4
movq %rax, 0xf8(%r15)
movb %bpl, (%rax,%r12)
movq 0x100(%r15), %rdi
leaq 0x8(,%r12,8), %rsi
movl %r14d, %edx
callq 0x3a0b4
movq %rax, 0x100(%r15)
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq 0x3b494
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_O3/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 0x383b97(%rip), %rax    # 0x3b20b8
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)
movaps 0x7a379(%rip), %xmm0    # 0xa88f0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x80(%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_O3/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 0x383ad2(%rip), %rcx    # 0x3b20b8
movslq 0x124(%rcx), %rax
testq %rax, %rax
jle 0x2e625
movq 0x128(%rcx), %rcx
shlq $0x5, %rax
leaq (%rax,%rax,2), %rdx
xorl %r8d, %r8d
xorl %eax, %eax
cmpl %edi, (%rcx,%r8)
jne 0x2e61b
xorl %r9d, %r9d
cmpl %esi, 0x20(%rcx,%r8)
sete %r9b
addl %r9d, %eax
addq $0x60, %r8
cmpq %r8, %rdx
jne 0x2e606
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7a27d(%rip), %xmm1    # 0xa88d8
addsd %xmm2, %xmm1
movsd 0x7a279(%rip), %xmm2    # 0xa88e0
divsd %xmm1, %xmm2
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movapd 0x7a289(%rip), %xmm1    # 0xa8900
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
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm3, %xmm1
cvttsd2si %xmm1, %eax
addl $0x50, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa6bc3(%rip), %r14     # 0xd5870
movq (%r14), %rax
movslq 0x1c0(%rax), %rdi
shlq $0x4, %rdi
leaq 0x79dea(%rip), %rsi     # 0xa8aac
movl $0x3, %edx
callq 0x3a0e1
movq (%r14), %rcx
movl 0x1c0(%rcx), %edx
xorl %edi, %edi
cmpl $0x2, %edx
jl 0x2ed35
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 0x2ed16
jp 0x2ed16
cmpl $0x3, 0x140713c(%rcx)
jne 0x2ed2d
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 0x2ecf1
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 0x3a0b4
// File: /workspace/github_c_makefile_star2_O3/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 0x2ee8a
movq %rdi, %r14
leaq 0x79d16(%rip), %r15     # 0xa8ac0
movl $0x30, %edi
movq %r15, %rsi
movl $0x5, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0xa6aaa(%rip), %r12     # 0xd5870
movq (%r12), %rax
movslq 0x1c0(%rax), %rdi
shlq $0x3, %rdi
movq %r15, %rsi
movl $0x6, %edx
callq 0x3a0e1
movq %rax, (%rbx)
movq (%r12), %rcx
cmpl $0x0, 0x1c0(%rcx)
jle 0x2ee36
xorl %eax, %eax
movl 0x1407128(%rcx), %edx
cmpq %rdx, %rax
jne 0x2ee13
cmpl $0x0, 0x10(%rcx)
movq (%rbx), %rcx
je 0x2ee16
movq (%r14), %rdx
movl (%rdx,%rax,8), %edx
movl %edx, (%rcx,%rax,8)
jmp 0x2ee23
movq (%rbx), %rcx
movq (%r14), %rdx
movsd (%rdx,%rax,8), %xmm0
movsd %xmm0, (%rcx,%rax,8)
incq %rax
movq (%r12), %rcx
movslq 0x1c0(%rcx), %rdx
cmpq %rdx, %rax
jl 0x2edf4
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq %rax, 0x28(%rbx)
cmpl $0x4, 0x140713c(%rcx)
jne 0x2ee8e
movslq 0x10(%rcx), %rdi
shlq $0x2, %rdi
leaq 0x79c68(%rip), %rsi     # 0xa8ac0
movl $0xf, %edx
callq 0x3a0e1
movq %rax, 0x8(%rbx)
movq (%r12), %rcx
cmpl $0x0, 0x10(%rcx)
jle 0x2ee96
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 0x2ee76
jmp 0x2ee96
xorl %ebx, %ebx
jmp 0x2ee96
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_O3/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 0xa69b8(%rip), %r14     # 0xd5870
movq (%r14), %rdi
movl 0x1c0(%rdi), %r15d
callq 0x1372c
leal 0x1(%rax), %edi
callq 0x15391
cmpl $0x2, %r15d
jl 0x2ef9a
leal -0x1(%r15), %ecx
movl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
movq %rsi, %rdi
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
cmpq %rcx, %rdi
jb 0x2eee6
incq %rsi
cmpq %rcx, %rsi
jne 0x2eee3
cmpl $0x2, %r15d
jl 0x2ef9a
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 0x2ef53
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
shrq $0x20, %rsi
leaq 0xa68bc(%rip), %rax     # 0xd5870
movq (%rax), %rcx
movl 0x1c0(%rcx), %r8d
leal -0x1(%r8), %eax
xorpd %xmm0, %xmm0
cmpl %esi, %eax
jne 0x2f00d
cmpl $0x2, %r8d
jl 0x2f0bb
movq (%rdx), %rax
movslq 0x1407128(%rcx), %rcx
movq (%rdi), %rdx
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rcx, %rdi
setge %r8b
movsd (%rax,%rdi,8), %xmm1
leaq (%rdx,%r8,8), %r8
mulsd (%r8,%rdi,8), %xmm1
addsd %xmm1, %xmm0
incq %rdi
cmpq %rdi, %rsi
jne 0x2efe3
jmp 0x2f0bb
cmpl $0x2, %r8d
jl 0x2f0bb
movq (%rdx), %rsi
movslq 0x1407128(%rcx), %r9
movq (%rdi), %r10
movl %eax, %eax
xorl %ebx, %ebx
xorl %r11d, %r11d
xorl %r14d, %r14d
cmpq %r9, %rbx
setge %r14b
leaq (%r10,%rbx,8), %r15
movsd (%r15,%r14,8), %xmm1
movslq %r11d, %r11
movq %rbx, %r14
movsd (%rsi,%r11,8), %xmm2
mulsd %xmm1, %xmm2
xorl %r15d, %r15d
cmpq %r9, %r14
setge %r15b
leaq (%r10,%r15,8), %r15
mulsd (%r15,%r14,8), %xmm2
addsd %xmm2, %xmm0
incq %r11
incq %r14
cmpq %rax, %r14
jb 0x2f045
incq %rbx
cmpq %rax, %rbx
jne 0x2f02b
cmpl $0x2, %r8d
jl 0x2f0bb
movslq 0x1407128(%rcx), %rcx
movq (%rdi), %rsi
movslq %r11d, %rdi
shlq $0x3, %rdi
addq (%rdx), %rdi
xorl %edx, %edx
xorl %r8d, %r8d
cmpq %rcx, %rdx
setge %r8b
movsd (%rdi,%rdx,8), %xmm1
leaq (%rsi,%r8,8), %r8
mulsd (%r8,%rdx,8), %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x2f096
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa67a1(%rip), %r14     # 0xd5870
movq (%r14), %rax
movl 0x1c0(%rax), %esi
decl %esi
movl $0x1, %edi
callq 0x3d79d
movq (%r14), %rsi
movslq 0x1c0(%rsi), %rcx
testq %rcx, %rcx
jle 0x2f123
movl 0x1407128(%rsi), %esi
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rdi, %rsi
je 0x2f11b
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 0x2f0fe
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa5a98(%rip), %rax     # 0xd5870
movq (%rax), %rcx
movl 0x1c0(%rcx), %eax
xorpd %xmm0, %xmm0
cmpl $0x2, %eax
jl 0x2fe28
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 0x2fdfb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x382174(%rip), %rax    # 0x3b1fa4
cmpl $0x0, (%rax)
leaq 0xa5a36(%rip), %rax     # 0xd5870
movq (%rax), %rax
je 0x2fe99
movl 0x1c0(%rax), %ecx
xorpd %xmm0, %xmm0
cmpl $0x2, %ecx
jl 0x2ff23
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 0x2fe63
jmp 0x2ff23
movslq 0x1bc(%rax), %rcx
testq %rcx, %rcx
jle 0x2ff24
addq $0x30f08, %rax          # imm = 0x30F08
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd 0x75667(%rip), %xmm1    # 0xa5520
movl (%rax), %r8d
cmpl $0x2, %r8d
je 0x2fefb
cmpl $0x1, %r8d
je 0x2fee5
testl %r8d, %r8d
jne 0x2ff15
movq (%rdi), %r8
movl (%r8,%rdx,8), %r8d
movq (%rsi), %r9
subl (%r9,%rdx,8), %r8d
xorps %xmm2, %xmm2
cvtsi2sd %r8d, %xmm2
jmp 0x2ff0d
movq (%rdi), %r8
movl (%r8,%rdx,8), %r8d
movq (%rsi), %r9
cmpl (%r9,%rdx,8), %r8d
je 0x2ff15
addsd %xmm1, %xmm0
jmp 0x2ff15
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 0x2feb9
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2ffa0
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rdi
movq 0x10(%rbx), %r14
callq 0x3a180
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2ff7b
callq 0x2ff55
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2ff89
callq 0x3a180
movq %rbx, %rdi
callq 0x3a180
movq %r14, %rbx
testq %r14, %r14
jne 0x2ff61
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x2eea5
movq %rax, %rbx
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x2ffd8
movq %rbx, %r15
movq %r14, %rdi
callq 0x2eea5
movq %rax, 0x10(%r15)
movq 0x10(%r14), %r14
movq %rax, %r15
testq %r14, %r14
jne 0x2ffc0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x30026
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorpd %xmm1, %xmm1
xorl %ebp, %ebp
movsd %xmm1, (%rsp)
incl %ebp
movq %rbx, %rdi
callq 0x2f35e
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x2fff2
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
divsd %xmm0, %xmm1
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3002a
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x30087
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 0x2f35e
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 0x3004a
addq $0x10, %rsp
popq %rbx
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3035a
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 0x2f12b
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x30336
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x303bc
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa54f8(%rip), %r12     # 0xd5870
leaq 0x787c8(%rip), %r15     # 0xa8b47
xorl %ebp, %ebp
movq (%r12), %r13
movq %rbx, %rdi
callq 0x2f33a
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 0x30381
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x75472(%rip), %rdi     # 0xa584d
callq 0x549ba
movsd %xmm0, 0x78(%rsp)
leaq 0x75469(%rip), %rdi     # 0xa5856
callq 0x54920
movl %eax, 0x68(%rsp)
leaq 0x75463(%rip), %rdi     # 0xa5860
callq 0x549ba
movsd %xmm0, 0x70(%rsp)
leaq 0x75433(%rip), %rdi     # 0xa5842
callq 0x54afc
movl %eax, 0x64(%rsp)
movq %rbx, 0x58(%rsp)
testq %rbx, %rbx
je 0x30490
leaq 0x60(%rsp), %r15
leaq 0x80353(%rip), %r12     # 0xb0781
movq 0x58(%rsp), %r13
movq %r13, %rdi
callq 0x2ec9f
movq %rax, %rbp
movq 0x58(%rsp), %rbx
movq %rbx, %rdi
callq 0x2ec9f
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbp, %rdi
movq %rax, %rsi
callq 0x93d00
movq %r14, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x42e0
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x30443
movl $0xa, %edi
movq %r14, %rsi
callq 0x4150
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x30433
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x381ae8(%rip), %rax    # 0x3b1fa4
cmpl $0x0, (%rax)
je 0x304ee
movl 0x1c0(%r14), %eax
movl $0x1, %r12d
cmpl $0x2, %eax
jl 0x30524
decl %eax
xorl %ecx, %ecx
cmpl $0x1, 0x18864(%r14,%rcx,4)
sbbl $-0x1, %r12d
incq %rcx
cmpq %rcx, %rax
jne 0x304d7
jmp 0x30524
movslq 0x1bc(%r14), %rax
testq %rax, %rax
jle 0x30521
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 0x30506
jmp 0x30524
xorl %r12d, %r12d
leaq 0x76b90(%rip), %rdi     # 0xa70bb
callq 0x54afc
cmpl $0x4, %eax
jne 0x3055e
xorl %edx, %edx
testq %rbx, %rbx
je 0x3054a
movq %rbx, %rax
incl %edx
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x3053f
leaq 0x758d9(%rip), %rsi     # 0xa5e2a
movq %r15, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, 0x10(%r14)
je 0x30576
leaq 0x785e2(%rip), %rdi     # 0xa8b4e
callq 0x54c89
movq %rax, %r12
jmp 0x30576
testq %rbx, %rbx
je 0x305b0
movsbl %bpl, %ebp
cmpl $0x0, 0x10(%r14)
je 0x30597
movq %rbx, %rdi
callq 0x2f33a
cltq
cmpl $0x0, (%r12,%rax,4)
je 0x305a7
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2f378
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x3057f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x30642
xorl %edx, %edx
movq %rax, %rcx
movq 0x10(%rax), %rax
movq %rdx, 0x10(%rcx)
movq %rcx, %rdx
testq %rax, %rax
jne 0x3062d
jmp 0x30644
xorl %ecx, %ecx
movq %rcx, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x30682
testq %r8, %r8
je 0x3066e
movq %r8, (%rdi)
cmpl %edx, %eax
jge 0x306af
movq -0x8(%rsi,%rax,8), %rdi
movl %edx, %ecx
movq %rdi, %rdx
movq %rdx, %rdi
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
jne 0x30693
movq (%rsi,%rax,8), %rdx
movq %rdx, 0x10(%rdi)
incq %rax
cmpq %rcx, %rax
jne 0x30690
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3073e
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
testq %rax, %rax
je 0x306e1
movq %rax, %r13
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x306d3
jmp 0x306e4
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %r12, %rdi
callq 0x2f33a
cmpl %ebx, %eax
jne 0x30716
leaq 0x10(%r13), %rax
testq %r13, %r13
cmoveq %r15, %rax
movq %r12, (%rax)
movq 0x10(%r12), %rax
testq %rbp, %rbp
je 0x3071d
movq %rax, 0x10(%rbp)
movq %r12, %r13
movq %rbp, %r12
jmp 0x30726
movq 0x10(%r12), %rax
jmp 0x30726
movq %rax, (%r14)
movq %r12, %r13
xorl %r12d, %r12d
movq %r12, %rbp
movq %rax, %r12
testq %rax, %rax
jne 0x306e6
testq %r13, %r13
je 0x3073e
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_O3/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:
testq %rdi, %rdi
je 0x30793
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
movq %rbx, %rax
movq 0x10(%rax), %rax
addq $0x8, %rdi
testq %rax, %rax
jne 0x3075b
leaq 0x783f1(%rip), %rsi     # 0xa8b60
movl $0x4, %edx
callq 0x3a0e1
testq %rbx, %rbx
je 0x30791
movq %rax, %rcx
movq %rbx, (%rcx)
movq 0x10(%rbx), %rbx
addq $0x8, %rcx
testq %rbx, %rbx
jne 0x30781
popq %rbx
retq
leaq 0x783c6(%rip), %rsi     # 0xa8b60
xorl %edi, %edi
movl $0x4, %edx
jmp 0x3a0e1
// File: /workspace/github_c_makefile_star2_O3/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 0x307e5
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x2ed8f
movq %rax, %rcx
testq %r15, %r15
je 0x307d0
movq %rcx, 0x10(%r15)
movq %r14, %rax
movq 0x10(%rbx), %rbx
movq %rax, %r14
movq %rcx, %r15
testq %rbx, %rbx
jne 0x307b9
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x3080b
movq %r14, %rax
incl %ebp
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x30800
movl %ebp, %edi
callq 0x3ae94
movq %rax, %rbx
movq %r14, %rdi
callq 0x3074d
movq %rax, %r14
movslq (%rbx), %rax
movq (%r14,%rax,8), %rdi
callq 0x2ed8f
movq %rax, %r15
cmpl $0x2, %ebp
jl 0x3085c
movl %ebp, %r12d
movl $0x1, %r13d
movq %r15, %rbp
movslq (%rbx,%r13,4), %rax
movq (%r14,%rax,8), %rdi
callq 0x2ed8f
movq %rax, 0x10(%rbp)
incq %r13
movq %rax, %rbp
cmpq %r13, %r12
jne 0x30840
movq %r14, %rdi
callq 0x3a180
movq %rbx, %rdi
callq 0x3a180
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_O3/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, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x60(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x55918
movq %rax, %rdi
movq (%rbx), %r13
testq %r13, %r13
je 0x30931
movq %rbx, 0x18(%rsp)
xorl %ebp, %ebp
xorl %ebx, %ebx
movq %r14, 0x20(%rsp)
movq 0x10(%r13), %r15
movq %r12, %r14
movq %rdi, %r12
movq %r13, %rdi
callq 0x2f33a
movq %r12, %rdi
movq %r14, %r12
cltq
cmpl $0x0, (%rdi,%rax,4)
movq %rbp, %rax
cmoveq %rbx, %rax
movq 0x20(%rsp), %rcx
cmoveq %r14, %rcx
cmoveq %r13, %rbx
cmovneq %r13, %rbp
leaq 0x10(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq %r13, (%rdx)
movq %r15, %r13
testq %r15, %r15
jne 0x308c6
testq %rbx, %rbx
je 0x3091f
movq $0x0, 0x10(%rbx)
testq %rbp, %rbp
movq 0x18(%rsp), %rbx
je 0x30931
movq $0x0, 0x10(%rbp)
movq $0x0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/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
xorl %eax, %eax
movq %rax, (%rsi)
movq %rax, (%rdx)
movq (%rdi), %rbp
testq %rbp, %rbp
je 0x309f7
movq %r8, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, (%rsp)
xorl %ebx, %ebx
xorl %r14d, %r14d
movq %rcx, 0x8(%rsp)
movq 0x10(%rbp), %rax
movq %rax, 0x10(%rsp)
movq %rcx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x76f0b
ucomisd 0x75365(%rip), %xmm0    # 0xa5d08
movq %rbx, %rax
cmovaq %r14, %rax
movq %r13, %rcx
cmovaq %r15, %rcx
cmovaq %rbp, %r14
cmovbeq %rbp, %rbx
leaq 0x10(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq 0x8(%rsp), %rcx
movq %rbp, (%rdx)
movq 0x10(%rsp), %rax
movq %rax, %rbp
testq %rax, %rax
jne 0x30984
testq %r14, %r14
je 0x309e6
movq $0x0, 0x10(%r14)
testq %rbx, %rbx
movq (%rsp), %rdi
je 0x309f7
movq $0x0, 0x10(%rbx)
movq $0x0, (%rdi)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
xorl %r14d, %r14d
movq %r14, (%rsi)
movq %r14, (%rdx)
movq (%rdi), %rbp
testq %rbp, %rbp
je 0x30ac8
movq %r8, %r13
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
cmpl $0x1, %r9d
movl $0x0, %eax
adcl $-0x3, %eax
movl %eax, 0xc(%rsp)
xorl %r15d, %r15d
movq %rcx, 0x18(%rsp)
movq 0x10(%rbp), %rax
movq %rax, 0x20(%rsp)
movq %rbp, %rdi
movl 0xc(%rsp), %esi
movq %rcx, %rdx
movq %r13, %rcx
callq 0x76460
testl %eax, %eax
movq %r14, %rax
cmoveq %r15, %rax
movq %rbx, %rcx
cmoveq %r12, %rcx
cmoveq %rbp, %r15
cmovneq %rbp, %r14
leaq 0x10(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq 0x18(%rsp), %rcx
movq %rbp, (%rdx)
movq 0x20(%rsp), %rax
movq %rax, %rbp
testq %rax, %rax
jne 0x30a56
testq %r15, %r15
je 0x30ab6
movq $0x0, 0x10(%r15)
testq %r14, %r14
movq 0x10(%rsp), %rdi
je 0x30ac8
movq $0x0, 0x10(%r14)
movq $0x0, (%rdi)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq (%rdi), %r8
testq %r8, %r8
je 0x30b45
pushq %rbx
movslq %ecx, %r9
xorl %eax, %eax
xorl %ecx, %ecx
movq (%r8), %r10
ucomisd (%r10,%r9,8), %xmm0
movq %rsi, %r10
cmovbq %rdx, %r10
movq %rcx, %r11
movq %r8, %rcx
cmovbq %r11, %rcx
cmovbq %rax, %r11
cmovbq %r8, %rax
leaq 0x10(%r11), %rbx
testq %r11, %r11
cmoveq %r10, %rbx
movq 0x10(%r8), %r10
movq %r8, (%rbx)
movq %r10, %r8
testq %r10, %r10
jne 0x30aee
testq %rcx, %rcx
je 0x30b37
movq $0x0, 0x10(%rcx)
testq %rax, %rax
je 0x30b44
movq $0x0, 0x10(%rax)
popq %rbx
movq $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %rsi, %rbx
testq %rdi, %rdi
je 0x30bed
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %r15
xorl %r13d, %r13d
leaq 0xa4cfa(%rip), %r12     # 0xd5870
movq %r15, %rdi
callq 0x2f33a
movq %r15, %rdi
cmpl %r14d, %eax
jne 0x30ba2
callq 0x2ed8f
movq (%rax), %rcx
movq (%r12), %rdx
movslq 0x1407128(%rdx), %rdx
movl $0x0, (%rcx,%rdx,8)
jmp 0x30bc8
callq 0x2f33a
cmpl %ebp, %eax
jne 0x30bd9
movq %r15, %rdi
callq 0x2ed8f
movq (%rax), %rcx
movq (%r12), %rdx
movslq 0x1407128(%rdx), %rdx
movl $0x1, (%rcx,%rdx,8)
testq %r13, %r13
je 0x30bd3
movq %rax, 0x10(%r13)
jmp 0x30bd6
movq %rax, (%rbx)
movq %rax, %r13
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x30b76
leaq 0x10(%r13), %rax
testq %r13, %r13
cmovneq %rax, %rbx
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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)
movq (%rdi), %r12
testq %r12, %r12
je 0x30ca5
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x10(%r12), %rbx
movq %r12, %rdi
callq 0x2f33a
cmpl %r14d, %eax
jne 0x30c4e
movq %rbp, %rax
movq %r15, %rcx
movq %r12, %rbp
jmp 0x30c72
movq %r12, %rdi
callq 0x2f33a
cmpl 0xc(%rsp), %eax
movq %r13, %rax
cmoveq %rbp, %rax
movq 0x10(%rsp), %rcx
cmoveq %r15, %rcx
cmoveq %r12, %rbp
cmovneq %r12, %r13
leaq 0x10(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq %r12, (%rdx)
movq %rbx, %r12
testq %rbx, %rbx
jne 0x30c31
testq %rbp, %rbp
je 0x30c95
movq $0x0, 0x10(%rbp)
leaq 0x10(%r13), %rax
testq %r13, %r13
movq 0x10(%rsp), %rdi
cmovneq %rax, %rdi
movq $0x0, (%rdi)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist_one_vs_rest
void divide_instancelist_one_vs_rest(Instanceptr* parentlist, Instanceptr* list1, Instanceptr* list2, int positive)
{
 /*!Last Changed 07.01.2004*/
 Instanceptr ptmp, pnext, next1 = NULL, next2 = NULL;
 ptmp = (*parentlist);
 while (ptmp)
  {
   pnext = ptmp->next;
   if (give_classno(ptmp) == positive)
    {
     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 (%rdi), %r12
testq %r12, %r12
je 0x30dcd
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, 0x8(%rsp)
xorl %r13d, %r13d
xorl %ebx, %ebx
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movq %r12, %rdi
callq 0x2f33a
cmpl %r14d, %eax
movq %r13, %rax
cmoveq %rbx, %rax
movq %r15, %r8
cmoveq %rbp, %r8
cmoveq %r12, %rbx
cmovneq %r12, %r13
leaq 0x10(%rax), %rdi
testq %rax, %rax
cmoveq %r8, %rdi
movq %r12, (%rdi)
movq 0x10(%rsp), %rax
movq %rax, %r12
testq %rax, %rax
jne 0x30d68
testq %rbx, %rbx
je 0x30dbb
movq $0x0, 0x10(%rbx)
testq %r13, %r13
movq 0x8(%rsp), %rdi
je 0x30dcd
movq $0x0, 0x10(%r13)
movq $0x0, (%rdi)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq