LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x30, %edi
leaq 0x24228(%rip), %rsi     # 0xee132
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movslq -0x4(%rbp), %rdi
movl $0x20, %esi
leaq 0x2420a(%rip), %rdx     # 0xee132
movl $0x3, %ecx
callq 0x52f40
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movslq -0x8(%rbp), %rax
shrq $0x3, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movslq -0x4(%rbp), %rdx
shlq $0x5, %rdx
shrq $0x3, %rdx
movq -0x10(%rbp), %rax
movslq 0x2c(%rax), %rcx
subq %rdx, %rcx
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0xc9fe4
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x52e80
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xc9fb8
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0xca0bf
movq -0x28(%rbp), %rdi
callq 0xca000
movl -0x1c(%rbp), %eax
movq -0x28(%rbp), %rcx
subl 0x18(%rcx), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jle 0xca173
jmp 0xca0d8
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
cmpl -0x20(%rbp), %eax
jge 0xca130
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xca000
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x52e80
movq -0x30(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x2c(%rax), %ecx
movl %ecx, 0x2c(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x18(%rax)
jmp 0xca0d8
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x1c(%rbp), %rsi
shlq $0x3, %rsi
movl -0x1c(%rbp), %edx
callq 0x52d10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x20(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x2c(%rax)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x533d0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xca030
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xca47c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x53400
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $-0x1, (%rcx)
movb %al, -0x19(%rbp)
je 0xca4bf
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xca4c8
jmp 0xca543
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xca514
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0xca53e
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jle 0xca530
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0xca53c
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0xca53e
jmp 0xca4a4
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x4, %rax
ja 0xca829
movq -0x20(%rbp), %rax
leaq 0x2398e(%rip), %rcx     # 0xee140
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xca550
movsd %xmm0, -0x8(%rbp)
jmp 0xca846
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xca590
movsd %xmm0, -0x8(%rbp)
jmp 0xca846
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xca600
movsd %xmm0, -0x8(%rbp)
jmp 0xca846
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xca6b0
movsd %xmm0, -0x8(%rbp)
jmp 0xca846
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xca720
movsd %xmm0, -0x8(%rbp)
jmp 0xca846
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0x23931(%rip), %rdi     # 0xee168
movb $0x0, %al
callq 0x4030
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0xca780
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xca780
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xca8ac
jp 0xca8ac
jmp 0xca8f4
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xca8be
jp 0xca8be
jmp 0xca8f4
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xca780
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
callq 0x42a0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xca908
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xca780
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movl $0x28, %edi
leaq 0x23847(%rip), %rsi     # 0xee192
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movl -0x18(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x14(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x10(%rax)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x237fa(%rip), %rsi     # 0xee192
movl $0x8, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movslq -0x4(%rbp), %rdx
shlq $0x3, %rdx
callq 0x42b0
cmpl $0x2, -0x14(%rbp)
jne 0xcaa38
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x237b9(%rip), %rsi     # 0xee192
movl $0xc, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xcaa36
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xca490
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xca9f5
jmp 0xcaa44
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
cmpl $0x2, 0x10(%rax)
jne 0xcaa7f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x50(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x50(%rax)
movups 0x40(%rcx), %xmm0
movups %xmm0, 0x40(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xcaa90
movq -0x30(%rbp), %rcx
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x50(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x50(%rax)
movups 0x40(%rcx), %xmm0
movups %xmm0, 0x40(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xcaa90
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xcae37
jp 0xcae37
jmp 0xcaeb2
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xcae49
jp 0xcae49
jmp 0xcaeb2
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x50(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x50(%rax)
movups 0x40(%rcx), %xmm0
movups %xmm0, 0x40(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xcaa90
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
callq 0x42a0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xcaef9
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x50(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x50(%rax)
movups 0x40(%rcx), %xmm0
movups %xmm0, 0x40(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xcaa90
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x1f3ba(%rip), %rdi     # 0xea4a0
callq 0x78f10
cvtsi2sd %eax, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x20(%rax)
leaq 0x173b1(%rip), %rdi     # 0xe24b0
callq 0x79040
movq -0x8(%rbp), %rax
movsd %xmm0, 0x30(%rax)
leaq 0x1743e(%rip), %rdi     # 0xe2552
callq 0x79040
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
leaq 0x17432(%rip), %rdi     # 0xe255b
callq 0x78f10
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd 0x19735(%rip), %xmm0    # 0xe4878
movsd %xmm0, 0x28(%rax)
leaq 0x17416(%rip), %rdi     # 0xe2565
callq 0x79040
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
leaq 0x3a6dc(%rip), %rax     # 0x105840
movq (%rax), %rax
cmpl $0x3, 0x140713c(%rax)
jne 0xcb17d
movq -0x8(%rbp), %rax
movl $0x4, 0x4(%rax)
jmp 0xcb192
leaq 0x173c3(%rip), %rdi     # 0xe2547
callq 0x792b0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
leaq 0x1efad(%rip), %rdi     # 0xea146
callq 0x79040
movq -0x8(%rbp), %rax
movsd %xmm0, 0x40(%rax)
leaq 0x1760f(%rip), %rdi     # 0xe27bd
callq 0x79040
movq -0x8(%rbp), %rax
movsd %xmm0, 0x48(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x50(%rax)
cmpl $0x5, -0xc(%rbp)
jne 0xcb1d4
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
leaq 0x1efae(%rip), %rdi     # 0xea192
callq 0x79530
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
leaq 0x22f98(%rip), %rsi     # 0xee1c0
movl $0x2, %edx
callq 0x52d70
movq -0x20(%rbp), %rcx
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq %rdx, -0x10(%rbp)
movl (%rcx), %edi
movq 0x10(%rcx), %rsi
movl 0x4(%rax), %edx
movl 0x8(%rax), %ecx
movsd 0x10(%rax), %xmm0
movsd 0x18(%rax), %xmm1
callq 0xca920
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rdx, (%rcx)
movslq (%rax), %rdi
shlq $0x0, %rdi
leaq 0x22f48(%rip), %rsi     # 0xee1c0
movl $0x4, %edx
callq 0x52d70
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x8(%rbp), %rsi
movslq (%rax), %rdx
shlq $0x0, %rdx
callq 0x42b0
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl (%rcx), %edi
movsd 0x22efd(%rip), %xmm0    # 0xee1b8
mulsd 0x20(%rax), %xmm0
cvttsd2si %xmm0, %esi
callq 0xc9ef0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xcaa50
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xc9fa0
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq 0x1fddb(%rip), %rdi     # 0xeb124
callq 0x79440
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %ecx
leaq -0x20(%rbp), %rdx
callq 0xca080
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xcb451
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xcb44f
cmpl $0x1, -0x14(%rbp)
jne 0xcb3e8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
imull %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0xca860
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0xcb43f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
imull %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0xca780
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0xcb441
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xcb37d
jmp 0xcb451
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0xca1a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0xca3f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x11(%rbp), %dl
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x10, %edi
leaq 0x22cc7(%rip), %rsi     # 0xee1cb
movl $0x2, %edx
callq 0x52d70
movq -0x18(%rbp), %rcx
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq %rdx, -0x8(%rbp)
movl (%rcx), %edi
movq 0x10(%rcx), %rsi
movl 0x4(%rax), %edx
movl 0x8(%rax), %ecx
movsd 0x10(%rax), %xmm0
movsd 0x18(%rax), %xmm1
callq 0xca920
movq -0x18(%rbp), %rcx
movq %rax, %rsi
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movq %rsi, (%rdx)
movl (%rcx), %edi
movsd 0x22c64(%rip), %xmm0    # 0xee1b8
mulsd 0x20(%rax), %xmm0
cvttsd2si %xmm0, %esi
callq 0xc9ef0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq 0x1fb4b(%rip), %rdi     # 0xeb124
callq 0x79440
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %ecx
leaq -0x20(%rbp), %rdx
callq 0xca080
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xcb666
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xcb664
cmpl $0x1, -0x14(%rbp)
jne 0xcb638
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0xca860
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0xcb657
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0xca780
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0xcb659
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xcb609
jmp 0xcb666
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xcaa50
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xc9fa0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq 0x1f81b(%rip), %rdi     # 0xeb124
callq 0x79440
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x2c(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
leaq -0x20(%rbp), %rdx
callq 0xca080
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xcb9af
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xcb9ad
cmpl $0x1, -0x14(%rbp)
jne 0xcb981
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0xca860
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0xcb9a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0xca780
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0xcb9a2
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xcb94e
jmp 0xcb9af
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x28(%rcx), %rcx
movq 0x30(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, %ecx
subl 0x28(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x31(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xcba44
movsbl -0x31(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movslq -0x30(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
imull %ecx, %eax
cvtsi2sd %eax, %xmm0
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
movslq -0x30(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xcb9f0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x11(%rbp), %dl
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movslq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x533d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa76f0
cmpl $0x0, %eax
jne 0xcbf9e
movl $0x1, -0x4(%rbp)
jmp 0xcc0a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0xcbd90
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rax
movl 0x68(%rax), %ecx
movq -0x10(%rbp), %rax
movsd 0x50(%rax), %xmm0
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x456d0
cmpq $0x0, -0x20(%rbp)
je 0xcbfe9
cmpq $0x0, -0x28(%rbp)
jne 0xcc02e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0xa60c0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x464e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x28(%rbp), %rsi
callq 0x44f40
movl $0x1, -0x4(%rbp)
jmp 0xcc0a0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x464e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x28(%rbp), %rsi
callq 0x44f40
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0xa7070
cmpl $0x0, %eax
jne 0xcc078
movl $0x1, -0x4(%rbp)
jmp 0xcc0a0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xcbf60
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xcbf60
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x4, %rax
ja 0xcc231
movq -0x20(%rbp), %rax
leaq 0x22105(%rip), %rcx     # 0xee1e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x44250
movsd %xmm0, -0x8(%rbp)
jmp 0xcc24d
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x44250
movq -0x28(%rbp), %rax
movaps %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
movsd 0x10(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsi2sdl 0x4(%rax), %xmm1
callq 0x4290
movsd %xmm0, -0x8(%rbp)
jmp 0xcc24d
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x442e0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x4060
movsd %xmm0, -0x8(%rbp)
jmp 0xcc24d
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x44250
movq -0x28(%rbp), %rax
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd 0x10(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x4040
movsd %xmm0, -0x8(%rbp)
jmp 0xcc24d
leaq 0x39661(%rip), %rax     # 0x105840
movq (%rax), %rax
movq 0x1407210(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x42c40
movq -0x50(%rbp), %rax
cvttsd2si %xmm0, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x42c40
movq -0x48(%rbp), %rax
cvttsd2si %xmm0, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xcc24d
movq -0x28(%rbp), %rax
movl (%rax), %esi
leaq 0x21f2a(%rip), %rdi     # 0xee168
movb $0x0, %al
callq 0x4030
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x449f0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
shll %edi
movl -0x34(%rbp), %esi
shll %esi
callq 0x57fc0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xcc40e
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xcc3f4
movq -0x50(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xcc0b0
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl -0x34(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x30(%rbp), %ecx
addl -0x34(%rbp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl -0x34(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x30(%rbp), %ecx
addl -0x34(%rbp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xcc2d0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xcc2b6
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x449f0
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %edi
movl -0x3c(%rbp), %esi
callq 0x57fc0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xcc548
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xcc52e
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x444b0
movl %eax, -0x64(%rbp)
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x444b0
movl -0x64(%rbp), %ecx
movl %eax, %edx
movq -0x58(%rbp), %rax
imull %edx, %ecx
cvtsi2sd %ecx, %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xcc0b0
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xcc492
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xcc478
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xcd4ef
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xcc0b0
movaps %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xcd473
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xcd5af
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xcc0b0
movaps %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xcd533
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
leaq 0x381e1(%rip), %rax     # 0x105840
movq (%rax), %rax
cmpl $0x2, 0x10(%rax)
jne 0xcd673
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xcd6d0
leaq 0x381c6(%rip), %rax     # 0x105840
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jne 0xcd68e
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xcd6d0
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xcd6ca
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcd69c
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)