LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmcache.c
// Function: empty_cache
Cacheptr empty_cache(int l, int size)
{
	/*Last Changed 26.04.2005*/
	Cacheptr result;
	result = safemalloc(sizeof(Cache), "empty_cache", 2);
	result->head = (Cachenodeptr) safecalloc(l, sizeof(Cachenode), "empty_cache", 3);	
	result->size = size / sizeof(double);
	result->size -= l * sizeof(Cachenode) / sizeof(double);
	result->lru_head.next = &(result->lru_head);
	result->lru_head.prev = &(result->lru_head);
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
leaq 0x1dfe7(%rip), %r14     # 0xaea9a
movl $0x30, %edi
movq %r14, %rsi
movl $0x2, %edx
callq 0x390f5
movq %rax, %r15
movslq %ebp, %r12
movl $0x20, %esi
movq %r12, %rdi
movq %r14, %rdx
movl $0x3, %ecx
callq 0x39210
movq %rax, (%r15)
sarl $0x3, %ebx
shll $0x2, %r12d
subl %r12d, %ebx
movl %ebx, 0x2c(%r15)
leaq 0x8(%r15), %rax
movq %rax, 0x10(%r15)
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmcache.c
// Function: free_cache
void free_cache(Cacheptr c)
{
	/*Last Changed 26.04.2005*/
	Cachenodeptr h;
	for (h = c->lru_head.next; h != &(c->lru_head); h = h->next)
		 safe_free(h->data);
	safe_free(c->head);
	safe_free(c);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r14, %r15
je 0x90b2d
movq 0x10(%r15), %rdi
callq 0x39194
movq 0x8(%r15), %r15
jmp 0x90b19
movq (%rbx), %rdi
callq 0x39194
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmcache.c
// Function: lru_insert
void lru_insert(Cacheptr c, Cachenodeptr h)
{
	/*Last Changed 26.04.2005*/
	h->next = &(c->lru_head);
	h->prev = c->lru_head.prev;
	h->prev->next = h;
	h->next->prev = h;
}

// Assembly:
leaq 0x8(%rdi), %rax
movq %rax, 0x8(%rsi)
movq 0x8(%rdi), %rax
movq %rax, (%rsi)
movq %rsi, 0x8(%rax)
movq 0x8(%rsi), %rax
movq %rsi, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmcache.c
// Function: get_data
int get_data(Cacheptr c, int index, double **data, int len)
{
	/*Last Changed 26.04.2005*/
	int more;
	Cachenodeptr h, old;
 h = &(c->head[index]);
	if (h->len) 
		 lru_delete(h);
	more = len - h->len;
	if (more > 0)
	 {
		 while (c->size < more)
			 {
		  	old = c->lru_head.next;
			  lru_delete(old);
			  safe_free(old->data);
			  c->size += old->len;
			  old->data = NULL;
			  old->len = 0;
			 }
		 h->data = (double *)alloc(h->data, sizeof(double) * len, len);
		 c->size -= more;
		 swap_int(&(h->len), &len);
	 }
	lru_insert(c, h);
	*data = h->data;
	return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rdi, %r14
movl %ecx, 0x4(%rsp)
movq (%rdi), %rax
movslq %esi, %rcx
shlq $0x5, %rcx
leaq (%rax,%rcx), %r13
movl 0x18(%rax,%rcx), %edx
testl %edx, %edx
je 0x90bb0
movq (%r13), %rsi
movq 0x8(%r13), %rdi
movq %rdi, 0x8(%rsi)
movq 0x8(%r13), %rdi
movq %rsi, (%rdi)
subl %edx, %ebp
jle 0x90c38
leaq (%rax,%rcx), %r15
addq $0x18, %r15
cmpl %ebp, 0x2c(%r14)
jge 0x90c0c
movq 0x10(%r14), %r12
movq (%r12), %rax
movq 0x8(%r12), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%r12), %rcx
movq %rax, (%rcx)
movq 0x10(%r12), %rdi
callq 0x39194
movl 0x2c(%r14), %eax
addl 0x18(%r12), %eax
movl %eax, 0x2c(%r14)
movq $0x0, 0x10(%r12)
movl $0x0, 0x18(%r12)
cmpl %ebp, %eax
jl 0x90bc6
movq 0x10(%r13), %rdi
leaq 0x4(%rsp), %r12
movslq (%r12), %rdx
movq %rdx, %rsi
shlq $0x3, %rsi
callq 0x390c8
movq %rax, 0x10(%r13)
subl %ebp, 0x2c(%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0x395a3
leaq 0x8(%r14), %rax
movq %rax, 0x8(%r13)
movq 0x8(%r14), %rax
movq %rax, (%r13)
movq %r13, 0x8(%rax)
movq 0x8(%r13), %rax
movq %r13, (%rax)
movq 0x10(%r13), %rax
movq %rax, (%rbx)
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmcache.c
// Function: cache_swap_index
void cache_swap_index(Cacheptr c, int i, int j)
{
	/*Last Changed 26.04.2005*/
	Cachenodeptr h;
	double* tmp;
	if (i == j) 
		 return;
	if (c->head[i].len) 
		 lru_delete(&(c->head[i]));
	if (c->head[j].len) 
		 lru_delete(&(c->head[j]));
	tmp = c->head[i].data;
 c->head[i].data = c->head[j].data;
	c->head[j].data = tmp;
	swap_int(&(c->head[i].len), &(c->head[j].len));
	if (c->head[i].len) 
		 lru_insert(c, &(c->head[i]));
	if (c->head[j].len) 
		 lru_insert(c, &(c->head[j]));
	if (i > j) 
		 swap_int(&i, &j);
	for (h = c->lru_head.next; h != &(c->lru_head); h = h->next)
	 {
 		if (h->len > i)
			 {
		  	if (h->len > j)
				   swap_double(&(h->data[i]), &(h->data[j]));
			  else
					 {
   				lru_delete(h);
		   		safe_free(h->data);
				   c->size += h->len;
				   h->data = NULL;
				   h->len = 0;
					 }
			 }
	 }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
cmpl %edx, %esi
jne 0x90c8c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rbx
movq (%rdi), %rax
movslq %esi, %rcx
shlq $0x5, %rcx
cmpl $0x0, 0x18(%rax,%rcx)
je 0x90cb6
leaq (%rax,%rcx), %rsi
movq (%rsi), %rdi
movq 0x8(%rsi), %r8
movq %r8, 0x8(%rdi)
movq 0x8(%rsi), %rsi
movq %rdi, (%rsi)
movslq %edx, %rdx
shlq $0x5, %rdx
cmpl $0x0, 0x18(%rax,%rdx)
je 0x90cda
leaq (%rax,%rdx), %rsi
movq (%rsi), %rdi
movq 0x8(%rsi), %r8
movq %r8, 0x8(%rdi)
movq 0x8(%rsi), %rsi
movq %rdi, (%rsi)
leaq (%rax,%rcx), %rdi
addq $0x18, %rdi
movq -0x8(%rdi), %rcx
leaq 0x18(%rax,%rdx), %rsi
movq -0x8(%rsi), %rax
movq %rax, -0x8(%rdi)
movq %rcx, -0x8(%rsi)
callq 0x395a3
movq (%rbx), %rcx
movslq 0xc(%rsp), %rax
movq %rax, %rdx
shlq $0x5, %rdx
cmpl $0x0, 0x18(%rcx,%rdx)
je 0x90d2f
addq %rcx, %rdx
leaq 0x8(%rbx), %rsi
movq %rsi, 0x8(%rdx)
movq 0x8(%rbx), %rsi
movq %rsi, (%rdx)
movq %rdx, 0x8(%rsi)
movq 0x8(%rdx), %rsi
movq %rdx, (%rsi)
movslq 0x8(%rsp), %rdx
movq %rdx, %rsi
shlq $0x5, %rsi
cmpl $0x0, 0x18(%rcx,%rsi)
je 0x90d5f
addq %rsi, %rcx
leaq 0x8(%rbx), %rsi
movq %rsi, 0x8(%rcx)
movq 0x8(%rbx), %rsi
movq %rsi, (%rcx)
movq %rcx, 0x8(%rsi)
movq 0x8(%rcx), %rsi
movq %rcx, (%rsi)
cmpl %edx, %eax
jle 0x90d72
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x395a3
leaq 0x8(%rbx), %r14
movq 0x10(%rbx), %r15
cmpq %r14, %r15
je 0x90c82
movl 0x18(%r15), %ecx
movslq 0xc(%rsp), %rax
cmpl %eax, %ecx
jle 0x90dde
movslq 0x8(%rsp), %rdx
cmpl %edx, %ecx
jle 0x90dac
movq 0x10(%r15), %rcx
leaq (%rcx,%rax,8), %rdi
leaq (%rcx,%rdx,8), %rsi
callq 0x395ac
jmp 0x90dde
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%r15), %rcx
movq %rax, (%rcx)
movq 0x10(%r15), %rdi
callq 0x39194
movl 0x18(%r15), %eax
addl %eax, 0x2c(%rbx)
movq $0x0, 0x10(%r15)
movl $0x0, 0x18(%r15)
movq 0x8(%r15), %r15
jmp 0x90d7a
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmkernel.c
// Function: kernel_swap_index
void kernel_swap_index(Kernelptr k, int i, int j)
{
	/*Last Changed 26.04.2005*/
	Svm_nodeptr tmp;
	tmp = k->x[i];
	k->x[i] = k->x[j];
	k->x[j] = tmp;
	if (k->x_square != NULL) 
		 swap_double(&(k->x_square[i]), &(k->x_square[j]));
}

// Assembly:
movq (%rdi), %r8
movslq %esi, %rax
movq (%r8,%rax,8), %rsi
movslq %edx, %rcx
movq (%r8,%rcx,8), %rdx
movq %rdx, (%r8,%rax,8)
movq (%rdi), %rdx
movq %rsi, (%rdx,%rcx,8)
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x90e16
leaq (%rdx,%rax,8), %rdi
leaq (%rdx,%rcx,8), %rsi
jmp 0x395ac
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmkernel.c
// Function: dot
double dot(Svm_nodeptr px, Svm_nodeptr py)
{
	/*Last Changed 26.04.2005*/
	double sum = 0;
	while (px->index != -1 && py->index != -1)
	 {
 		if (px->index == py->index)
			 {
		  	sum += px->value * py->value;
		  	px++;
			  py++;
			 }
		 else
			 {
		  	if (px->index > py->index)
			  	 py++;
			  else
				   px++;
			 }			
	}
	return sum;
}

// Assembly:
movl (%rdi), %eax
xorpd %xmm0, %xmm0
cmpl $-0x1, %eax
je 0x90e51
movl (%rsi), %ecx
cmpl $-0x1, %ecx
je 0x90e51
cmpl %ecx, %eax
jne 0x90e41
movsd 0x8(%rdi), %xmm1
mulsd 0x8(%rsi), %xmm1
addsd %xmm1, %xmm0
addq $0x10, %rdi
jmp 0x90e43
jle 0x90e49
addq $0x10, %rsi
jmp 0x90e4d
addq $0x10, %rdi
movl (%rdi), %eax
jmp 0x90e1d
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmkernel.c
// Function: kernel_function
double kernel_function(Kernelptr k, int i, int j)
{
	/*Last Changed 26.04.2005*/
	switch (k->kernel_type)
	 {
	  case    KLINEAR :return kernel_linear(k, i, j);
				                break;
	  case    KPOLY   :return kernel_poly(k, i, j);
				                break;
			case    KRBF    :return kernel_rbf(k, i, j);
				                break;
			case    KSIGMOID:return kernel_sigmoid(k, i, j);
				                break;
   case KPREDEFINED:return kernel_predefined(k, i, j);
                    break;
			default         :printf(m1232, k->kernel_type);
                 return 0;
				             break;
	 }
}

// Assembly:
movl 0x10(%rdi), %eax
cmpq $0x4, %rax
ja 0x910ac
leaq 0x1da59(%rip), %rcx     # 0xaeaa8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x90e52
leaq 0x4180c(%rip), %rax     # 0xd2870
movq (%rax), %rax
movq 0x1407210(%rax), %rax
movq 0x8(%rax), %rax
movq (%rdi), %rcx
movslq %esi, %rsi
movq (%rcx,%rsi,8), %rsi
cvttsd2si 0x8(%rsi), %esi
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
cvttsd2si 0x8(%rcx), %ecx
movslq %esi, %rdx
movq (%rax,%rdx,8), %rax
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
retq
jmp 0x90f14
jmp 0x90f98
jmp 0x90ea5
pushq %rax
leaq 0x1da1c(%rip), %rdi     # 0xaead0
movl %eax, %esi
xorl %eax, %eax
callq 0x4030
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmkernel.c
// Function: kernel_function_normalized
double kernel_function_normalized(Kernelptr k, int i, int j)
{
 double Kxx, Kyy;
 Kxx = kernel_function(k, i, i);
 Kyy = kernel_function(k, j, j);
 if (Kxx != 0 && Kyy != 0)
   return kernel_function(k, i, j) / sqrt(Kxx * Kyy);
 return kernel_function(k, i, j); 
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edx
callq 0x9103f
movsd %xmm0, (%rsp)
movq %r14, %rdi
movl %ebx, %esi
movl %ebx, %edx
callq 0x9103f
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x9103f
movsd (%rsp), %xmm2
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jne 0x91113
jnp 0x9114f
movsd 0x8(%rsp), %xmm3
ucomisd %xmm0, %xmm3
jne 0x91121
jnp 0x9114f
mulsd %xmm3, %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jb 0x91138
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
jmp 0x9114b
movapd %xmm2, %xmm0
movsd %xmm1, (%rsp)
callq 0x4300
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmkernel.c
// Function: empty_kernel
Kernelptr empty_kernel(int l, Svm_node** x, int kernel_type, int degree, double gamma, double coef0)
{
	/*Last Changed 26.04.2005*/
	Kernelptr result;
	int i;
	result = safemalloc(sizeof(Kernel), "empty_kernel", 3);
	result->coef0 = coef0;
	result->degree = degree;
	result->gamma = gamma;
	result->kernel_type = kernel_type;
	result->x = safemalloc(sizeof(Svm_nodeptr) * l, "empty_kernel", 8);
	memcpy(result->x, x, sizeof(Svm_nodeptr) * l);
	if (kernel_type == KRBF)
	 {
		 result->x_square = safemalloc(sizeof(double) * l, "empty_kernel", 12);
			for (i = 0; i < l; i++)
				 result->x_square[i] = dot(x[i], x[i]);
	 }
	else
		 result->x_square = NULL;
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movl %ecx, %r12d
movl %edx, %r15d
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1d972(%rip), %r13     # 0xaeafa
movl $0x28, %edi
movq %r13, %rsi
movl $0x3, %edx
callq 0x390f5
movq %rax, %r14
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movl %r12d, 0x14(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movl %r15d, 0x10(%rax)
movslq %ebp, %r12
shlq $0x3, %r12
movq %r12, %rdi
movq %r13, %rsi
movl $0x8, %edx
callq 0x390f5
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4310
cmpl $0x2, %r15d
jne 0x91263
leaq 0x1d90a(%rip), %rsi     # 0xaeafa
movq %r12, %rdi
movl $0xc, %edx
callq 0x390f5
movq %rax, 0x8(%r14)
testl %ebp, %ebp
jle 0x9126b
movl %ebp, %ecx
xorl %edx, %edx
movq (%rbx,%rdx,8), %rsi
movl (%rsi), %r8d
xorpd %xmm0, %xmm0
cmpl $-0x1, %r8d
je 0x91254
movq %rsi, %rdi
movl (%rsi), %r9d
cmpl $-0x1, %r9d
je 0x91254
cmpl %r9d, %r8d
jne 0x9123f
movsd 0x8(%rdi), %xmm1
mulsd 0x8(%rsi), %xmm1
addsd %xmm1, %xmm0
addq $0x10, %rdi
jmp 0x91241
jle 0x91247
addq $0x10, %rsi
jmp 0x9124b
addq $0x10, %rdi
movl (%rdi), %r8d
cmpl $-0x1, %r8d
jne 0x9121d
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rcx, %rdx
jne 0x91209
jmp 0x9126b
movq $0x0, 0x8(%r14)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmkernel.c
// Function: free_kernel
void free_kernel(Kernelptr k)
{
	/*Last Changed 26.04.2005*/
	safe_free(k->x);
	if (k->kernel_type == KRBF)
  	safe_free(k->x_square);
 safe_free(k);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x39194
cmpl $0x2, 0x10(%rbx)
jne 0x91298
movq 0x8(%rbx), %rdi
callq 0x39194
movq %rbx, %rdi
popq %rbx
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmkernel.c
// Function: k_function_normalized
double k_function_normalized(Svm_nodeptr x, Svm_nodeptr y, Svm_parameter param)
{
 double Kxx, Kyy;
 Kxx = k_function(x, x, param);
 Kyy = k_function(y, y, param);
 if (Kxx != 0 && Kyy != 0)
   return k_function(x, y, param) / sqrt(Kxx * Kyy);
 return k_function(x, y, param);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x90(%rsp), %r15
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq %r14, %rsi
callq 0x912a1
movsd %xmm0, 0x60(%rsp)
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x912a1
movsd %xmm0, 0x68(%rsp)
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x912a1
movsd 0x60(%rsp), %xmm1
movapd %xmm0, %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x9152d
jnp 0x9156b
movsd 0x68(%rsp), %xmm3
ucomisd %xmm0, %xmm3
jne 0x9153b
jnp 0x9156b
mulsd %xmm3, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x91552
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x91567
movapd %xmm1, %xmm0
movsd %xmm2, 0x60(%rsp)
callq 0x4300
movsd 0x60(%rsp), %xmm2
divsd %xmm0, %xmm2
movapd %xmm2, %xmm0
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmprepare.c
// Function: prepare_svm_problem
void prepare_svm_problem(Svm_problemptr prob, SVM_TYPE probtype, Instanceptr data, Partition p)
{
 /*Last Changed 27.05.2005*/
	int i = 0, *assignments;
	Instanceptr tmp;
	if (probtype == TWO_CLASS)
	 {
			assignments = find_class_assignments(p);
		 prob->nr_class = 2;
	 }
	else
  	prob->nr_class = current_dataset->classno;
	prob->l = data_size(data);
	prob->x = safemalloc(prob->l * sizeof(Svm_nodeptr), "prepare_svm_parameters", 11);
	prob->y = safemalloc(prob->l * sizeof(double), "prepare_svm_parameters", 12);
	tmp = data;
	while (tmp)
	 {
		 if (in_list(probtype, 2, C_SVC, NU_SVC))
		   prob->y[i] = give_classno(tmp);
			else
				 if (probtype == TWO_CLASS)
							prob->y[i] = assignments[give_classno(tmp)];
					else
  				 prob->y[i] = give_regressionvalue(tmp);
			prob->x[i] = instance_to_svmnode(tmp);
		 tmp = tmp->next;
			i++;
	 }
	if (probtype == TWO_CLASS)
			safe_free(assignments);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
cmpl $0x5, %esi
jne 0x915bd
leaq 0x50(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movupd (%rax), %xmm0
movupd %xmm0, (%rsp)
movl $0x2, %ebp
callq 0x5442f
movq %rax, %r12
jmp 0x915ca
leaq 0x412ac(%rip), %rax     # 0xd2870
movq (%rax), %rax
movl 0x10(%rax), %ebp
movl %ebp, 0x18(%r15)
movq %r14, %rdi
callq 0x2fa14
movl %eax, (%r15)
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0x1d520(%rip), %r13     # 0xaeb07
movq %r13, %rsi
movl $0xb, %edx
callq 0x390f5
movq %rax, 0x10(%r15)
movslq (%r15), %rdi
shlq $0x3, %rdi
movq %r13, %rsi
movl $0xc, %edx
callq 0x390f5
movq %rax, 0x8(%r15)
testq %r14, %r14
je 0x91685
xorl %r13d, %r13d
movl %ebx, %edi
movl $0x2, %esi
xorl %edx, %edx
movl $0x1, %ecx
xorl %eax, %eax
callq 0x39a80
movq %r14, %rdi
testl %eax, %eax
je 0x91642
callq 0x2eaca
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
jmp 0x9165e
cmpl $0x5, %ebx
jne 0x91659
callq 0x2eaca
cltq
xorps %xmm0, %xmm0
cvtsi2sdl (%r12,%rax,4), %xmm0
jmp 0x9165e
callq 0x2eaee
movq 0x8(%r15), %rax
movsd %xmm0, (%rax,%r13)
movq %r14, %rdi
callq 0x2e3eb
movq 0x10(%r15), %rcx
movq %rax, (%rcx,%r13)
movq 0x10(%r14), %r14
addq $0x8, %r13
testq %r14, %r14
jne 0x91618
cmpl $0x5, %ebx
jne 0x916a0
movq %r12, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmprepare.c
// Function: prepare_svm_parameters
void prepare_svm_parameters(Svm_parameterptr param, SVM_TYPE probtype)
{
	/*Last Changed 02.05.2005*/
	param->cache_size = get_parameter_i("svmcache");
	param->C = get_parameter_f("svmC");
	param->coef0 = get_parameter_f("svmcoef0");
	param->degree = get_parameter_i("svmdegree");
	param->eps = 0.001;
	param->gamma = get_parameter_f("svmgamma");
 if (current_dataset->storetype == STORE_KERNEL)
   param->kernel_type = KPREDEFINED;
 else
	  param->kernel_type = get_parameter_l("kerneltype");
	param->nu = get_parameter_f("svmnu");
	param->p = get_parameter_f("svmepsilon");
	param->shrinking = 1;
	if (probtype == TWO_CLASS)
		 probtype = C_SVC;
	param->svm_type = probtype;
	param->cweights = (double *) get_parameter_a("svmcweights");
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x1901c(%rip), %rdi     # 0xaa6da
callq 0x5341c
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x20(%rbx)
leaq 0x110d8(%rip), %rdi     # 0xa27ab
callq 0x534b6
movsd %xmm0, 0x30(%rbx)
leaq 0x11169(%rip), %rdi     # 0xa284d
callq 0x534b6
movsd %xmm0, 0x18(%rbx)
leaq 0x11161(%rip), %rdi     # 0xa2856
callq 0x5341c
movl %eax, 0x8(%rbx)
movabsq $0x3f50624dd2f1a9fc, %rax # imm = 0x3F50624DD2F1A9FC
movq %rax, 0x28(%rbx)
leaq 0x1114e(%rip), %rdi     # 0xa2860
callq 0x534b6
movsd %xmm0, 0x10(%rbx)
leaq 0x4114d(%rip), %rax     # 0xd2870
movq (%rax), %rcx
movl $0x4, %eax
cmpl $0x3, 0x140713c(%rcx)
je 0x91740
leaq 0x11107(%rip), %rdi     # 0xa2842
callq 0x535f7
movl %eax, 0x4(%rbx)
leaq 0x18c53(%rip), %rdi     # 0xaa39d
callq 0x534b6
movsd %xmm0, 0x40(%rbx)
leaq 0x112ed(%rip), %rdi     # 0xa2a48
callq 0x534b6
movsd %xmm0, 0x48(%rbx)
movl $0x1, 0x50(%rbx)
xorl %eax, %eax
cmpl $0x5, %ebp
cmovnel %ebp, %eax
movl %eax, (%rbx)
leaq 0x18c4f(%rip), %rdi     # 0xaa3cc
callq 0x53784
movq %rax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmq.c
// Function: empty_svcq
Svcqptr empty_svcq(Svm_problem prob, Svm_parameter param, signed char* y)
{
	/*Last Changed 27.04.2005*/
	Svcqptr result;
	result = safemalloc(sizeof(Svcq), "empty_svcq", 2);
	result->k = empty_kernel(prob.l, prob.x, param.kernel_type, param.degree, param.gamma, param.coef0);
	result->y = safemalloc(prob.l * sizeof(signed char), "empty_svcq", 4);
	memcpy(result->y, y, prob.l * sizeof(signed char));
	result->cache = empty_cache(prob.l, (int)(param.cache_size*(1<<20)));
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x1d386(%rip), %r15     # 0xaeb28
movl $0x18, %edi
movq %r15, %rsi
movl $0x2, %edx
callq 0x390f5
movq %rax, %rbx
movl 0x30(%rsp), %ebp
movq 0x40(%rsp), %rsi
movl 0x54(%rsp), %edx
movl 0x58(%rsp), %ecx
movsd 0x60(%rsp), %xmm0
movsd 0x68(%rsp), %xmm1
movl %ebp, %edi
callq 0x9115c
movq %rax, (%rbx)
movslq %ebp, %r12
movq %r12, %rdi
movq %r15, %rsi
movl $0x4, %edx
callq 0x390f5
movq %rax, 0x8(%rbx)
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4310
movsd 0x70(%rsp), %xmm0
mulsd 0x1d30f(%rip), %xmm0    # 0xaeb20
cvttsd2si %xmm0, %esi
movl %r12d, %edi
callq 0x90aa0
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmq.c
// Function: free_svcq
void free_svcq(Svcqptr s)
{
	/*Last Changed 27.04.2005*/
	safe_free(s->y);
	free_kernel(s->k);
	free_cache(s->cache);
 safe_free(s);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x39194
movq (%rbx), %rdi
callq 0x9127d
movq 0x10(%rbx), %rdi
callq 0x90b09
movq %rbx, %rdi
popq %rbx
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmq.c
// Function: svcq_get_Q
double* svcq_get_Q(Svcqptr s, int i, int len)
{
	/*Last Changed 27.04.2005*/
 ON_OFF normalizekernel = get_parameter_o("normalizekernel");
	double *data;
	int start, j;
	start = get_data(s->cache, i, &data, len);
	if (start < len)
	 {
			for (j = start; j < len; j++)
     if (normalizekernel == ON)
				   data[j] = (double)(s->y[i] * s->y[j] * kernel_function_normalized(s->k, i, j));
     else
       data[j] = (double)(s->y[i] * s->y[j] * kernel_function(s->k, i, j));
	 }
	return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x19a99(%rip), %rdi     # 0xab309
callq 0x536e7
movl %eax, %r15d
movq 0x10(%r14), %rdi
leaq 0x10(%rsp), %rdx
movl %ebp, %esi
movl %ebx, %ecx
callq 0x90b70
cmpl %ebx, %eax
jge 0x91908
movslq %ebp, %r13
movslq %eax, %r12
movq (%r14), %rdi
cmpl $0x1, %r15d
jne 0x918c7
movq 0x8(%r14), %rax
movsbl (%rax,%r13), %ecx
movsbl (%rax,%r12), %eax
imull %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x8(%rsp)
movl %ebp, %esi
movl %r12d, %edx
callq 0x910c5
jmp 0x918ef
movq 0x8(%r14), %rax
movsbl (%rax,%r13), %ecx
movsbl (%rax,%r12), %eax
imull %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x8(%rsp)
movl %ebp, %esi
movl %r12d, %edx
callq 0x9103f
mulsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
cmpl %r12d, %ebx
jne 0x91894
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmq.c
// Function: svcq_swap_index
void svcq_swap_index(Svcqptr s, int i, int j)
{
	/*Last Changed 27.04.2005*/
	signed char tmp;
	cache_swap_index(s->cache, i, j);
	kernel_swap_index(s->k, i, j);
	tmp = s->y[i];
	s->y[i] = s->y[j];
	s->y[j] = tmp;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x90c6d
movq (%r14), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x90de4
movq 0x8(%r14), %rax
movslq %ebp, %rcx
movb (%rax,%rcx), %dl
movslq %ebx, %rsi
movb (%rax,%rsi), %dil
movb %dil, (%rax,%rcx)
movq 0x8(%r14), %rax
movb %dl, (%rax,%rsi)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmq.c
// Function: empty_oneclassq
Oneclassqptr empty_oneclassq(Svm_problem prob, Svm_parameter param)
{
	/*Last Changed 27.04.2005*/
	Oneclassqptr result;
	result = safemalloc(sizeof(Oneclassq), "empty_oneclassq", 2);
	result->k = empty_kernel(prob.l, prob.x, param.kernel_type, param.degree, param.gamma, param.coef0);
	result->cache = empty_cache(prob.l, (int)(param.cache_size*(1<<20)));
	return result;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x1d1cc(%rip), %rsi     # 0xaeb33
movl $0x10, %edi
movl $0x2, %edx
callq 0x390f5
movq %rax, %rbx
movl 0x20(%rsp), %ebp
movq 0x30(%rsp), %rsi
movl 0x44(%rsp), %edx
movl 0x48(%rsp), %ecx
movsd 0x50(%rsp), %xmm0
movsd 0x58(%rsp), %xmm1
movl %ebp, %edi
callq 0x9115c
movq %rax, (%rbx)
movsd 0x60(%rsp), %xmm0
mulsd 0x1d172(%rip), %xmm0    # 0xaeb20
cvttsd2si %xmm0, %esi
movl %ebp, %edi
callq 0x90aa0
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmq.c
// Function: oneclassq_get_Q
double* oneclassq_get_Q(Oneclassqptr o, int i, int len)
{
	/*Last Changed 27.04.2005*/
 ON_OFF normalizekernel = get_parameter_o("normalizekernel");
	double *data;
	int start, j;
	start = get_data(o->cache, i, &data, len);
	if (start < len)
	 {
			for (j = start; j < len; j++)
     if (normalizekernel == ON)
				   data[j] = (double)(kernel_function_normalized(o->k, i, j));
     else
       data[j] = (double)(kernel_function(o->k, i, j));
	 }
	return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x1990a(%rip), %rdi     # 0xab309
callq 0x536e7
movl %eax, %r15d
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %rdx
movl %ebp, %esi
movl %ebx, %ecx
callq 0x90b70
cmpl %ebx, %eax
jge 0x91a4d
movslq %eax, %r12
movq (%r14), %rdi
movl %ebp, %esi
movl %r12d, %edx
cmpl $0x1, %r15d
jne 0x91a35
callq 0x910c5
jmp 0x91a3a
callq 0x9103f
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
cmpl %r12d, %ebx
jne 0x91a20
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmq.c
// Function: empty_svrq
Svrqptr empty_svrq(Svm_problem prob, Svm_parameter param)
{
	/*Last Changed 27.04.2005*/
	int k;
	Svrqptr result;
	result = safemalloc(sizeof(Svrq), "empty_svrq", 3);
	result->k = empty_kernel(prob.l, prob.x, param.kernel_type, param.degree, param.gamma, param.coef0);
	result->l = prob.l;
	result->cache = empty_cache(prob.l, (int)(param.cache_size*(1<<20)));
	result->sign = safemalloc(2 * prob.l * sizeof(signed char), "empty_svrq", 7);
	result->index = safemalloc(2 * prob.l * sizeof(int), "empty_svrq", 8);
	for(k = 0; k < prob.l; k++)
	 {
			result->sign[k] = 1;
			result->sign[k + prob.l] = -1;
			result->index[k] = k;
			result->index[k + prob.l] = k;
		}
	result->buffer[0] = safemalloc(2 * prob.l * sizeof(double), "empty_svrq", 16);
	result->buffer[1] = safemalloc(2 * prob.l * sizeof(double), "empty_svrq", 17);
	result->next_buffer = 0;
	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1d0b1(%rip), %r12     # 0xaeb43
movl $0x40, %edi
movq %r12, %rsi
movl $0x3, %edx
callq 0x390f5
movq %rax, %rbx
movslq 0x30(%rsp), %r14
movq 0x40(%rsp), %rsi
movl 0x54(%rsp), %edx
movl 0x58(%rsp), %ecx
movsd 0x60(%rsp), %xmm0
movsd 0x68(%rsp), %xmm1
movl %r14d, %edi
callq 0x9115c
movq %rax, (%rbx)
movl %r14d, 0x8(%rbx)
movsd 0x70(%rsp), %xmm0
mulsd 0x1d03e(%rip), %xmm0    # 0xaeb20
cvttsd2si %xmm0, %esi
movl %r14d, %edi
callq 0x90aa0
movq %rax, 0x10(%rbx)
leaq (%r14,%r14), %r15
movq %r15, %rdi
movq %r12, %rsi
movl $0x7, %edx
callq 0x390f5
movq %rax, 0x18(%rbx)
leaq (,%r14,8), %rdi
movq %r12, %rsi
movl $0x8, %edx
callq 0x390f5
movq %rax, 0x20(%rbx)
testq %r14, %r14
jle 0x91b5b
leaq (,%r14,4), %rax
xorl %ecx, %ecx
movq 0x18(%rbx), %rdx
movb $0x1, (%rdx,%rcx)
movq 0x18(%rbx), %rdx
addq %r14, %rdx
movb $-0x1, (%rcx,%rdx)
movq 0x20(%rbx), %rdx
leaq (%rdx,%rcx,4), %rsi
movl %ecx, (%rdx,%rcx,4)
movl %ecx, (%rax,%rsi)
incq %rcx
cmpq %rcx, %r14
jne 0x91b32
shlq $0x3, %r15
leaq 0x1cfdd(%rip), %r14     # 0xaeb43
movq %r15, %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x390f5
movq %rax, 0x30(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movl $0x11, %edx
callq 0x390f5
movq %rax, 0x38(%rbx)
movl $0x0, 0x28(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmq.c
// Function: free_svrq
void free_svrq(Svrqptr s)
{
	/*Last Changed 27.04.2005*/
	free_kernel(s->k);
	free_cache(s->cache);
	safe_free(s->sign);
	safe_free(s->index);
	safe_free(s->buffer[0]);
	safe_free(s->buffer[1]);
	safe_free(s);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x9127d
movq 0x10(%rbx), %rdi
callq 0x90b09
movq 0x18(%rbx), %rdi
callq 0x39194
movq 0x20(%rbx), %rdi
callq 0x39194
movq 0x30(%rbx), %rdi
callq 0x39194
movq 0x38(%rbx), %rdi
callq 0x39194
movq %rbx, %rdi
popq %rbx
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmq.c
// Function: svrq_get_Q
double* svrq_get_Q(Svrqptr s, int i, int len)
{
	/*Last Changed 27.04.2005*/
 ON_OFF normalizekernel = get_parameter_o("normalizekernel");
	double *data, *buf;
	int real_i, j;
	signed char si;
 real_i = s->index[i];
	if(get_data(s->cache, real_i, &data, s->l) < s->l)
		{
			for (j = 0; j < s->l; j++)
     if (normalizekernel == ON)    
				   data[j] = (double)(kernel_function_normalized(s->k, real_i, j));
     else
       data[j] = (double)(kernel_function(s->k, real_i, j));
		}
	buf = s->buffer[s->next_buffer];
	s->next_buffer = 1 - s->next_buffer;
 si = s->sign[i];
	for (j = 0; j < len; j++)
			 buf[j] = si * s->sign[j] * data[s->index[j]];
	return buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
leaq 0x19709(%rip), %rdi     # 0xab309
callq 0x536e7
movl %eax, %ebp
movq 0x20(%r14), %rax
movslq %r15d, %r13
movl (%rax,%r13,4), %r15d
movq 0x10(%r14), %rdi
movl 0x8(%r14), %ecx
movq %rsp, %rdx
movl %r15d, %esi
callq 0x90b70
cmpl 0x8(%r14), %eax
jge 0x91c65
cmpl $0x0, 0x8(%r14)
jle 0x91c65
xorl %r12d, %r12d
movq (%r14), %rdi
movl %r15d, %esi
movl %r12d, %edx
cmpl $0x1, %ebp
jne 0x91c4a
callq 0x910c5
jmp 0x91c4f
callq 0x9103f
movq (%rsp), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jl 0x91c35
movslq 0x28(%r14), %rcx
movq 0x30(%r14,%rcx,8), %rax
movl $0x1, %edx
subl %ecx, %edx
movl %edx, 0x28(%r14)
testl %ebx, %ebx
jle 0x91cbd
movq 0x18(%r14), %rcx
movsbl (%rcx,%r13), %edx
movq (%rsp), %rsi
movq 0x20(%r14), %rdi
movl %ebx, %r8d
xorl %r9d, %r9d
movsbl (%rcx,%r9), %r10d
imull %edx, %r10d
xorps %xmm0, %xmm0
cvtsi2sd %r10d, %xmm0
movslq (%rdi,%r9,4), %r10
mulsd (%rsi,%r10,8), %xmm0
movsd %xmm0, (%rax,%r9,8)
incq %r9
cmpq %r9, %r8
jne 0x91c94
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmq.c
// Function: svrq_swap_index
void svrq_swap_index(Svrqptr s, int i, int j)
{
	/*Last Changed 27.04.2005*/
	signed char tmp;
	tmp = s->sign[i];
	s->sign[i] = s->sign[j];
	s->sign[j] = tmp;
	swap_int(&(s->index[i]), &(s->index[j]));
}

// Assembly:
movq 0x18(%rdi), %rax
movslq %esi, %rcx
movb (%rax,%rcx), %sil
movslq %edx, %rdx
movb (%rax,%rdx), %r8b
movb %r8b, (%rax,%rcx)
movq 0x18(%rdi), %rax
movb %sil, (%rax,%rdx)
movq 0x20(%rdi), %rax
leaq (%rax,%rcx,4), %rdi
leaq (%rax,%rdx,4), %rsi
jmp 0x395a3
nop
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmregtree.c
// Function: create_svmregtree
int create_svmregtree(Regressionnodeptr node, Regtree_parameterptr param)
{
 /*!Last Changed 01.11.2009*/
 Instanceptr leftinstances = NULL, rightinstances = NULL;
 if (!(can_be_divided_regression(node, param)))
   return 1;
 node->featureno = optimize_C_for_svmregtreenode(node, param->leaftype);
 divide_instancelist_according_to_split(&(node->instances), &leftinstances, &rightinstances, node->featureno, node->split);
 if (leftinstances == NULL || rightinstances == NULL)
  {
   make_leaf_regression_node(node, param->leaftype);
   node->instances = restore_instancelist(node->instances, leftinstances);
   merge_instancelist(&(node->instances), rightinstances);
   return 1;
  }
 node->instances = restore_instancelist(node->instances, leftinstances);
 merge_instancelist(&(node->instances), rightinstances);
 if (!(make_regression_children(node, param->leaftype)))
   return 1;
 create_svmregtree(node->left, param);
 create_svmregtree(node->right, param);
 return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
callq 0x75e70
testl %eax, %eax
je 0x9223d
movl (%r14), %esi
movq %rbx, %rdi
callq 0x91fab
movl %eax, 0x68(%rbx)
leaq 0x20(%rbx), %r15
movsd 0x50(%rbx), %xmm0
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %ecx
callq 0x301e1
movq (%r12), %rsi
testq %rsi, %rsi
je 0x92213
cmpq $0x0, 0x8(%rsp)
je 0x92213
movq 0x20(%rbx), %rdi
callq 0x30ad5
movq %rax, 0x20(%rbx)
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2fd59
movl (%r14), %esi
movq %rbx, %rdi
callq 0x759f8
testl %eax, %eax
je 0x9223d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x92168
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x92168
jmp 0x9223d
movl (%r14), %esi
movq %rbx, %rdi
callq 0x74df3
movq 0x20(%rbx), %rdi
movq 0x10(%rsp), %rsi
callq 0x30ad5
movq %rax, 0x20(%rbx)
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2fd59
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsimplex.c
// Function: kernel_value
double kernel_value(Instanceptr inst1, Instanceptr inst2, Kernel_parameter kernel)
{
	switch (kernel.type)
  {
   case    KLINEAR :return dot_product(inst1, inst2);
                    break;
   case    KPOLY   :return pow(kernel.gamma * dot_product(inst1, inst2) + kernel.coef0, kernel.degree);
                    break;
   case    KRBF    :return exp(-kernel.gamma * distance_between_instances(inst1, inst2));
                    break;
   case    KSIGMOID:return tanh(kernel.gamma * dot_product(inst1, inst2) + kernel.coef0);
                    break;
   case KPREDEFINED:return current_dataset->kernel->values[(int) real_feature(inst1, 0)][(int) real_feature(inst2, 0)];
                    break;
   default         :printf(m1232, kernel.type);
                    return 0;
                    break;
  }
 return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x30(%rsp), %esi
cmpq $0x4, %rsi
ja 0x92353
leaq 0x30(%rsp), %r14
leaq 0x1c8dc(%rip), %rax     # 0xaeb50
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x2f492
leaq 0x405dd(%rip), %rax     # 0xd2870
movq (%rax), %rax
movq 0x1407210(%rax), %rax
movq 0x8(%rax), %r14
xorl %esi, %esi
callq 0x2e4b6
cvttsd2si %xmm0, %eax
cltq
movq (%r14,%rax,8), %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2e4b6
cvttsd2si %xmm0, %eax
cltq
movsd (%r14,%rax,8), %xmm0
jmp 0x92364
movsd 0x8(%r14), %xmm0
xorpd 0x10ef5(%rip), %xmm0    # 0xa31d0
movapd %xmm0, (%rsp)
movq %rbx, %rsi
callq 0x2f4ea
mulsd (%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x4060
movsd 0x8(%r14), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rsi
callq 0x2f492
mulsd (%rsp), %xmm0
addsd 0x10(%r14), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x4040
movsd 0x8(%r14), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rsi
callq 0x2f492
mulsd (%rsp), %xmm0
addsd 0x10(%r14), %xmm0
cvtsi2sdl 0x4(%r14), %xmm1
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x42f0
leaq 0x1c776(%rip), %rdi     # 0xaead0
xorl %eax, %eax
callq 0x4030
xorps %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsimplex.c
// Function: prepare_Q_for_epsilon_svm
matrix prepare_Q_for_epsilon_svm(Instanceptr data, Kernel_parameter kernel)
{
 Instanceptr tmp, tmp1;
 matrix Q;
 int i, j, size = data_size(data);
 Q = matrix_alloc(2 * size, 2 * size);
 tmp = data;
 i = 0;
 while (tmp != NULL)
  {
   tmp1 = data;
   j = 0;
   while (tmp1 != NULL)
    {
     Q.values[i][j] = kernel_value(tmp, tmp1, kernel);
     Q.values[i + size][j + size] = Q.values[i][j];
     Q.values[i + size][j] = -Q.values[i][j];
     Q.values[i][j + size] = -Q.values[i][j];
     tmp1 = tmp1->next;
     j++;
    }
   tmp = tmp->next;
   i++;
  }
 return Q;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0x2fa14
movl %eax, %r12d
leal (%r12,%r12), %edi
movl %edi, %esi
callq 0x3c6e5
movq %rax, 0x20(%rsp)
movq %rbx, 0x18(%rsp)
testq %rbx, %rbx
je 0x92454
leaq 0x70(%rsp), %rcx
movslq %r12d, %rax
leaq (%rdx,%rax,8), %r14
shlq $0x3, %rax
movq %rax, 0x28(%rsp)
xorl %r8d, %r8d
movq 0x18(%rsp), %r12
xorl %r15d, %r15d
movq 0x28(%rsp), %rbp
movq 0x18(%rsp), %r13
movq %r8, 0x30(%rsp)
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rsp)
movups (%rcx), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r13, %rsi
movq %rdx, %rbx
callq 0x92250
movaps 0x10dd9(%rip), %xmm1    # 0xa31d0
movq 0x30(%rsp), %r8
movq %rbx, %rdx
movq (%rbx,%r8,8), %rax
movsd %xmm0, (%rax,%r15)
movq (%r14,%r8,8), %rcx
movsd %xmm0, (%rcx,%rbp)
movsd (%rax,%r15), %xmm0
xorps %xmm1, %xmm0
movlps %xmm0, (%rcx,%r15)
leaq 0x70(%rsp), %rcx
movsd (%rax,%r15), %xmm0
xorps %xmm1, %xmm0
movlps %xmm0, (%rax,%rbp)
movq 0x10(%r13), %r13
addq $0x8, %rbp
addq $0x8, %r15
testq %r13, %r13
jne 0x923d2
movq 0x10(%r12), %r12
incq %r8
testq %r12, %r12
jne 0x923c0
movq 0x20(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsimplex.c
// Function: prepare_Q_for_C_svm
matrix prepare_Q_for_C_svm(Instanceptr data, Kernel_parameter kernel, int negative)
{
 Instanceptr tmp, tmp1;
 matrix Q;
 int i, j, size = data_size(data);
 Q = matrix_alloc(size, size);
 tmp = data;
 i = 0;
 while (tmp != NULL)
  {
   tmp1 = data;
   j = 0;
   while (tmp1 != NULL)
    {
     Q.values[i][j] = svm_classno(tmp, negative) * svm_classno(tmp1, negative) * kernel_value(tmp, tmp1, kernel);
     tmp1 = tmp1->next;
     j++;
    }
   tmp = tmp->next;
   i++;
  }
 return Q;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x2fa14
movl %eax, %edi
movl %eax, %esi
callq 0x3c6e5
movq %rax, 0x28(%rsp)
movq %r14, 0x20(%rsp)
testq %r14, %r14
je 0x92542
leaq 0x80(%rsp), %r15
xorl %ecx, %ecx
movq 0x20(%rsp), %r12
movq %rdx, 0x30(%rsp)
xorl %r14d, %r14d
movq 0x20(%rsp), %rbp
movq %rcx, 0x38(%rsp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x2f5e9
movq %r15, %r13
movl %eax, %r15d
movq %rbp, %rdi
movl %ebx, %esi
callq 0x2f5e9
imull %r15d, %eax
movq %r13, %r15
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movupd (%r13), %xmm0
movupd %xmm0, (%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x92250
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %rdx
mulsd 0x40(%rsp), %xmm0
movq (%rdx,%rcx,8), %rax
movsd %xmm0, (%rax,%r14)
movq 0x10(%rbp), %rbp
addq $0x8, %r14
testq %rbp, %rbp
jne 0x924bd
movq 0x10(%r12), %r12
incq %rcx
testq %r12, %r12
jne 0x924b0
movq 0x28(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsimplex.c
// Function: prepare_qp_for_C_svm
Quadraticprogramptr prepare_qp_for_C_svm(Instanceptr data, Svm_simplex_parameterptr parameters, int negative)
{
 int i, size = data_size(data);
 double *c, *b;
 matrix A, Q;
 Instanceptr tmp;
 Quadraticprogramptr program;
 Q = prepare_Q_for_C_svm(data, parameters->kernel, negative);
 c = safemalloc(size * sizeof(double), "prepare_qp_for_C_svm", 4);
 for (i = 0; i < size; i++)
   c[i] = -1;
 b = safemalloc((size + 2) * sizeof(double), "prepare_qp_for_C_svm", 7);
 for (i = 0; i < size; i++)
   b[i] = parameters->C;
 b[size] = 0;
 b[size + 1] = 0;
 A = matrix_alloc(size + 2, size);
 for (i = 0, tmp = data; i < size; i++, tmp = tmp->next)
  {
   A.values[size][i] = svm_classno(tmp, negative);
   A.values[size + 1][i] = -svm_classno(tmp, negative);
   A.values[i][i] = 1;
  }
 program = prepare_quadratic_program(Q, A, c, b);
 matrix_free(Q);
 matrix_free(A);
 safe_free(c);
 safe_free(b);
 return program;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
callq 0x2fa14
movl %eax, %ebp
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movupd (%r12), %xmm0
movupd %xmm0, (%rsp)
movq %r14, %rdi
movl %ebx, %esi
callq 0x92468
movq %rax, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movslq %ebp, %rbp
leaq (,%rbp,8), %rdi
leaq 0x1c3b6(%rip), %rsi     # 0xaeb7f
movl $0x4, %edx
callq 0x390f5
testl %ebp, %ebp
jle 0x927ef
xorl %edx, %edx
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rbp
jne 0x927e3
movq %rax, 0x30(%rsp)
leal 0x2(%rbp), %r15d
leaq 0x10(,%rbp,8), %rdi
leaq 0x1c378(%rip), %rsi     # 0xaeb7f
movl $0x7, %edx
callq 0x390f5
testl %ebp, %ebp
jle 0x9282b
xorl %ecx, %ecx
movsd 0x20(%r12), %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %rbp
jne 0x92817
xorl %ecx, %ecx
movq %rcx, (%rax,%rbp,8)
movq %rax, 0x28(%rsp)
movq %rcx, 0x8(%rax,%rbp,8)
movl %r15d, %edi
movl %ebp, %esi
callq 0x3c6e5
movq %rax, 0x20(%rsp)
movq %rdx, %r12
testl %ebp, %ebp
jle 0x928ae
leaq 0x1(%rbp), %r13
xorl %r15d, %r15d
movq %r14, %rdi
movl %ebx, %esi
callq 0x2f5e9
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq (%r12,%rbp,8), %rax
movsd %xmm0, (%rax,%r15,8)
movq %r14, %rdi
movl %ebx, %esi
callq 0x2f5e9
negl %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq (%r12,%r13,8), %rax
movsd %xmm0, (%rax,%r15,8)
movq (%r12,%r15,8), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax,%r15,8)
incq %r15
movq 0x10(%r14), %r14
cmpq %r15, %rbp
jne 0x92858
movq 0x40(%rsp), %r14
movq %r14, %rdi
movq 0x38(%rsp), %r15
movq %r15, %rsi
movq 0x20(%rsp), %rbx
movq %rbx, %rdx
movq %r12, %rcx
movq 0x30(%rsp), %r13
movq %r13, %r8
movq 0x28(%rsp), %rbp
movq %rbp, %r9
callq 0xecc7
movq %rax, 0x18(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3dbad
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3dbad
movq %r13, %rdi
callq 0x39194
movq %rbp, %rdi
callq 0x39194
movq 0x18(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsimplex.c
// Function: test_svm_regression
double test_svm_regression(Svm_regression_modelptr model, Svm_simplex_parameterptr parameters, Instanceptr inst)
{
 int i;
 double sum = 0;
 for (i = 0; i < model->support_vector_count; i++)
   sum += model->alpha[i] * kernel_value(inst, model->support_vectors[i], parameters->kernel);
 sum += model->b;
 return sum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x92f89
movq %rdx, %r14
movq %rsi, %r15
xorpd %xmm0, %xmm0
xorl %r12d, %r12d
movsd %xmm0, 0x18(%rsp)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movsd (%rcx,%r12,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movq (%rax,%r12,8), %rsi
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movupd (%r15), %xmm0
movupd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x92250
mulsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
incq %r12
movslq (%rbx), %rax
cmpq %rax, %r12
jl 0x92f27
jmp 0x92f8d
xorpd %xmm0, %xmm0
addsd 0x18(%rbx), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsimplex.c
// Function: test_binary_svm
double test_binary_svm(Svm_binary_modelptr model, Svm_simplex_parameterptr parameters, Instanceptr inst)
{
 int i;
 double sum = 0;
 for (i = 0; i < model->support_vector_count; i++)
   sum += model->alpha_y[i] * kernel_value(inst, model->support_vectors[i], parameters->kernel);
 sum += model->b;
 return sum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x93020
movq %rdx, %r14
movq %rsi, %r15
xorpd %xmm0, %xmm0
xorl %r12d, %r12d
movsd %xmm0, 0x18(%rsp)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movsd (%rcx,%r12,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movq (%rax,%r12,8), %rsi
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movupd (%r15), %xmm0
movupd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x92250
mulsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
incq %r12
movslq (%rbx), %rax
cmpq %rax, %r12
jl 0x92fbe
jmp 0x93024
xorpd %xmm0, %xmm0
addsd 0x18(%rbx), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsimplex.c
// Function: number_of_support_vectors
int number_of_support_vectors(void* model)
{
 int i, sv;
 if (current_dataset->classno == 2)
   return ((Svm_binary_modelptr) model)->support_vector_count;
 else
   if (current_dataset->classno == 0)
     return ((Svm_regression_modelptr) model)->support_vector_count;
   else
    {
     sv = 0;
     for (i = 0; i < ((Svm_simplex_modelptr)model)->problemcount; i++)
       sv += ((Svm_simplex_modelptr)model)->models[i]->support_vector_count;
     return sv;
    }
}

// Assembly:
leaq 0x3f7f6(%rip), %rax     # 0xd2870
movq (%rax), %rax
movl (%rdi), %ecx
testl $0xfffffffd, 0x10(%rax) # imm = 0xFFFFFFFD
jne 0x9308b
movl %ecx, %eax
retq
testl %ecx, %ecx
jle 0x930a6
movq 0x8(%rdi), %rdx
xorl %esi, %esi
xorl %eax, %eax
movq (%rdx,%rsi,8), %rdi
addl (%rdi), %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x93097
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsimplex.c
// Function: solve_one_vs_one_svm
Svm_simplex_modelptr solve_one_vs_one_svm(Instanceptr* data, Svm_simplex_parameterptr parameters)
{
 int i, j, k;
 Instanceptr list;
 Svm_simplex_modelptr model;
 model = safemalloc(sizeof(Svm_simplex_model), "solve_one_vs_one_svm", 4);
 model->problemcount = current_dataset->classno * (current_dataset->classno - 1) / 2;
 model->models = safemalloc(model->problemcount * sizeof(Svm_binary_modelptr), "solve_one_vs_one_svm", 6);
 k = 0;
 for (i = 0; i < current_dataset->classno; i++)
   for (j = i + 1; j < current_dataset->classno; j++)
    {
     divide_instancelist_one_vs_one(data, &list, i, j);
     model->models[k] = solve_binary_svm(list, parameters, i);
     k++;
     merge_instancelist(data, list);
    }
 return model;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbp
movq %rdi, %r14
leaq 0x1baf6(%rip), %r12     # 0xaebba
movl $0x10, %edi
movq %r12, %rsi
movl $0x4, %edx
callq 0x390f5
movq %rax, %r15
leaq 0x3f790(%rip), %rbx     # 0xd2870
movq (%rbx), %rax
movl 0x10(%rax), %eax
leal -0x1(%rax), %ecx
imull %eax, %ecx
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
sarl %eax
movl %eax, (%r15)
movslq %eax, %rdi
shlq $0x3, %rdi
movq %r12, %rsi
movl $0x6, %edx
callq 0x390f5
movq %rax, 0x8(%r15)
movq (%rbx), %rax
cmpl $0x0, 0x10(%rax)
jle 0x931a9
xorl %esi, %esi
leaq 0x18(%rsp), %rdx
xorl %r12d, %r12d
movq %r15, 0x10(%rsp)
movq %rbp, 0x20(%rsp)
movl %esi, %r13d
leal 0x1(%r13), %esi
movq (%rbx), %rax
cmpl 0x10(%rax), %esi
jge 0x931a1
movslq %r12d, %r12
movl %esi, 0xc(%rsp)
movl %esi, %ebp
movq %r14, %rdi
movq %rdx, %r15
movq %rdx, %rsi
movl %r13d, %edx
movl %ebp, %ecx
callq 0x3031b
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %r13d, %edx
callq 0x92bec
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x2fd59
movq %r15, %rdx
incl %ebp
movq (%rbx), %rax
cmpl 0x10(%rax), %ebp
jl 0x93149
movq 0x10(%rsp), %r15
movl 0xc(%rsp), %esi
movq (%rbx), %rax
cmpl 0x10(%rax), %esi
jl 0x93131
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq