LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/svm.c
// Function: solve_c_svc
void solve_c_svc(Svm_problem prob, Svm_parameter param, double *alpha, Solutioninfoptr si, double Cp, double Cn)
{
	/*Last Changed 29.04.2005*/
	int i, l = prob.l;
	double *minus_ones, sum_alpha = 0.0;
	signed char* y;
	Solverptr s;
 minus_ones = safemalloc(l * sizeof(double), "solve_c_svc", 5);
	y = safemalloc(l * sizeof(signed char), "solve_c_svc", 6);
	s = safemalloc(sizeof(Solver), "solve_c_svc", 7);
	for (i = 0; i < l; i++)
	 {
		 alpha[i] = 0;
		 minus_ones[i] = -1;
		 if (prob.y[i] > 0) 
				 y[i] = +1; 
			else 
				 y[i] = -1;
	 }
	solve(s, l, QC, minus_ones, y, alpha, Cp, Cn, si, prob, param, 0);
	for (i = 0; i < l; i++)
		 sum_alpha += alpha[i];
	for (i = 0; i < l; i++)
		 alpha[i] *= y[i];
	safe_free(s);
	safe_free(minus_ones);
	safe_free(y);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movsd %xmm1, 0xa0(%rsp)
movsd %xmm0, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdi, %rbx
leaq 0xe0(%rsp), %rbp
movl (%rbp), %r13d
movslq %r13d, %r12
leaq (,%r12,8), %rdi
leaq 0x1ef3b(%rip), %r15     # 0xa194c
pushq $0x5
popq %rdx
movq %r15, %rsi
callq 0x34f59
movq %rax, %r14
pushq $0x6
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x34f59
movq %rax, %r15
pushq $0x7
popq %rdx
movl $0x80, %edi
leaq 0x1ef0d(%rip), %rsi     # 0xa194c
callq 0x34f59
movl %r13d, %r8d
movq %rax, %r13
xorl %eax, %eax
testl %r12d, %r12d
movl $0x0, %r12d
cmovgl %r8d, %r12d
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
xorpd %xmm0, %xmm0
cmpq %rax, %r12
je 0x82a93
andq $0x0, (%rbx,%rax,8)
movq %rcx, (%r14,%rax,8)
movq 0x8(%rbp), %rdx
movsd (%rdx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
setbe %dl
negb %dl
orb $0x1, %dl
movb %dl, (%r15,%rax)
incq %rax
jmp 0x82a67
leaq 0x28(%rsp), %rdi
pushq $0xb
popq %rcx
leaq 0x100(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups %xmm1, 0x18(%rsp)
movups %xmm0, 0x8(%rsp)
movq 0x90(%rsp), %rax
movq %rax, (%rsp)
andl $0x0, 0x80(%rsp)
xorl %ebp, %ebp
movq %r13, %rdi
movl %r8d, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %r15, %r8
movq %rbx, %r9
movsd 0x98(%rsp), %xmm0
movsd 0xa0(%rsp), %xmm1
callq 0x88454
cmpq %rbp, %r12
je 0x82b13
movsbl (%r15,%rbp), %eax
cvtsi2sd %eax, %xmm0
mulsd (%rbx,%rbp,8), %xmm0
movsd %xmm0, (%rbx,%rbp,8)
incq %rbp
jmp 0x82af6
movq %r13, %rdi
callq 0x34ff7
movq %r14, %rdi
callq 0x34ff7
movq %r15, %rdi
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/svm.c
// Function: solve_one_class
void solve_one_class(Svm_problem prob, Svm_parameter param, double *alpha, Solutioninfoptr si)
{
	/*Last Changed 29.04.2005*/
	Solverptr s;
	int l = prob.l, i, n;
	double *zeros; 
	signed char *ones; 
 zeros = safemalloc(l * sizeof(double), "solve_one_class", 5);
	ones = safemalloc(l * sizeof(signed char), "solve_one_class", 6);
	s = safemalloc(sizeof(Solver), "solve_one_class", 7);
 n = (int)(param.nu * prob.l);	
	for (i = 0; i < n; i++)
		 alpha[i] = 1;
	alpha[n] = param.nu * prob.l - n;
	for (i = n + 1; i < l; i++)
		 alpha[i] = 0;
	for (i = 0; i < l; i++)
	 {
 		zeros[i] = 0;
 		ones[i] = 1;
	 }
	solve(s, l, QONE, zeros, ones, alpha, 1.0, 1.0, si, prob, param, 0);
	safe_free(s);
	safe_free(zeros);
	safe_free(ones);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, 0x90(%rsp)
movq %rdi, %rbx
leaq 0xf0(%rsp), %r12
leaq 0xd0(%rsp), %rax
movslq (%rax), %r15
leaq (,%r15,8), %rdi
leaq 0x1ebdd(%rip), %rbp     # 0xa1965
pushq $0x5
popq %rdx
movq %rbp, %rsi
callq 0x34f59
movq %rax, %r14
pushq $0x6
popq %rdx
movq %r15, %rdi
movq %rbp, %rsi
callq 0x34f59
movq %rax, %r13
pushq $0x7
popq %rdx
movl $0x80, %edi
movq %rbp, %rsi
callq 0x34f59
movq %rax, %rbp
cvtsi2sd %r15d, %xmm0
mulsd 0x40(%r12), %xmm0
cvttsd2si %xmm0, %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
movabsq $0x3ff0000000000000, %rdi # imm = 0x3FF0000000000000
cmpq %rcx, %rdx
je 0x82dee
movq %rdi, (%rbx,%rcx,8)
incq %rcx
jmp 0x82de0
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
cltq
movsd %xmm0, (%rbx,%rax,8)
incq %rax
xorpd %xmm0, %xmm0
cmpq %r15, %rax
jl 0x82df8
xorl %eax, %eax
testl %r15d, %r15d
movl $0x0, %ecx
cmovgl %r15d, %ecx
cmpq %rax, %rcx
je 0x82e2c
andq $0x0, (%r14,%rax,8)
movb $0x1, (%r13,%rax)
incq %rax
jmp 0x82e17
leaq 0x28(%rsp), %rdi
pushq $0xb
popq %rcx
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0xd0(%rsp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x18(%rsp)
movups %xmm0, 0x8(%rsp)
andl $0x0, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq %rax, (%rsp)
pushq $0x2
popq %rdx
movsd 0x126ae(%rip), %xmm0    # 0x95520
movq %rbp, %rdi
movl %r15d, %esi
movq %r14, %rcx
movq %r13, %r8
movq %rbx, %r9
movaps %xmm0, %xmm1
callq 0x88454
movq %rbp, %rdi
callq 0x34ff7
movq %r14, %rdi
callq 0x34ff7
movq %r13, %rdi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/svm.c
// Function: solve_epsilon_svr
void solve_epsilon_svr(Svm_problem prob, Svm_parameter param, double *alpha, Solutioninfoptr si)
{
	/*Last Changed 29.04.2005*/
	Solverptr s;
	int l = prob.l, i;
	double *alpha2, *linear_term, sum_alpha;
	signed char* y;
 alpha2 = safemalloc(2 * l * sizeof(double), "solve_epsilon_svr", 5);
 linear_term = safemalloc(2 * l * sizeof(double), "solve_epsilon_svr", 6);
	y = safemalloc(2 * l * sizeof(signed char), "solve_epsilon_svr", 7);
	s = safemalloc(sizeof(Solver), "solve_epsilon_svr", 8);
	for (i = 0; i < l; i++)
	 {
 		alpha2[i] = 0;
	 	linear_term[i] = param.p - prob.y[i];
		 y[i] = 1;
		 alpha2[i + l] = 0;
		 linear_term[i + l] = param.p + prob.y[i];
		 y[i + l] = -1;
	 }
 solve(s, 2 * l, QR, linear_term, y, alpha2, param.C, param.C, si, prob, param, 0);
 sum_alpha = 0;
	for (i = 0; i < l; i++)
	 {
 		alpha[i] = alpha2[i] - alpha2[i+l];
		 sum_alpha += fabs(alpha[i]);
	 }
	safe_free(s);
	safe_free(alpha2);
	safe_free(linear_term);
	safe_free(y);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, 0x88(%rsp)
movq %rdi, %rbx
leaq 0xd0(%rsp), %rax
movslq (%rax), %rbp
leaq (,%rbp,2), %r12
movq %rbp, %r15
shlq $0x4, %r15
leaq 0x1ea86(%rip), %r13     # 0xa1975
pushq $0x5
popq %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x34f59
movq %rax, %r14
pushq $0x6
popq %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x34f59
movq %rax, %r15
pushq $0x7
popq %rdx
movq %r12, 0x90(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x34f59
movq %rax, %r12
pushq $0x8
popq %rdx
movl $0x80, %edi
movq %r13, %rsi
callq 0x34f59
leaq 0xf0(%rsp), %rsi
leaq 0xd0(%rsp), %r8
movq %rax, %r9
xorl %eax, %eax
movq %rbp, %rdx
testl %edx, %edx
movl $0x0, %r13d
cmovgl %edx, %r13d
leaq (%r14,%rbp,8), %rbp
leaq (%r15,%rdx,8), %rcx
movq %rdx, %rdi
movq %r12, %rdx
addq %rdi, %rdx
cmpq %rax, %r13
je 0x82faf
andq $0x0, (%r14,%rax,8)
movsd 0x48(%rsi), %xmm0
movq 0x8(%r8), %rdi
movapd %xmm0, %xmm1
subsd (%rdi,%rax,8), %xmm1
movsd %xmm1, (%r15,%rax,8)
movb $0x1, (%r12,%rax)
andq $0x0, (%rbp,%rax,8)
addsd (%rdi,%rax,8), %xmm0
movsd %xmm0, (%rcx,%rax,8)
movb $-0x1, (%rdx,%rax)
incq %rax
jmp 0x82f6f
movsd 0x30(%rsi), %xmm0
leaq 0x28(%rsp), %rdi
pushq $0xb
popq %rcx
rep  movsq (%rsi), %es:(%rdi)
movups (%r8), %xmm1
movups 0x10(%r8), %xmm2
movups %xmm2, 0x18(%rsp)
movups %xmm1, 0x8(%rsp)
movq 0x88(%rsp), %rax
movq %rax, (%rsp)
andl $0x0, 0x80(%rsp)
pushq $0x1
popq %rdx
movq %r9, 0x88(%rsp)
movq %r9, %rdi
movq 0x90(%rsp), %rsi
movq %r15, %rcx
movq %r12, %r8
movq %r14, %r9
movapd %xmm0, %xmm1
callq 0x88454
xorl %eax, %eax
cmpq %rax, %r13
je 0x8302b
movsd (%r14,%rax,8), %xmm0
subsd (%rbp,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x83010
movq 0x88(%rsp), %rdi
callq 0x34ff7
movq %r14, %rdi
callq 0x34ff7
movq %r15, %rdi
callq 0x34ff7
movq %r12, %rdi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/svm.c
// Function: svm_group_classes
int svm_group_classes(Svm_problem prob, int **start_ret, int **count_ret, int *perm)
{
	/*Last Changed 02.05.2005*/
	int l,  *count, *data_label, i, classno, *start, classes[MAXCLASSES], nr_class = 0;
 l = prob.l;
 for (i = 0; i < l; i++)
	  search_and_add_into_list(classes, &nr_class, (int)prob.y[i]);
 count = safecalloc(nr_class, sizeof(int), "svm_group_classes", 5);
	data_label = safemalloc(l * sizeof(int), "svm_group_classes", 6);
	for (i = 0; i < l; i++)
	 {
		 classno = search_list(classes, nr_class, (int)prob.y[i]);
			(count[classno])++;
		 data_label[i] = classno;
	 }
	start = safemalloc(nr_class * sizeof(int), "svm_group_classes", 11);
	start[0] = 0;
	for (i = 1;i < nr_class; i++)
		 start[i] = start[i - 1] + count[i - 1];
	for (i = 0; i < l; i++)
	 {
 		perm[start[data_label[i]]] = i;
		 ++start[data_label[i]];
	 }
	start[0] = 0;
	for (i = 1;i < nr_class; i++)
		 start[i] = start[i - 1] + count[i - 1];
	*start_ret = start;
	*count_ret = count;
	safe_free(data_label);
 return nr_class;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0x4(%rsp), %r12
andl $0x0, (%r12)
movslq 0x120(%rsp), %r13
movq 0x128(%rsp), %r14
xorl %r15d, %r15d
testl %r13d, %r13d
movl $0x0, %ebx
cmovgl %r13d, %ebx
leaq 0x20(%rsp), %rbp
cmpq %r15, %rbx
je 0x83520
cvttsd2si (%r14,%r15,8), %edx
movq %rbp, %rdi
movq %r12, %rsi
callq 0x33ae1
incq %r15
jmp 0x83505
movslq 0x4(%rsp), %rdi
leaq 0x1e49d(%rip), %rbp     # 0xa19c9
pushq $0x4
popq %rsi
pushq $0x5
popq %rcx
movq %rbp, %rdx
callq 0x35067
movq %rax, %r12
shlq $0x2, %r13
pushq $0x6
popq %rdx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x34f59
movq %rax, %r13
xorl %r15d, %r15d
leaq 0x20(%rsp), %rbp
movslq 0x4(%rsp), %rsi
cmpq %r15, %rbx
je 0x83582
cvttsd2si (%r14,%r15,8), %edx
movq %rbp, %rdi
callq 0x33b22
cltq
incl (%r12,%rax,4)
movl %eax, (%r13,%r15,4)
incq %r15
jmp 0x8355a
shlq $0x2, %rsi
leaq 0x1e43c(%rip), %rax     # 0xa19c9
pushq $0xb
popq %rdx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x34f59
andl $0x0, (%rax)
pushq $0x1
popq %rcx
xorl %edx, %edx
movslq 0x4(%rsp), %rsi
cmpq %rsi, %rcx
jge 0x835ba
addl -0x4(%r12,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0x835a3
xorl %ecx, %ecx
movq 0x8(%rsp), %rsi
cmpq %rcx, %rbx
je 0x835df
movslq (%r13,%rcx,4), %rdx
movslq (%rax,%rdx,4), %rdx
movl %ecx, (%rsi,%rdx,4)
movslq (%r13,%rcx,4), %rdx
incl (%rax,%rdx,4)
incq %rcx
jmp 0x835c1
andl $0x0, (%rax)
pushq $0x1
popq %rcx
xorl %edx, %edx
movslq 0x4(%rsp), %rsi
cmpq %rsi, %rcx
jge 0x835fe
addl -0x4(%r12,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0x835e7
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq 0x18(%rsp), %rax
movq %r12, (%rax)
movq %r13, %rdi
callq 0x34ff7
movl 0x4(%rsp), %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/svm.c
// Function: sigmoid_predict
double sigmoid_predict(double decision_value, double A, double B)
{
 double fApB = decision_value * A + B;
 if (fApB >= 0)
   return exp(-fApB) / (1.0 + exp(-fApB));
 else
   return 1.0 / (1 + exp(fApB)) ;
}

// Assembly:
subq $0x28, %rsp
movapd %xmm0, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
jae 0x84cd7
movsd 0x1084b(%rip), %xmm0    # 0x95520
jmp 0x84cf4
xorpd 0x114f1(%rip), %xmm3    # 0x961d0
movapd %xmm3, 0x10(%rsp)
movapd %xmm3, %xmm0
callq 0x4060
movapd 0x10(%rsp), %xmm3
movsd %xmm0, 0x8(%rsp)
movapd %xmm3, %xmm0
callq 0x4060
addsd 0x10815(%rip), %xmm0    # 0x95520
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/svm.c
// Function: svm_predict_probability
void svm_predict_probability(Svm_modelptr model, Svm_nodeptr x, double* prob_estimates)
{
 /*Last Changed 04.01.2006*/
 int i, j, nr_class, k = 0;
 double *dec_values, min_prob = 1e-7, **pairwise_prob;
 nr_class = model->nr_class;
 dec_values = safemalloc((nr_class * (nr_class - 1) / 2) * sizeof(double), "svm_predict_probability", 4);
 svm_predict_values(model, x, dec_values);
 pairwise_prob = (double **) safemalloc_2d(sizeof(double*), sizeof(double), nr_class, nr_class, "svm_predict_probability", 6);
 for (i = 0; i < nr_class; i++)
   for (j = i + 1; j < nr_class; j++)
    {
     pairwise_prob[i][j] = fmin(fmax(sigmoid_predict(dec_values[k], model->probA[k], model->probB[k]), min_prob), 1 - min_prob);
     pairwise_prob[j][i] = 1 - pairwise_prob[i][j];
     k++;
    }
 multiclass_probability(nr_class, pairwise_prob, prob_estimates);
 free_2d((void**)pairwise_prob, nr_class);
 safe_free(dec_values);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x30(%rsp)
movq %rsi, %r13
movq %rdi, %r15
movl 0x58(%rdi), %ebx
leal -0x1(%rbx), %eax
imull %ebx, %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0x1ca87(%rip), %rbp     # 0xa1a4e
pushq $0x4
popq %rdx
movq %rbp, %rsi
callq 0x34f59
movq %r15, %rdi
movq %r13, %rsi
movq %rax, 0x8(%rsp)
movq %rax, %rdx
callq 0x84490
pushq $0x8
popq %rdi
pushq $0x6
popq %r9
movq %rdi, 0x20(%rsp)
movq %rdi, %rsi
movl %ebx, %edx
movl %ebx, %ecx
movq %rbp, %r8
callq 0x351c3
xorl %r14d, %r14d
testl %ebx, %ebx
movl $0x0, %ecx
movq %rbx, 0x28(%rsp)
cmovgl %ebx, %ecx
movq %rcx, 0x38(%rsp)
movq %rax, 0x10(%rsp)
addq $0x8, %rax
movq %rax, 0x18(%rsp)
pushq $0x1
popq %rbx
xorl %ecx, %ecx
cmpq 0x38(%rsp), %r14
je 0x850ea
movslq %ecx, %rcx
leaq (,%rcx,8), %r12
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rsp)
leaq (%rax,%rcx,8), %rbp
xorl %r13d, %r13d
leal (%rbx,%r13), %eax
cmpl %eax, 0x28(%rsp)
jle 0x850cb
movsd (%rbp,%r13,8), %xmm0
movq 0xa0(%r15), %rax
addq %r12, %rax
movsd (%rax,%r13,8), %xmm1
movq 0xa8(%r15), %rax
addq %r12, %rax
movsd (%rax,%r13,8), %xmm2
callq 0x84cb3
maxsd 0x1c899(%rip), %xmm0    # 0xa1928
minsd 0x1c899(%rip), %xmm0    # 0xa1930
movq 0x10(%rsp), %rax
movq (%rax,%r14,8), %rax
addq 0x20(%rsp), %rax
movsd %xmm0, (%rax,%r13,8)
movsd 0x1046d(%rip), %xmm1    # 0x95520
subsd %xmm0, %xmm1
movq 0x18(%rsp), %rax
movq (%rax,%r13,8), %rax
movsd %xmm1, (%rax,%r14,8)
incq %r13
jmp 0x85051
incq %r14
incq %rbx
addq $0x8, 0x18(%rsp)
addq $0x8, 0x20(%rsp)
movq 0x40(%rsp), %rcx
addq %r13, %rcx
jmp 0x8502a
movq 0x28(%rsp), %rbx
movl %ebx, %edi
movq 0x10(%rsp), %r14
movq %r14, %rsi
movq 0x30(%rsp), %rdx
callq 0x84d1e
movq %r14, %rdi
movl %ebx, %esi
callq 0x34fc3
movq 0x8(%rsp), %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/svm.c
// Function: svm_predict
double svm_predict(Svm_modelptr model, Svm_nodeptr x)
{
	/*Last Changed 02.05.2005*/
 int i, j, nr_class, *vote, pos = 0, vote_max_idx;
	double res, *dec_values;
	if (in_list(model->param.svm_type, 3, ONE_CLASS, EPSILON_SVR, NU_SVR))
	 {
		 svm_predict_values(model, x, &res);		
		 if (model->param.svm_type == ONE_CLASS)
				 if (res > 0)
						 return 1;
					else
						 return -1;
		 else
			  return res;
	 }
	else
	 {
		 nr_class = model->nr_class;
		 dec_values = safemalloc(sizeof(double) * nr_class * (nr_class-1) / 2, "svm_predict", 17);
		 svm_predict_values(model, x, dec_values);
		 vote = safemalloc(sizeof(int) * nr_class, "svm_predict", 19);
		 for (i = 0; i < nr_class; i++)
			  vote[i] = 0;
		 for (i = 0; i < nr_class; i++)
  			for (j = i + 1; j < nr_class; j++)
					 {
				   if (dec_values[pos] > 0)
    					++vote[i];
			   	else
					    ++vote[j];
				   pos++;
					 }  
		 vote_max_idx = 0;
		 for (i = 1; i < nr_class; i++)
			  if (vote[i] > vote[vote_max_idx])
				   vote_max_idx = i;
		 safe_free(vote);
		 safe_free(dec_values);
		 return vote_max_idx;
	 }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %edi
xorl %ebp, %ebp
pushq $0x2
popq %rdx
pushq $0x3
popq %rcx
pushq $0x4
popq %r8
movl %ecx, %esi
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0x8518e
movq %rsp, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x84490
cmpl $0x2, (%r14)
movsd (%rbx), %xmm0
jne 0x8526f
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
leaq 0x1137c(%rip), %rcx     # 0x96500
movsd (%rcx,%rax,8), %xmm0
jmp 0x8526f
movslq 0x58(%r14), %r13
leaq -0x1(%r13), %rax
imulq %r13, %rax
shlq $0x2, %rax
movabsq $0x7ffffffffffffffc, %rdi # imm = 0x7FFFFFFFFFFFFFFC
andq %rax, %rdi
leaq 0x1c8b4(%rip), %r12     # 0xa1a66
pushq $0x11
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x84490
leaq (,%r13,4), %rdi
pushq $0x13
popq %rdx
movq %r12, %rsi
callq 0x34f59
testl %r13d, %r13d
movl $0x0, %ecx
cmovgl %r13d, %ecx
cmpq %rbp, %rcx
je 0x851fb
andl $0x0, (%rax,%rbp,4)
incq %rbp
jmp 0x851ed
pushq $0x1
popq %rdx
xorl %esi, %esi
xorpd %xmm0, %xmm0
xorl %edi, %edi
cmpq %rcx, %rsi
je 0x8523b
movslq %edi, %rdi
movq %rdx, %r8
cmpl %r8d, %r13d
jle 0x85233
movsd (%rbx,%rdi,8), %xmm1
ucomisd %xmm0, %xmm1
movq %rsi, %r9
ja 0x85227
movq %r8, %r9
incl (%rax,%r9,4)
incq %rdi
incq %r8
jmp 0x85211
incq %rsi
incq %rdx
jmp 0x85206
xorl %ebp, %ebp
pushq $0x1
popq %rcx
cmpq %r13, %rcx
jge 0x8525b
movl (%rax,%rcx,4), %esi
movslq %ebp, %rdi
movl %ecx, %edx
cmpl (%rax,%rdi,4), %esi
jg 0x85254
movl %ebp, %edx
incq %rcx
movl %edx, %ebp
jmp 0x85240
movq %rax, %rdi
callq 0x34ff7
movq %rbx, %rdi
callq 0x34ff7
cvtsi2sd %ebp, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1c7df(%rip), %r14     # 0xa1a72
pushq $0x30
popq %rdi
pushq $0x2
popq %rdx
movq %r14, %rsi
callq 0x34f59
movq %rax, %r15
movslq %ebp, %r12
pushq $0x20
popq %rsi
pushq $0x3
popq %rcx
movq %r12, %rdi
movq %r14, %rdx
callq 0x35067
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_O2/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
leaq 0x10(%rdi), %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x85308
movq 0x10(%r15), %rdi
callq 0x34ff7
addq $0x8, %r15
jmp 0x852f1
movq (%rbx), %rdi
callq 0x34ff7
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdi, %r14
movl %ecx, 0xc(%rsp)
movq (%rdi), %rax
movslq %esi, %rcx
shlq $0x5, %rcx
leaq (%rax,%rcx), %r13
movl 0x18(%rax,%rcx), %r8d
testl %r8d, %r8d
je 0x85385
movq (%r13), %rsi
movq 0x8(%r13), %rdi
movq %rdi, 0x8(%rsi)
movq %rsi, (%rdi)
movl %ebp, %r12d
subl %r8d, %r12d
jle 0x85407
movq %rdx, 0x10(%rsp)
leaq (%rax,%rcx), %r15
addq $0x18, %r15
movl 0x2c(%r14), %eax
cmpl %r12d, %eax
jge 0x853d4
movq 0x10(%r14), %rbx
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq 0x10(%rbx), %rdi
callq 0x34ff7
movl 0x2c(%r14), %eax
addl 0x18(%rbx), %eax
movl %eax, 0x2c(%r14)
andq $0x0, 0x10(%rbx)
andl $0x0, 0x18(%rbx)
jmp 0x8539e
movq 0x10(%r13), %rdi
movslq %ebp, %rsi
shlq $0x3, %rsi
movl %ebp, %edx
callq 0x34f30
movq %rax, 0x10(%r13)
subl %r12d, 0x2c(%r14)
leaq 0xc(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x3537f
movl (%r12), %ebp
movq 0x10(%rsp), %rdx
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, (%rdx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
cmpl %edx, %esi
jne 0x8545f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rax
movslq %esi, %r15
shlq $0x5, %r15
cmpl $0x0, 0x18(%rax,%r15)
je 0x8548b
leaq (%rax,%r15), %rcx
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rdx)
movq %rdx, (%rcx)
movslq %ebp, %r12
shlq $0x5, %r12
cmpl $0x0, 0x18(%rax,%r12)
je 0x854ac
leaq (%rax,%r12), %rcx
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rdx)
movq %rdx, (%rcx)
leaq (%rax,%r15), %rdi
addq $0x18, %rdi
movq -0x8(%rdi), %rcx
leaq 0x18(%rax,%r12), %rsi
movq -0x8(%rsi), %rax
movq %rax, -0x8(%rdi)
movq %rcx, -0x8(%rsi)
callq 0x3537f
movq (%rbx), %rax
cmpl $0x0, 0x18(%rax,%r15)
je 0x854f6
addq %rax, %r15
leaq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r15)
movq 0x8(%rbx), %rcx
movq %rcx, (%r15)
movq %r15, 0x8(%rcx)
movq 0x8(%r15), %rcx
movq %r15, (%rcx)
cmpl $0x0, 0x18(%rax,%r12)
je 0x8551b
addq %r12, %rax
leaq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
movq 0x8(%rax), %rcx
movq %rax, (%rcx)
cmpl %ebp, %r14d
jle 0x8552f
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3537f
leaq 0x8(%rbx), %r14
leaq 0x10(%rbx), %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x85452
movl 0x18(%r15), %ecx
movslq 0xc(%rsp), %rax
cmpl %eax, %ecx
jle 0x85594
movslq 0x8(%rsp), %rdx
cmpl %edx, %ecx
jle 0x8556c
movq 0x10(%r15), %rcx
leaq (%rcx,%rax,8), %rdi
leaq (%rcx,%rdx,8), %rsi
callq 0x35388
jmp 0x85594
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq 0x10(%r15), %rdi
callq 0x34ff7
movl 0x18(%r15), %eax
addl %eax, 0x2c(%rbx)
andq $0x0, 0x10(%r15)
andl $0x0, 0x18(%r15)
addq $0x8, %r15
jmp 0x85537
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x855ce
leaq (%rdx,%rax,8), %rdi
leaq (%rdx,%rcx,8), %rsi
jmp 0x35388
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorpd %xmm0, %xmm0
movl (%rdi), %eax
cmpl $-0x1, %eax
je 0x8560b
movl (%rsi), %ecx
cmpl $-0x1, %ecx
je 0x8560b
cmpl %ecx, %eax
je 0x855ed
jle 0x85605
addq $0x10, %rsi
jmp 0x855d5
movsd 0x8(%rdi), %xmm1
mulsd 0x8(%rsi), %xmm1
addsd %xmm1, %xmm0
addq $0x10, %rdi
addq $0x10, %rsi
jmp 0x855d3
addq $0x10, %rdi
jmp 0x855d3
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x85775
leaq 0x1c32d(%rip), %rcx     # 0xa1a80
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x8560c
jmp 0x85703
jmp 0x85665
jmp 0x856c5
jmp 0x85622
pushq %rax
leaq 0x1c32b(%rip), %rdi     # 0xa1aa8
movl %eax, %esi
xorl %eax, %eax
callq 0x4030
xorps %xmm0, %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x85743
movsd %xmm0, (%rsp)
movq %r14, %rdi
movl %ebx, %esi
movl %ebx, %edx
callq 0x85743
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x85743
movsd (%rsp), %xmm2
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jne 0x857d9
jnp 0x85812
movsd 0x8(%rsp), %xmm3
ucomisd %xmm0, %xmm3
jne 0x857e7
jnp 0x85812
mulsd %xmm3, %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jb 0x857fb
sqrtsd %xmm2, %xmm0
jmp 0x8580e
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_O2/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, %ebp
movq %rsi, %rbx
movl %edi, %r14d
leaq 0x1c287(%rip), %r13     # 0xa1ad2
pushq $0x28
popq %rdi
pushq $0x3
popq %rdx
movq %r13, %rsi
callq 0x34f59
movq %rax, %r15
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movl %r12d, 0x14(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movl %ebp, 0x10(%rax)
movslq %r14d, %r12
shlq $0x3, %r12
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x34f59
movq %rax, (%r15)
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4310
cmpl $0x2, %ebp
jne 0x858e3
leaq 0x1c227(%rip), %rsi     # 0xa1ad2
pushq $0xc
popq %rdx
movq %r12, %rdi
callq 0x34f59
movq %rax, %r12
movq %rax, 0x8(%r15)
xorl %r13d, %r13d
testl %r14d, %r14d
cmovlel %r13d, %r14d
cmpq %r13, %r14
je 0x858e8
movq (%rbx,%r13,8), %rdi
movq %rdi, %rsi
callq 0x855cf
movsd %xmm0, (%r12,%r13,8)
incq %r13
jmp 0x858c7
andq $0x0, 0x8(%r15)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 0x34ff7
cmpl $0x2, 0x10(%rbx)
jne 0x85915
movq 0x8(%rbx), %rdi
callq 0x34ff7
movq %rbx, %rdi
popq %rbx
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0xb
popq %r15
leaq 0x90(%rsp), %r12
movq %r15, %rcx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq %r14, %rsi
callq 0x8591e
movsd %xmm0, 0x58(%rsp)
movq %r15, %rcx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x8591e
movsd %xmm0, 0x60(%rsp)
movq %r15, %rcx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8591e
movsd 0x58(%rsp), %xmm1
movapd %xmm0, %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x85b18
jnp 0x85b53
movsd 0x60(%rsp), %xmm3
ucomisd %xmm0, %xmm3
jne 0x85b26
jnp 0x85b53
mulsd %xmm3, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x85b3a
sqrtsd %xmm1, %xmm0
jmp 0x85b4f
movapd %xmm1, %xmm0
movsd %xmm2, 0x58(%rsp)
callq 0x4300
movsd 0x58(%rsp), %xmm2
divsd %xmm0, %xmm2
movapd %xmm2, %xmm0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
cmpl $0x5, %esi
jne 0x85ba5
leaq 0x60(%rsp), %rax
pushq $0x2
popq %rbp
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movupd (%rax), %xmm0
movupd %xmm0, (%rsp)
callq 0x4dc2f
movq %rax, 0x20(%rsp)
jmp 0x85bb2
leaq 0x47cc4(%rip), %rax     # 0xcd870
movq (%rax), %rax
movl 0x10(%rax), %ebp
movl %ebp, 0x18(%r15)
movq %r14, %rdi
callq 0x2c3cc
movl %eax, (%r15)
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0x1bf10(%rip), %r13     # 0xa1adf
pushq $0xb
popq %rdx
movq %r13, %rsi
callq 0x34f59
movq %rax, 0x10(%r15)
movslq (%r15), %rdi
shlq $0x3, %rdi
pushq $0xc
popq %rdx
movq %r13, %rsi
callq 0x34f59
movq %rax, 0x8(%r15)
pushq $0x2
popq %rbp
pushq $0x1
popq %r13
xorl %r12d, %r12d
testq %r14, %r14
je 0x85c66
movl %ebx, %edi
movl %ebp, %esi
xorl %edx, %edx
movl %r13d, %ecx
xorl %eax, %eax
callq 0x35812
movq %r14, %rdi
testl %eax, %eax
je 0x85c25
callq 0x2b47e
cvtsi2sd %eax, %xmm0
jmp 0x85c42
cmpl $0x5, %ebx
jne 0x85c3d
callq 0x2b47e
cltq
movq 0x20(%rsp), %rcx
cvtsi2sdl (%rcx,%rax,4), %xmm0
jmp 0x85c42
callq 0x2b4a0
movq 0x8(%r15), %rax
movsd %xmm0, (%rax,%r12)
movq %r14, %rdi
callq 0x2add8
movq 0x10(%r15), %rcx
movq %rax, (%rcx,%r12)
movq 0x10(%r14), %r14
addq $0x8, %r12
jmp 0x85bfe
cmpl $0x5, %ebx
jne 0x85c83
movq 0x20(%rsp), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 0x17a29(%rip), %rdi     # 0x9d6ca
callq 0x4cd35
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x20(%rbx)
leaq 0xfaf5(%rip), %rdi      # 0x957ab
callq 0x4cdcf
movsd %xmm0, 0x30(%rbx)
leaq 0xfb86(%rip), %rdi      # 0x9584d
callq 0x4cdcf
movsd %xmm0, 0x18(%rbx)
leaq 0xfb7e(%rip), %rdi      # 0x95856
callq 0x4cd35
movl %eax, 0x8(%rbx)
movabsq $0x3f50624dd2f1a9fc, %rax # imm = 0x3F50624DD2F1A9FC
movq %rax, 0x28(%rbx)
leaq 0xfb6b(%rip), %rdi      # 0x95860
callq 0x4cdcf
movsd %xmm0, 0x10(%rbx)
leaq 0x47b6a(%rip), %rax     # 0xcd870
movq (%rax), %rax
cmpl $0x3, 0x140713c(%rax)
jne 0x85d17
pushq $0x4
popq %rax
jmp 0x85d23
leaq 0xfb24(%rip), %rdi      # 0x95842
callq 0x4cf11
movl %eax, 0x4(%rbx)
leaq 0x17660(%rip), %rdi     # 0x9d38d
callq 0x4cdcf
movsd %xmm0, 0x40(%rbx)
leaq 0xfd0a(%rip), %rdi      # 0x95a48
callq 0x4cdcf
movsd %xmm0, 0x48(%rbx)
movl $0x1, 0x50(%rbx)
xorl %eax, %eax
cmpl $0x5, %ebp
cmovnel %ebp, %eax
movl %eax, (%rbx)
leaq 0x1765c(%rip), %rdi     # 0x9d3bc
callq 0x4d088
movq %rax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1bd7e(%rip), %r15     # 0xa1b00
pushq $0x18
popq %rdi
pushq $0x2
popq %rdx
movq %r15, %rsi
callq 0x34f59
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 0x8581f
movq %rax, (%rbx)
movslq %ebp, %r12
pushq $0x4
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x34f59
movq %rax, 0x8(%rbx)
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4310
movsd 0x70(%rsp), %xmm0
mulsd 0x1bd0d(%rip), %xmm0    # 0xa1af8
cvttsd2si %xmm0, %esi
movl %r12d, %edi
callq 0x85280
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x34ff7
movq (%rbx), %rdi
callq 0x858fa
movq 0x10(%rbx), %rdi
callq 0x852e1
movq %rbx, %rdi
popq %rbx
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/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, %r12d
movl %esi, %ebx
movq %rdi, %r14
leaq 0x184ae(%rip), %rdi     # 0x9e2f9
callq 0x4cff1
movl %eax, 0xc(%rsp)
movq 0x10(%r14), %rdi
leaq 0x10(%rsp), %rdx
movl %ebx, 0x8(%rsp)
movl %ebx, %esi
movl %r12d, %ecx
callq 0x85347
cmpl %r12d, %eax
jge 0x85ecd
movslq 0x8(%rsp), %r13
movslq %eax, %r15
movslq %r12d, %r12
cmpq %r12, %r15
jge 0x85ecd
movq (%r14), %rdi
movq 0x8(%r14), %rax
movsbl (%rax,%r13), %ebp
movsbl (%rax,%r15), %ebx
cmpl $0x1, 0xc(%rsp)
jne 0x85ea6
movl 0x8(%rsp), %esi
movl %r15d, %edx
callq 0x8578b
jmp 0x85eb2
movl 0x8(%rsp), %esi
movl %r15d, %edx
callq 0x85743
imull %ebp, %ebx
cvtsi2sd %ebx, %xmm1
mulsd %xmm0, %xmm1
movq 0x10(%rsp), %rax
movsd %xmm1, (%rax,%r15,8)
incq %r15
jmp 0x85e7b
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_O2/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 0x8543a
movq (%r14), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x8559c
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_O2/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 0x1bbdf(%rip), %rsi     # 0xa1b0b
pushq $0x10
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
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 0x8581f
movq %rax, (%rbx)
movsd 0x60(%rsp), %xmm0
mulsd 0x1bb89(%rip), %xmm0    # 0xa1af8
cvttsd2si %xmm0, %esi
movl %ebp, %edi
callq 0x85280
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r12d
movl %esi, %ebx
movq %rdi, %r14
leaq 0x18338(%rip), %rdi     # 0x9e2f9
callq 0x4cff1
movl %eax, %ebp
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %rdx
movl %ebx, %esi
movl %r12d, %ecx
callq 0x85347
cmpl %r12d, %eax
jge 0x86014
movslq %eax, %r15
movslq %r12d, %r12
cmpq %r12, %r15
jge 0x86014
movq (%r14), %rdi
movl %ebx, %esi
movl %r15d, %edx
cmpl $0x1, %ebp
jne 0x85fff
callq 0x8578b
jmp 0x86004
callq 0x85743
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
jmp 0x85fe6
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1bac2(%rip), %r12     # 0xa1b1b
pushq $0x40
popq %rdi
pushq $0x3
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, %rbx
movl 0x30(%rsp), %eax
movslq %eax, %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 0x8581f
movq %rax, (%rbx)
movl %r14d, 0x8(%rbx)
movsd 0x70(%rsp), %xmm0
mulsd 0x1ba51(%rip), %xmm0    # 0xa1af8
cvttsd2si %xmm0, %esi
movl %r14d, %edi
callq 0x85280
movq %rax, 0x10(%rbx)
leaq (%r14,%r14), %r15
pushq $0x7
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x34f59
movq %rax, 0x18(%rbx)
leaq (,%r14,8), %rdi
pushq $0x8
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, 0x20(%rbx)
xorl %eax, %eax
testl %r14d, %r14d
movl $0x0, %ecx
cmovgl %r14d, %ecx
leaq (,%r14,4), %rdx
cmpq %rax, %rcx
je 0x86125
movq 0x18(%rbx), %rsi
movb $0x1, (%rsi,%rax)
movq 0x18(%rbx), %rsi
addq %r14, %rsi
movb $-0x1, (%rax,%rsi)
movq 0x20(%rbx), %rsi
leaq (%rsi,%rax,4), %rdi
movl %eax, (%rsi,%rax,4)
movl %eax, (%rdx,%rdi)
incq %rax
jmp 0x860fa
shlq $0x3, %r15
leaq 0x1b9eb(%rip), %r14     # 0xa1b1b
pushq $0x10
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x34f59
movq %rax, 0x30(%rbx)
pushq $0x11
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x34f59
movq %rax, 0x38(%rbx)
andl $0x0, 0x28(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x858fa
movq 0x10(%rbx), %rdi
callq 0x852e1
movq 0x18(%rbx), %rdi
callq 0x34ff7
movq 0x20(%rbx), %rdi
callq 0x34ff7
movq 0x30(%rbx), %rdi
callq 0x34ff7
movq 0x38(%rbx), %rdi
callq 0x34ff7
movq %rbx, %rdi
popq %rbx
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/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 0x18136(%rip), %rdi     # 0x9e2f9
callq 0x4cff1
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 0x85347
movl 0x8(%r14), %ecx
cmpl %ecx, %eax
jge 0x86228
xorl %r12d, %r12d
movslq %ecx, %rax
cmpq %rax, %r12
jge 0x86228
movq (%r14), %rdi
movl %r15d, %esi
movl %r12d, %edx
cmpl $0x1, %ebp
jne 0x86210
callq 0x8578b
jmp 0x86215
callq 0x85743
movq (%rsp), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
movl 0x8(%r14), %ecx
jmp 0x861f3
movslq 0x28(%r14), %rcx
movq 0x30(%r14,%rcx,8), %rax
pushq $0x1
popq %rdx
subl %ecx, %edx
movl %edx, 0x28(%r14)
movq 0x18(%r14), %rcx
movsbl (%rcx,%r13), %edx
movq (%rsp), %rsi
xorl %edi, %edi
testl %ebx, %ebx
cmovlel %edi, %ebx
cmpq %rdi, %rbx
je 0x86279
movsbl (%rcx,%rdi), %r8d
imull %edx, %r8d
cvtsi2sd %r8d, %xmm0
movq 0x20(%r14), %r8
movslq (%r8,%rdi,4), %r8
mulsd (%rsi,%r8,8), %xmm0
movsd %xmm0, (%rax,%rdi,8)
incq %rdi
jmp 0x8624e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq