LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/statistics.c
// Function: construct_confusion_matrix_from_file
Confusion_matrixptr construct_confusion_matrix_from_file(char* posterior_file_name, double decision_threshold)
{
 /*!Last Changed 17.01.2009*/
 matrixptr posteriors;
 Confusion_matrixptr result;
 int i, numberofruns = get_parameter_i("runcount") * get_parameter_i("foldcount");
 result = safemalloc(numberofruns * sizeof(Confusion_matrix), "construct_confusion_matrix_from_file", 4);
 posteriors = read_posteriors(numberofruns, posterior_file_name);
 for (i = 0; i < numberofruns; i++)
  {
   result[i] = construct_confusion_matrix_from_posteriors(posteriors[i], decision_threshold);
   matrix_free(posteriors[i]);
  }
 safe_free(posteriors);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r14
leaq 0x1ab77(%rip), %rdi     # 0xaacfd
callq 0x54920
movl %eax, %ebx
leaq 0x1ea54(%rip), %rdi     # 0xaebe8
callq 0x54920
movl %eax, %ebp
imull %ebx, %ebp
movslq %ebp, %r15
movq %r15, %rdi
shlq $0x4, %rdi
leaq 0x21619(%rip), %rsi     # 0xb17c8
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %rbx
movl %r15d, %edi
movq %r14, %rsi
callq 0x85bc
movq %rax, %r14
testl %r15d, %r15d
jle 0x9020d
movl %ebp, %r15d
shlq $0x4, %r15
xorl %r12d, %r12d
movq (%r14,%r12), %rdi
movq 0x8(%r14,%r12), %rsi
movsd 0x8(%rsp), %xmm0
callq 0x900d5
movq %rax, (%rbx,%r12)
movq %rdx, 0x8(%rbx,%r12)
movq (%r14,%r12), %rdi
movq 0x8(%r14,%r12), %rsi
callq 0x3ed51
addq $0x10, %r12
cmpq %r12, %r15
jne 0x901d9
movq %r14, %rdi
callq 0x3a180
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/structure.c
// Function: simulated_annealing_bn
bayesiangraphptr simulated_annealing_bn(char *graph_name, char *train_file, char *cv_file, char *test_file, ORDERING_TYPE ordering, double infthreshold)
{/*Last Changed 09.03.2001*/
 int i = 0, j, edgecount;
 bayesiangraphptr newnetwork;
 double **edges;
 newnetwork = (bayesiangraphptr) initial_graph_from_data(graph_name, train_file, cv_file, test_file);
 if (!newnetwork)
   return NULL;
 newnetwork->independence = zero_independence_test(newnetwork);
 newnetwork->one_independence = one_independence_test(newnetwork);
 edges = find_edges(newnetwork, infthreshold, &edgecount);
 switch (ordering)
  {
   case ORDERING_RANDOM  :random_ordering(newnetwork);
                          break;
   case ORDERING_STATE   :state_ordering(newnetwork);
                          break;
   case ORDERING_MINTABLE:min_table_ordering(newnetwork, edges, edgecount);
                          break;
   case ORDERING_ALARM   :alarm_ordering(newnetwork);
                          break;
   default               :printf(m1240, ordering);
                          break;
  }
 add_arcs_according_to_ordering(newnetwork, edges, edgecount);
 make_conditional_tables(newnetwork);
 while (i < 5)
  {
   j = myrand() % 2;
   if (j)
     if (!remove_operator(newnetwork))
       i++;
     else
       i = 0;
   else
     if (!modify_operator(newnetwork))
       i++;
     else
       i = 0;
  }
 return newnetwork;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movl %r8d, %ebp
callq 0x26df6
movq %rax, %rbx
testq %rax, %rax
je 0x90313
movq %rbx, %rdi
callq 0x2e704
movq %rax, 0x30(%rbx)
movq %rbx, %rdi
callq 0x2ea99
movq %rax, 0x38(%rbx)
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x4f08d
movq %rax, %r14
cmpl $0x3, %ebp
ja 0x902be
movl %ebp, %eax
leaq 0x216e2(%rip), %rcx     # 0xb1968
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x5450c
jmp 0x902ce
movl 0x4(%rsp), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x545b5
jmp 0x902ce
movq %rbx, %rdi
callq 0x54771
jmp 0x902ce
movq %rbx, %rdi
callq 0x5452c
jmp 0x902ce
leaq 0x216c3(%rip), %rdi     # 0xb1988
movl %ebp, %esi
xorl %eax, %eax
callq 0x4030
movl 0x4(%rsp), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f4d1
movq %rbx, %rdi
callq 0x4f8a4
xorl %ebp, %ebp
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x3af20
movq %rbx, %rdi
testb $0x1, %al
jne 0x902ff
callq 0x54352
jmp 0x90304
callq 0x5420c
incl %r14d
testl %eax, %eax
cmovnel %ebp, %r14d
cmpl $0x5, %r14d
jl 0x902ea
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/svm.c
// Function: free_svm_split
void free_svm_split(Svm_split s)
{
	/*Last Changed 25.07.2005 added weights*/
	/*Last Changed 28.05.2005*/
	int i;
	safe_free(s.sv_coef);
	for (i = 0; i < s.l; i++)
		 safe_free(s.SV[i]);
	safe_free(s.SV);
	safe_free(s.weights);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x30(%rsp), %r14
movq 0x68(%r14), %rdi
callq 0x3a180
movslq 0x58(%r14), %r15
movq 0x60(%r14), %rbx
testq %r15, %r15
jle 0x90577
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
callq 0x3a180
incq %r12
cmpq %r12, %r15
jne 0x90566
movq %rbx, %rdi
callq 0x3a180
movq 0x78(%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/svm.c
// Function: free_svm_model
void free_svm_model(Svm_modelptr model)
{
 /*LAst Changed 04.01.2006 added probA and probB*/
	/*Last Changed 03.05.2005*/
	int i;
	safe_free(model->nSV);
	safe_free(model->rho);
	safe_free(model->SV);
	for (i = 0; i < model->nr_class - 1; i++)
		 safe_free(model->sv_coef[i]);
	safe_free(model->sv_coef);
 safe_free(model->probA);
 safe_free(model->probB);
	safe_free(model);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
callq 0x3a180
movq 0x70(%rbx), %rdi
callq 0x3a180
movq 0x60(%rbx), %rdi
callq 0x3a180
cmpl $0x2, 0x58(%rbx)
jl 0x905da
xorl %r14d, %r14d
movq 0x68(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x3a180
incq %r14
movslq 0x58(%rbx), %rax
decq %rax
cmpq %rax, %r14
jl 0x905be
movq 0x68(%rbx), %rdi
callq 0x3a180
movq 0xa0(%rbx), %rdi
callq 0x3a180
movq 0xa8(%rbx), %rdi
callq 0x3a180
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/svm.c
// Function: free_svm_problem
void free_svm_problem(Svm_problem prob)
{
	/*Last Changed 03.05.2005*/
	int i;
 if (prob.l > 0)
  {
	  safe_free(prob.y);
	  for (i = 0; i < prob.l; i++)
		   safe_free(prob.x[i]);
	  safe_free(prob.x);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq 0x20(%rsp), %r14
testq %r14, %r14
jle 0x9064c
leaq 0x20(%rsp), %rbx
movq 0x8(%rbx), %rdi
callq 0x3a180
movq 0x10(%rbx), %rbx
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x3a180
incq %r15
cmpq %r15, %r14
jne 0x9062e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3a180
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x98, %rsp
movsd %xmm1, 0x90(%rsp)
movsd %xmm0, 0x88(%rsp)
movq %rsi, %rbp
movq %rdi, %r14
leaq 0xd0(%rsp), %rax
movslq (%rax), %r12
leaq (,%r12,8), %rdi
leaq 0x21357(%rip), %r13     # 0xb19ec
movq %r13, %rsi
movl $0x5, %edx
callq 0x3a0e1
movq %rax, %rbx
movq %r12, %rdi
movq %r13, %rsi
movl $0x6, %edx
callq 0x3a0e1
movq %rax, %r15
movl $0x80, %edi
movq %r13, %rsi
movl $0x7, %edx
callq 0x3a0e1
movq %rax, %r13
testq %r12, %r12
jle 0x907aa
leaq 0xf0(%rsp), %rsi
movsd 0x88(%rsp), %xmm0
movsd 0x90(%rsp), %xmm1
leaq 0xd0(%rsp), %r8
movq 0x8(%r8), %rax
xorl %ecx, %ecx
movabsq $-0x4010000000000000, %rdx # imm = 0xBFF0000000000000
xorpd %xmm3, %xmm3
movq $0x0, (%r14,%rcx,8)
movq %rdx, (%rbx,%rcx,8)
movsd (%rax,%rcx,8), %xmm2
ucomisd %xmm3, %xmm2
setbe %dil
negb %dil
orb $0x1, %dil
movb %dil, (%r15,%rcx)
incq %rcx
cmpq %rcx, %r12
jne 0x9070c
leaq 0x28(%rsp), %rdi
movl $0xb, %ecx
rep  movsq (%rsi), %es:(%rdi)
movups (%r8), %xmm3
movups 0x10(%r8), %xmm2
movups %xmm2, 0x18(%rsp)
movups %xmm3, 0x8(%rsp)
movq %rbp, (%rsp)
movl $0x0, 0x80(%rsp)
movq %r13, %rdi
movl %r12d, %esi
xorl %edx, %edx
movq %rbx, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x96b2b
testl %r12d, %r12d
jle 0x9080f
xorl %eax, %eax
movsbl (%r15,%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
mulsd (%r14,%rax,8), %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0x90788
jmp 0x9080f
leaq 0x28(%rsp), %rdi
movl $0xb, %ecx
leaq 0xf0(%rsp), %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)
movq %rbp, (%rsp)
movl $0x0, 0x80(%rsp)
movq %r13, %rdi
movl %r12d, %esi
xorl %edx, %edx
movq %rbx, %rcx
movq %r15, %r8
movq %r14, %r9
movsd 0x88(%rsp), %xmm0
movsd 0x90(%rsp), %xmm1
callq 0x96b2b
movq %r13, %rdi
callq 0x3a180
movq %rbx, %rdi
callq 0x3a180
movq %r15, %rdi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/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 0x120(%rsp), %rbp
movl $0x0, 0x4(%rsp)
movslq (%rbp), %rbx
testq %rbx, %rbx
jle 0x9142a
movq 0x8(%rbp), %r14
xorl %r15d, %r15d
leaq 0x20(%rsp), %r12
leaq 0x4(%rsp), %r13
cvttsd2si (%r14,%r15,8), %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x38494
incq %r15
cmpq %r15, %rbx
jne 0x9140a
movslq 0x4(%rsp), %rdi
jmp 0x9142c
xorl %edi, %edi
leaq 0x20636(%rip), %r13     # 0xb1a69
movl $0x4, %esi
movq %r13, %rdx
movl $0x5, %ecx
callq 0x3a1fc
movq %rax, %r12
leaq (,%rbx,4), %rdi
movq %r13, %rsi
movl $0x6, %edx
callq 0x3a0e1
movq %rax, %r13
testl %ebx, %ebx
jle 0x91495
movq 0x8(%rbp), %r14
xorl %r15d, %r15d
leaq 0x20(%rsp), %rbp
movl 0x4(%rsp), %esi
cvttsd2si (%r14,%r15,8), %edx
movq %rbp, %rdi
callq 0x384d0
cltq
incl (%r12,%rax,4)
movl %eax, (%r13,%r15,4)
incq %r15
cmpq %r15, %rbx
jne 0x91470
movslq 0x4(%rsp), %rdi
shlq $0x2, %rdi
leaq 0x205c4(%rip), %rsi     # 0xb1a69
movl $0xb, %edx
callq 0x3a0e1
movl $0x0, (%rax)
cmpl $0x2, 0x4(%rsp)
jl 0x914d8
movl $0x1, %ecx
xorl %edx, %edx
addl -0x4(%r12,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
movslq 0x4(%rsp), %rsi
cmpq %rsi, %rcx
jl 0x914c3
testl %ebx, %ebx
movq 0x8(%rsp), %rsi
jle 0x914ff
xorl %ecx, %ecx
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
cmpq %rcx, %rbx
jne 0x914e3
movl $0x0, (%rax)
cmpl $0x2, 0x4(%rsp)
jl 0x91528
movl $0x1, %ecx
xorl %edx, %edx
addl -0x4(%r12,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
movslq 0x4(%rsp), %rsi
cmpq %rsi, %rcx
jl 0x91513
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq 0x18(%rsp), %rax
movq %r12, (%rax)
movq %r13, %rdi
callq 0x3a180
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_O3/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 0x92ea7
movsd 0x1267b(%rip), %xmm0    # 0xa5520
jmp 0x92ec4
xorpd 0x13321(%rip), %xmm3    # 0xa61d0
movapd %xmm3, 0x10(%rsp)
movapd %xmm3, %xmm0
callq 0x4060
movapd 0x10(%rsp), %xmm3
movsd %xmm0, 0x8(%rsp)
movapd %xmm3, %xmm0
callq 0x4060
addsd 0x12645(%rip), %xmm0    # 0xa5520
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x18(%rsp)
movq %rsi, %r13
movq %rdi, %rbx
movslq 0x58(%rdi), %r14
leal -0x1(%r14), %eax
imull %r14d, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movslq %ecx, %rdi
shlq $0x3, %rdi
leaq 0x1e901(%rip), %rbp     # 0xb1aee
movq %rbp, %rsi
movl $0x4, %edx
callq 0x3a0e1
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, 0x10(%rsp)
movq %rax, %rdx
callq 0x925b3
movl $0x8, %r15d
movl $0x8, %edi
movl $0x8, %esi
movl %r14d, %edx
movl %r14d, %ecx
movq %rbp, %r8
movl $0x6, %r9d
callq 0x3a3ac
movq %rax, %rcx
testq %r14, %r14
jle 0x9333d
movq %rcx, %rdx
addq $0x8, %rdx
leaq -0x1(%r14), %r13
xorl %eax, %eax
xorl %edi, %edi
movq %r14, 0x20(%rsp)
movq %rbx, 0x30(%rsp)
movq %rax, %r8
incq %rax
cmpq %r14, %rax
jae 0x93329
movq %rax, 0x28(%rsp)
movl %edi, 0xc(%rsp)
movslq %edi, %rdi
movq 0x10(%rsp), %rax
leaq (%rax,%rdi,8), %rax
movq %rax, 0x38(%rsp)
shlq $0x3, %rdi
movq %rdi, 0x40(%rsp)
xorl %ebp, %ebp
movq 0x38(%rsp), %rax
movsd (%rax,%rbp,8), %xmm0
movq 0xa0(%rbx), %rax
movq 0x40(%rsp), %rdi
addq %rdi, %rax
movsd (%rax,%rbp,8), %xmm1
movq 0xa8(%rbx), %rax
addq %rdi, %rax
movsd (%rax,%rbp,8), %xmm2
movq %rcx, %r12
movq %rdx, %rbx
movq %r8, %r14
callq 0x92e83
movq %r14, %r8
movsd 0x1e700(%rip), %xmm2    # 0xb19d0
movsd 0x1e6f0(%rip), %xmm1    # 0xb19c8
movq %rbx, %rdx
movq %r12, %rcx
movq 0x30(%rsp), %rbx
maxsd %xmm1, %xmm0
minsd %xmm2, %xmm0
movsd 0x1222d(%rip), %xmm1    # 0xa5520
movq (%r12,%r14,8), %rax
addq %r15, %rax
movsd %xmm0, (%rax,%rbp,8)
subsd %xmm0, %xmm1
movq (%rdx,%rbp,8), %rax
movsd %xmm1, (%rax,%r14,8)
incq %rbp
cmpq %rbp, %r13
jne 0x9328a
movl 0xc(%rsp), %edi
addl %ebp, %edi
movq 0x20(%rsp), %r14
movq 0x28(%rsp), %rax
addq $0x8, %rdx
addq $0x8, %r15
decq %r13
cmpq %r14, %rax
jne 0x93256
movl %r14d, %edi
movq %rcx, %rbx
movq %rcx, %rsi
movq 0x18(%rsp), %rdx
callq 0x92eee
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3a14b
movq 0x10(%rsp), %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %edi
movl $0x3, %esi
movl $0x2, %edx
movl $0x3, %ecx
movl $0x4, %r8d
xorl %eax, %eax
callq 0x3aa8c
testl %eax, %eax
je 0x933e7
leaq 0x8(%rsp), %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x925b3
cmpl $0x2, (%r14)
movsd (%rbx), %xmm0
jne 0x93505
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
leaq 0x13093(%rip), %rcx     # 0xa6470
movsd (%rcx,%rax,8), %xmm0
jmp 0x93505
movslq 0x58(%r14), %r13
leaq -0x1(%r13), %rax
imulq %r13, %rax
shlq $0x2, %rax
movabsq $0x7ffffffffffffffc, %rdi # imm = 0x7FFFFFFFFFFFFFFC
andq %rax, %rdi
leaq 0x1e6fb(%rip), %r12     # 0xb1b06
movq %r12, %rsi
movl $0x11, %edx
callq 0x3a0e1
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x925b3
leaq (,%r13,4), %r15
movq %r15, %rdi
movq %r12, %rsi
movl $0x13, %edx
callq 0x3a0e1
movq %rax, %r14
testq %r13, %r13
jle 0x934e7
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x4050
movq %r13, %rax
negq %rax
movl $0x1, %ecx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movq %r12, %rsi
incq %r12
cmpq %r13, %r12
jge 0x934aa
movslq %edx, %rdi
leaq (%rax,%rcx), %r8
leaq (%rbx,%rdi,8), %r9
xorl %edi, %edi
movsd (%r9,%rdi,8), %xmm1
ucomisd %xmm0, %xmm1
movq %rsi, %r10
ja 0x93499
leaq (%rcx,%rdi), %r10
incl (%r14,%r10,4)
incq %rdi
movq %r8, %r10
addq %rdi, %r10
jne 0x93486
addl %edi, %edx
incq %rcx
cmpq %r13, %r12
jne 0x9346e
xorpd %xmm0, %xmm0
cmpl $0x1, %r13d
je 0x934eb
xorl %ecx, %ecx
movl $0x1, %eax
movl (%r14,%rax,4), %esi
movslq %ecx, %rdi
movl %eax, %edx
cmpl (%r14,%rdi,4), %esi
jg 0x934d4
movl %ecx, %edx
incq %rax
movl %edx, %ecx
cmpq %rax, %r13
jne 0x934c3
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
jmp 0x934eb
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x3a180
movq %rbx, %rdi
callq 0x3a180
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1e5eb(%rip), %r14     # 0xb1b12
movl $0x30, %edi
movq %r14, %rsi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %r15
movslq %ebp, %r12
movl $0x20, %esi
movq %r12, %rdi
movq %r14, %rdx
movl $0x3, %ecx
callq 0x3a1fc
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_O3/olcaytaner[P]Isell/svmcache.c
// Function: free_cache
void free_cache(Cacheptr c)
{
	/*Last Changed 26.04.2005*/
	Cachenodeptr h;
	for (h = c->lru_head.next; h != &(c->lru_head); h = h->next)
		 safe_free(h->data);
	safe_free(c->head);
	safe_free(c);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r14, %r15
je 0x935a1
movq 0x10(%r15), %rdi
callq 0x3a180
movq 0x8(%r15), %r15
jmp 0x9358d
movq (%rbx), %rdi
callq 0x3a180
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/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 0x9361e
movq (%r13), %rsi
movq 0x8(%r13), %rdi
movq %rdi, 0x8(%rsi)
movq %rsi, (%rdi)
movl %ebp, %r12d
subl %r8d, %r12d
jle 0x936aa
movq %rdx, 0x10(%rsp)
leaq (%rax,%rcx), %r15
addq $0x18, %r15
cmpl %r12d, 0x2c(%r14)
jge 0x93677
movq 0x10(%r14), %rbx
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq 0x10(%rbx), %rdi
callq 0x3a180
movl 0x2c(%r14), %eax
addl 0x18(%rbx), %eax
movl %eax, 0x2c(%r14)
movq $0x0, 0x10(%rbx)
movl $0x0, 0x18(%rbx)
cmpl %r12d, %eax
jl 0x9363d
movq 0x10(%r13), %rdi
movslq %ebp, %rsi
shlq $0x3, %rsi
movl %ebp, %edx
callq 0x3a0b4
movq %rax, 0x10(%r13)
subl %r12d, 0x2c(%r14)
leaq 0xc(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x3a5af
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_O3/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 0x93702
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 0x9372e
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 0x9374f
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 0x3a5af
movq (%rbx), %rax
cmpl $0x0, 0x18(%rax,%r15)
je 0x93799
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 0x937be
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 0x937d2
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3a5af
leaq 0x8(%rbx), %r14
movq 0x10(%rbx), %r15
cmpq %r14, %r15
je 0x936f5
movl 0x18(%r15), %ecx
movslq 0xc(%rsp), %rax
cmpl %eax, %ecx
jle 0x9383a
movslq 0x8(%rsp), %rdx
cmpl %edx, %ecx
jle 0x9380c
movq 0x10(%r15), %rcx
leaq (%rcx,%rax,8), %rdi
leaq (%rcx,%rdx,8), %rsi
callq 0x3a5b8
jmp 0x9383a
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq 0x10(%r15), %rdi
callq 0x3a180
movl 0x18(%r15), %eax
addl %eax, 0x2c(%rbx)
movq $0x0, 0x10(%r15)
movl $0x0, 0x18(%r15)
movq 0x8(%r15), %r15
jmp 0x937da
// File: /workspace/github_c_makefile_star2_O3/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 0x93872
leaq (%rdx,%rax,8), %rdi
leaq (%rdx,%rcx,8), %rsi
jmp 0x3a5b8
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/svmkernel.c
// Function: dot
double dot(Svm_nodeptr px, Svm_nodeptr py)
{
	/*Last Changed 26.04.2005*/
	double sum = 0;
	while (px->index != -1 && py->index != -1)
	 {
 		if (px->index == py->index)
			 {
		  	sum += px->value * py->value;
		  	px++;
			  py++;
			 }
		 else
			 {
		  	if (px->index > py->index)
			  	 py++;
			  else
				   px++;
			 }			
	}
	return sum;
}

// Assembly:
movl (%rdi), %eax
xorpd %xmm0, %xmm0
cmpl $-0x1, %eax
je 0x938ad
movl (%rsi), %ecx
cmpl $-0x1, %ecx
je 0x938ad
cmpl %ecx, %eax
jne 0x9389d
movsd 0x8(%rdi), %xmm1
mulsd 0x8(%rsi), %xmm1
addsd %xmm1, %xmm0
addq $0x10, %rdi
jmp 0x9389f
jle 0x938a5
addq $0x10, %rsi
jmp 0x938a9
addq $0x10, %rdi
movl (%rdi), %eax
jmp 0x93879
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x93b08
leaq 0x1e075(%rip), %rcx     # 0xb1b20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x938ae
leaq 0x41db0(%rip), %rax     # 0xd5870
movq (%rax), %rax
movq 0x1407210(%rax), %rax
movq 0x8(%rax), %rax
movq (%rdi), %rcx
movslq %esi, %rsi
movq (%rcx,%rsi,8), %rsi
cvttsd2si 0x8(%rsi), %esi
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
cvttsd2si 0x8(%rcx), %ecx
movslq %esi, %rdx
movq (%rax,%rdx,8), %rax
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
retq
jmp 0x93970
jmp 0x939f4
jmp 0x93901
pushq %rax
leaq 0x1e038(%rip), %rdi     # 0xb1b48
movl %eax, %esi
xorl %eax, %eax
callq 0x4030
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x93a9b
movsd %xmm0, (%rsp)
movq %r14, %rdi
movl %ebx, %esi
movl %ebx, %edx
callq 0x93a9b
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x93a9b
movsd (%rsp), %xmm2
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jne 0x93b6f
jnp 0x93bab
movsd 0x8(%rsp), %xmm3
ucomisd %xmm0, %xmm3
jne 0x93b7d
jnp 0x93bab
mulsd %xmm3, %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jb 0x93b94
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
jmp 0x93ba7
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_O3/olcaytaner[P]Isell/svmkernel.c
// Function: empty_kernel
Kernelptr empty_kernel(int l, Svm_node** x, int kernel_type, int degree, double gamma, double coef0)
{
	/*Last Changed 26.04.2005*/
	Kernelptr result;
	int i;
	result = safemalloc(sizeof(Kernel), "empty_kernel", 3);
	result->coef0 = coef0;
	result->degree = degree;
	result->gamma = gamma;
	result->kernel_type = kernel_type;
	result->x = safemalloc(sizeof(Svm_nodeptr) * l, "empty_kernel", 8);
	memcpy(result->x, x, sizeof(Svm_nodeptr) * l);
	if (kernel_type == KRBF)
	 {
		 result->x_square = safemalloc(sizeof(double) * l, "empty_kernel", 12);
			for (i = 0; i < l; i++)
				 result->x_square[i] = dot(x[i], x[i]);
	 }
	else
		 result->x_square = NULL;
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movl %ecx, %r12d
movl %edx, %r15d
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1df8e(%rip), %r13     # 0xb1b72
movl $0x28, %edi
movq %r13, %rsi
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %r14
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movl %r12d, 0x14(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movl %r15d, 0x10(%rax)
movslq %ebp, %r12
shlq $0x3, %r12
movq %r12, %rdi
movq %r13, %rsi
movl $0x8, %edx
callq 0x3a0e1
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4310
cmpl $0x2, %r15d
jne 0x93cc2
leaq 0x1df26(%rip), %rsi     # 0xb1b72
movq %r12, %rdi
movl $0xc, %edx
callq 0x3a0e1
movq %rax, 0x8(%r14)
testl %ebp, %ebp
jle 0x93cca
movl %ebp, %ecx
xorl %edx, %edx
movq (%rbx,%rdx,8), %rsi
movl (%rsi), %r8d
xorpd %xmm0, %xmm0
cmpl $-0x1, %r8d
je 0x93cb3
movq %rsi, %rdi
movl %r8d, %r9d
cmpl %r9d, %r8d
jne 0x93c95
movsd 0x8(%rsi), %xmm1
mulsd 0x8(%rdi), %xmm1
addsd %xmm1, %xmm0
addq $0x10, %rsi
jmp 0x93c97
jle 0x93c9d
addq $0x10, %rdi
jmp 0x93ca1
addq $0x10, %rsi
movl (%rsi), %r8d
cmpl $-0x1, %r8d
je 0x93cb3
movl (%rdi), %r9d
cmpl $-0x1, %r9d
jne 0x93c7c
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rcx, %rdx
jne 0x93c65
jmp 0x93cca
movq $0x0, 0x8(%r14)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3a180
cmpl $0x2, 0x10(%rbx)
jne 0x93cf7
movq 0x8(%rbx), %rdi
callq 0x3a180
movq %rbx, %rdi
popq %rbx
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/svmkernel.c
// Function: k_function_normalized
double k_function_normalized(Svm_nodeptr x, Svm_nodeptr y, Svm_parameter param)
{
 double Kxx, Kyy;
 Kxx = k_function(x, x, param);
 Kyy = k_function(y, y, param);
 if (Kxx != 0 && Kyy != 0)
   return k_function(x, y, param) / sqrt(Kxx * Kyy);
 return k_function(x, y, param);
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
cmpl $0x5, %esi
jne 0x9401d
leaq 0x50(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movupd (%rax), %xmm0
movupd %xmm0, (%rsp)
movl $0x2, %ebp
callq 0x55918
movq %rax, %r12
jmp 0x9402a
leaq 0x4184c(%rip), %rax     # 0xd5870
movq (%rax), %rax
movl 0x10(%rax), %ebp
movl %ebp, 0x18(%r15)
movq %r14, %rdi
callq 0x30309
movl %eax, (%r15)
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0x1db38(%rip), %r13     # 0xb1b7f
movq %r13, %rsi
movl $0xb, %edx
callq 0x3a0e1
movq %rax, 0x10(%r15)
movslq (%r15), %rdi
shlq $0x3, %rdi
movq %r13, %rsi
movl $0xc, %edx
callq 0x3a0e1
movq %rax, 0x8(%r15)
testq %r14, %r14
je 0x940e5
xorl %r13d, %r13d
movl %ebx, %edi
movl $0x2, %esi
xorl %edx, %edx
movl $0x1, %ecx
xorl %eax, %eax
callq 0x3aa8c
movq %r14, %rdi
testl %eax, %eax
je 0x940a2
callq 0x2f33a
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
jmp 0x940be
cmpl $0x5, %ebx
jne 0x940b9
callq 0x2f33a
cltq
xorps %xmm0, %xmm0
cvtsi2sdl (%r12,%rax,4), %xmm0
jmp 0x940be
callq 0x2f35e
movq 0x8(%r15), %rax
movsd %xmm0, (%rax,%r13)
movq %r14, %rdi
callq 0x2ec9f
movq 0x10(%r15), %rcx
movq %rax, (%rcx,%r13)
movq 0x10(%r14), %r14
addq $0x8, %r13
testq %r14, %r14
jne 0x94078
cmpl $0x5, %ebx
jne 0x94100
movq %r12, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/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 0x19688(%rip), %rdi     # 0xad7a6
callq 0x54920
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x20(%rbx)
leaq 0x11678(%rip), %rdi     # 0xa57ab
callq 0x549ba
movsd %xmm0, 0x30(%rbx)
leaq 0x11709(%rip), %rdi     # 0xa584d
callq 0x549ba
movsd %xmm0, 0x18(%rbx)
leaq 0x11701(%rip), %rdi     # 0xa5856
callq 0x54920
movl %eax, 0x8(%rbx)
movabsq $0x3f50624dd2f1a9fc, %rax # imm = 0x3F50624DD2F1A9FC
movq %rax, 0x28(%rbx)
leaq 0x116ee(%rip), %rdi     # 0xa5860
callq 0x549ba
movsd %xmm0, 0x10(%rbx)
leaq 0x416ed(%rip), %rax     # 0xd5870
movq (%rax), %rcx
movl $0x4, %eax
cmpl $0x3, 0x140713c(%rcx)
je 0x941a0
leaq 0x116a7(%rip), %rdi     # 0xa5842
callq 0x54afc
movl %eax, 0x4(%rbx)
leaq 0x192bf(%rip), %rdi     # 0xad469
callq 0x549ba
movsd %xmm0, 0x40(%rbx)
leaq 0x1188d(%rip), %rdi     # 0xa5a48
callq 0x549ba
movsd %xmm0, 0x48(%rbx)
movl $0x1, 0x50(%rbx)
xorl %eax, %eax
cmpl $0x5, %ebp
cmovnel %ebp, %eax
movl %eax, (%rbx)
leaq 0x192bb(%rip), %rdi     # 0xad498
callq 0x54c89
movq %rax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x1d99e(%rip), %r15     # 0xb1ba0
movl $0x18, %edi
movq %r15, %rsi
movl $0x2, %edx
callq 0x3a0e1
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 0x93bb8
movq %rax, (%rbx)
movslq %ebp, %r12
movq %r12, %rdi
movq %r15, %rsi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, 0x8(%rbx)
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4310
movsd 0x70(%rsp), %xmm0
mulsd 0x1d927(%rip), %xmm0    # 0xb1b98
cvttsd2si %xmm0, %esi
movl %r12d, %edi
callq 0x93514
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3a180
movq (%rbx), %rdi
callq 0x93cdc
movq 0x10(%rbx), %rdi
callq 0x9357d
movq %rbx, %rdi
popq %rbx
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/svmq.c
// Function: svcq_get_Q
double* svcq_get_Q(Svcqptr s, int i, int len)
{
	/*Last Changed 27.04.2005*/
 ON_OFF normalizekernel = get_parameter_o("normalizekernel");
	double *data;
	int start, j;
	start = get_data(s->cache, i, &data, len);
	if (start < len)
	 {
			for (j = start; j < len; j++)
     if (normalizekernel == ON)
				   data[j] = (double)(s->y[i] * s->y[j] * kernel_function_normalized(s->k, i, j));
     else
       data[j] = (double)(s->y[i] * s->y[j] * kernel_function(s->k, i, j));
	 }
	return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x1a105(%rip), %rdi     # 0xae3d5
callq 0x54bec
movl %eax, 0x8(%rsp)
movq 0x10(%r14), %rdi
leaq 0x10(%rsp), %rdx
movl %ebp, %esi
movl %ebx, %ecx
callq 0x935e0
movl %ebx, 0xc(%rsp)
cmpl %ebx, %eax
jge 0x9434f
movl %ebp, %ebx
movslq %ebp, %r13
movslq %eax, %r12
movq (%r14), %rdi
movq 0x8(%r14), %rax
movsbl (%rax,%r13), %r15d
movsbl (%rax,%r12), %ebp
cmpl $0x1, 0x8(%rsp)
jne 0x9431f
movl %ebx, %esi
movl %r12d, %edx
callq 0x93b21
jmp 0x94329
movl %ebx, %esi
movl %r12d, %edx
callq 0x93a9b
imull %r15d, %ebp
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
mulsd %xmm0, %xmm1
movq 0x10(%rsp), %rax
movsd %xmm1, (%rax,%r12,8)
incq %r12
cmpl %r12d, 0xc(%rsp)
jne 0x942fb
jmp 0x94354
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_O3/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 0x936dd
movq (%r14), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x93840
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_O3/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 0x1d7fd(%rip), %rsi     # 0xb1bab
movl $0x10, %edi
movl $0x2, %edx
callq 0x3a0e1
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 0x93bb8
movq %rax, (%rbx)
movsd 0x60(%rsp), %xmm0
mulsd 0x1d7a3(%rip), %xmm0    # 0xb1b98
cvttsd2si %xmm0, %esi
movl %ebp, %edi
callq 0x93514
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/svmq.c
// Function: oneclassq_get_Q
double* oneclassq_get_Q(Oneclassqptr o, int i, int len)
{
	/*Last Changed 27.04.2005*/
 ON_OFF normalizekernel = get_parameter_o("normalizekernel");
	double *data;
	int start, j;
	start = get_data(o->cache, i, &data, len);
	if (start < len)
	 {
			for (j = start; j < len; j++)
     if (normalizekernel == ON)
				   data[j] = (double)(kernel_function_normalized(o->k, i, j));
     else
       data[j] = (double)(kernel_function(o->k, i, j));
	 }
	return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x19f8f(%rip), %rdi     # 0xae3d5
callq 0x54bec
movl %eax, %r15d
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %rdx
movl %ebp, %esi
movl %ebx, %ecx
callq 0x935e0
cmpl %ebx, %eax
jge 0x94496
movslq %eax, %r12
movq (%r14), %rdi
movl %ebp, %esi
movl %r12d, %edx
cmpl $0x1, %r15d
jne 0x9447c
callq 0x93b21
jmp 0x94481
callq 0x93a9b
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
cmpl %r12d, %ebx
jne 0x94467
jmp 0x9449b
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1d6e0(%rip), %r12     # 0xb1bbb
movl $0x40, %edi
movq %r12, %rsi
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %rbx
movslq 0x30(%rsp), %r14
movq 0x40(%rsp), %rsi
movl 0x54(%rsp), %edx
movl 0x58(%rsp), %ecx
movsd 0x60(%rsp), %xmm0
movsd 0x68(%rsp), %xmm1
movl %r14d, %edi
callq 0x93bb8
movq %rax, (%rbx)
movl %r14d, 0x8(%rbx)
movsd 0x70(%rsp), %xmm0
mulsd 0x1d66d(%rip), %xmm0    # 0xb1b98
cvttsd2si %xmm0, %esi
movl %r14d, %edi
callq 0x93514
movq %rax, 0x10(%rbx)
leaq (%r14,%r14), %r15
movq %r15, %rdi
movq %r12, %rsi
movl $0x7, %edx
callq 0x3a0e1
movq %rax, 0x18(%rbx)
leaq (,%r14,8), %rdi
movq %r12, %rsi
movl $0x8, %edx
callq 0x3a0e1
movq %rax, 0x20(%rbx)
testq %r14, %r14
jle 0x945a4
leaq (,%r14,4), %rax
xorl %ecx, %ecx
movq 0x18(%rbx), %rdx
movb $0x1, (%rdx,%rcx)
movq 0x18(%rbx), %rdx
addq %r14, %rdx
movb $-0x1, (%rcx,%rdx)
movq 0x20(%rbx), %rdx
leaq (%rdx,%rcx,4), %rsi
movl %ecx, (%rdx,%rcx,4)
movl %ecx, (%rax,%rsi)
incq %rcx
cmpq %rcx, %r14
jne 0x9457b
shlq $0x3, %r15
leaq 0x1d60c(%rip), %r14     # 0xb1bbb
movq %r15, %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x3a0e1
movq %rax, 0x30(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movl $0x11, %edx
callq 0x3a0e1
movq %rax, 0x38(%rbx)
movl $0x0, 0x28(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x93cdc
movq 0x10(%rbx), %rdi
callq 0x9357d
movq 0x18(%rbx), %rdi
callq 0x3a180
movq 0x20(%rbx), %rdi
callq 0x3a180
movq 0x30(%rbx), %rdi
callq 0x3a180
movq 0x38(%rbx), %rdi
callq 0x3a180
movq %rbx, %rdi
popq %rbx
jmp 0x3a180