LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/pstricks.c
// Function: write_dashed_line_pstricks
void write_dashed_line_pstricks(FILE* myfile, double startx, double starty, double endx, double endy, int dashedtype)
{
 switch (dashedtype)
  {
   case 0:fprintf(myfile, "\\psline[linestyle=solid](%f,%f)(%f,%f)\n", startx, starty, endx, endy);
          break;
   case 1:fprintf(myfile, "\\psline[linestyle=dashed,dash=4pt 1pt](%f,%f)(%f,%f)\n", startx, starty, endx, endy);
          break;
   case 2:fprintf(myfile, "\\psline[linestyle=dashed,dash=1pt 2pt](%f,%f)(%f,%f)\n", startx, starty, endx, endy);
          break;
   case 3:fprintf(myfile, "\\psline[linestyle=dotted](%f,%f)(%f,%f)\n", startx, starty, endx, endy);
          break;
   case 4:fprintf(myfile, "\\psline[linestyle=dashed,dash=10pt 1pt](%f,%f)(%f,%f)\n", startx, starty, endx, endy);
          break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x4, %rax
ja 0x9a541
movq -0x38(%rbp), %rax
leaq 0x51045(%rip), %rcx     # 0xeb4b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
movsd -0x28(%rbp), %xmm3
leaq 0x512d2(%rip), %rsi     # 0xeb769
movb $0x4, %al
callq 0x4280
jmp 0x9a541
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
movsd -0x28(%rbp), %xmm3
leaq 0x512cf(%rip), %rsi     # 0xeb791
movb $0x4, %al
callq 0x4280
jmp 0x9a541
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
movsd -0x28(%rbp), %xmm3
leaq 0x512dd(%rip), %rsi     # 0xeb7c7
movb $0x4, %al
callq 0x4280
jmp 0x9a541
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
movsd -0x28(%rbp), %xmm3
leaq 0x512eb(%rip), %rsi     # 0xeb7fd
movb $0x4, %al
callq 0x4280
jmp 0x9a541
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
movsd -0x28(%rbp), %xmm3
leaq 0x512ec(%rip), %rsi     # 0xeb826
movb $0x4, %al
callq 0x4280
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rbf.c
// Function: allocate_rbfnetwork
Rbfnetworkptr allocate_rbfnetwork(Rbf_parameterptr params)
{
	/*!Last Changed 19.08.2007*/
	Rbfnetworkptr network;
	network = safemalloc(sizeof(Rbfnetwork), "allocate_rbfnetwork", 2);
	network->hidden = params->hidden;
	network->output = params->output;
	network->input = params->input;
 allocate_rbfweights(&(network->weights), params);
	return network;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x40, %edi
leaq 0x4ec29(%rip), %rsi     # 0xebe31
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
callq 0x9d120
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rbf.c
// Function: initialize_rbfnetwork
void initialize_rbfnetwork(Rbfnetworkptr network, Instanceptr data, Rbf_parameterptr params)
{
	/*!Last Changed 20.08.2007*/
	int i, j;
	double* spreads;
	Instanceptr clustermeans, tmp;
	clustermeans = k_means_clustering(data, params->hidden);
	tmp = clustermeans;
	for (i = 0; i < params->hidden; i++)
	 {
		 for (j = 0; j < network->input; j++)
				 network->weights.m.values[i][j] = real_feature(tmp, j);
		 tmp = tmp->next;
	 }
	spreads = cluster_spreads(data, clustermeans, params->hidden);
 for (i = 0; i < params->hidden; i++)
   network->weights.s.values[0][i] = spreads[i];
	assignTwoDimRandomWeights(&(network->weights.w), params->randrange);
	deallocate(clustermeans);
	safe_free(spreads);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x11ad0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x9d2fd
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x9d2e6
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x42c40
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9d2aa
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9d297
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edx
callq 0x119a0
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x9d354
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9d31c
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
callq 0x5a7e0
movq -0x30(%rbp), %rdi
callq 0x44510
movq -0x28(%rbp), %rdi
callq 0x52e80
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rbf.c
// Function: distance_to_rbf_gaussian
double distance_to_rbf_gaussian(Instanceptr inst, int inputdim, double* mh)
{
	/*!Last Changed 19.08.2007*/
	int j;
	double sum;
	sum = 0.0;
	for (j = 0; j < inputdim; j++)
			sum += (real_feature(inst, j) - mh[j]) * (real_feature(inst, j) - mh[j]);
	return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9d4d6
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x42c40
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x42c40
movaps %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9d472
movsd -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rbf.c
// Function: rbf_forward_propagation
void rbf_forward_propagation(Rbfnetworkptr network, Instanceptr inst, double* p, double* y)
{
	/*!Last Changed 19.08.2007*/
 double dist, s_h;
	int i, h;
	p[0] = 1.0;
	for (h = 1; h < network->hidden + 1; h++)
  {
   dist = distance_to_rbf_gaussian(inst, network->input, network->weights.m.values[h - 1]);
   s_h = network->weights.s.values[0][h - 1];
			p[h] = safeexp(-dist / (2 * s_h * s_h));
  }
	for (i = 0; i < network->output; i++)
	 {
		 y[i] = 0.0;
			for (h = 0; h < network->hidden + 1; h++)
				 y[i] += network->weights.w.values[i][h] * p[h];
	 }
	if (network->output > 1) /*For classification*/
  	softmax(y, network->output);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd 0x44b04(%rip), %xmm0    # 0xe2018
movsd %xmm0, (%rax)
movl $0x1, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x9d5cd
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x38(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
callq 0x9d450
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movl -0x38(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x45701(%rip), %xmm1    # 0xe2ca0
mulsd -0x30(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0x52a40
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x9d51f
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x9d666
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x9d656
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x9d5fb
jmp 0x9d658
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x9d5d4
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jle 0x9d680
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x7ab00
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rbf.c
// Function: real_actual_difference
double real_actual_difference(int output, Instanceptr inst, int classno, double* y)
{
	/*!Last Changed 19.08.2007*/
	double ri;
 if (output == 1)
			ri = give_regressionvalue(inst);
	else
			if (give_classno(inst) != classno)
				 ri = 0.0;
			else
					ri = 1.0;
	return ri - y[classno];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x1, -0x4(%rbp)
jne 0x9d6bc
movq -0x10(%rbp), %rdi
callq 0x43580
movsd %xmm0, -0x28(%rbp)
jmp 0x9d6e3
movq -0x10(%rbp), %rdi
callq 0x43530
cmpl -0x14(%rbp), %eax
je 0x9d6d4
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x9d6e1
movsd 0x4493c(%rip), %xmm0    # 0xe2018
movsd %xmm0, -0x28(%rbp)
jmp 0x9d6e3
movsd -0x28(%rbp), %xmm0
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rbf.c
// Function: test_rbfnetwork_cls
int test_rbfnetwork_cls(Rbfnetworkptr network, Instanceptr data)
{
	/*!Last Changed 19.08.2007*/
	double *p, *y;
	Instanceptr inst;
	int correct = 0, classno;
	p = safemalloc((network->hidden + 1) * sizeof(double), "test_rbfnetwork_cls", 3);
	y = safemalloc(network->output * sizeof(double), "test_rbfnetwork_cls", 4);
	inst = data;
	while (inst)
	 {
		 rbf_forward_propagation(network, inst, p, y);
			classno = findMaxOutput(y, network->output);
			if (classno == give_classno(inst))
				 correct++;
		 inst = inst->next;
	 }
	safe_free(p);
	safe_free(y);
	return correct;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0x4e197(%rip), %rsi     # 0xebe45
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rdi
shlq $0x3, %rdi
leaq 0x4e176(%rip), %rsi     # 0xebe45
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x9dd43
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x9d4f0
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x505f0
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
callq 0x43530
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jne 0x9dd35
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x9dce5
movq -0x18(%rbp), %rdi
callq 0x52e80
movq -0x20(%rbp), %rdi
callq 0x52e80
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/rbf.c
// Function: test_rbfnetwork_reg
double test_rbfnetwork_reg(Rbfnetworkptr network, Instanceptr data)
{
	/*!Last Changed 19.08.2007*/
	double *p, *y, squaredError = 0.0;
	Instanceptr inst;
	p = safemalloc((network->hidden + 1) * sizeof(double), "test_rbfnetwork_reg", 3);
	y = safemalloc(sizeof(double), "test_rbfnetwork_reg", 4);
	inst = data;
	while (inst)
	 {
		 rbf_forward_propagation(network, inst, p, y);
			squaredError += (y[0] - give_regressionvalue(inst)) * (y[0] - give_regressionvalue(inst));
		 inst = inst->next;
	 }
	safe_free(p);
	safe_free(y);
	return squaredError;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0x4ddff(%rip), %rsi     # 0xebe6e
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movl $0x8, %edi
leaq 0x4dde5(%rip), %rsi     # 0xebe6e
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x9e130
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x9d4f0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x30(%rbp), %rdi
callq 0x43580
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x43580
movsd -0x40(%rbp), %xmm2
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
subsd %xmm1, %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x9e09f
movq -0x18(%rbp), %rdi
callq 0x52e80
movq -0x20(%rbp), %rdi
callq 0x52e80
movsd -0x28(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: performance_initialize_regression
Regressionresultptr performance_initialize_regression(int datasize)
{
	/*!Last Changed 13.12.2004*/
 Regressionresultptr result;
 result = safemalloc(sizeof(Regressionresult), "performance_initialize_regression", 2);
	result->regressionperformance = 0;
 result->absoluteerrors = safemalloc(datasize * sizeof(double), "performance_initialize_regression", 4);
 result->datasize = datasize;
 result->epsilonloss = 0.0;
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x20, %edi
leaq 0x4be5e(%rip), %rsi     # 0xec195
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x4be35(%rip), %rsi     # 0xec195
movl $0x4, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: train_onefeature
void* train_onefeature(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
	/*!Last Changed 11.08.2005 added model for onefeature algorithm*/
	/*!Last Changed 10.12.2004*/
	char dummy;
 Model_onefeatureptr m;
	Instanceptr leftgroup = NULL, rightgroup = NULL;
	m = safemalloc(sizeof(Model_onefeature), "train_onefeature", 4);
	m->bestfeature = best_regression_feature(*trdata, &(m->bestsplit), &dummy);
	divide_instancelist_according_to_split(trdata, &leftgroup, &rightgroup, m->bestfeature, m->bestsplit);
	m->leftmean = find_mean_of_regression_value(leftgroup);
	m->rightmean = find_mean_of_regression_value(rightgroup);
	deallocate(leftgroup);
	deallocate(rightgroup);
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x20, %edi
leaq 0x4bdb7(%rip), %rsi     # 0xec1b7
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
leaq -0x19(%rbp), %rdx
callq 0xa6720
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x456d0
movq -0x30(%rbp), %rdi
callq 0x44600
movq -0x28(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x38(%rbp), %rdi
callq 0x44600
movq -0x28(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x30(%rbp), %rdi
callq 0x44510
movq -0x38(%rbp), %rdi
callq 0x44510
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: test_onefeature
Prediction test_onefeature(Instanceptr data, void* model, void* parameters, double* posterior)
{
	/*!Last Changed 11.08.2005 added model for onefeature algorithm*/
	/*!Last Changed 10.12.2004*/
	Model_onefeatureptr m;
 Prediction predicted;
	m = (Model_onefeatureptr) model;
	if (data->values[m->bestfeature].floatvalue <= m->bestsplit)
   predicted.regvalue = m->leftmean;
 else
   predicted.regvalue = m->rightmean;
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movslq (%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0xa04e9
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, (%rax)
jmp 0xa04fa
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movsd 0x18(%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: test_knnreg
Prediction test_knnreg(Instanceptr data, void* model, void* parameters, double* posterior)
{
	/*!Last Changed 19.04.2004*/
	/*!Last Changed 10.03.2004*/
	int i;
	Prediction predicted;
	Instanceptr *nearestneighbors, trdata;
	Knn_parameterptr p;
 p = (Knn_parameterptr) parameters;
	trdata = (Instanceptr) model;
 if (current_dataset->storetype == STORE_KERNEL)
   nearestneighbors = find_all_neighbors(trdata, data, &(p->nearcount));
 else
	  nearestneighbors = find_nearest_neighbors(trdata, data, p->nearcount);
	predicted.regvalue = 0;
 for (i = 0; i < p->nearcount; i++)
			predicted.regvalue += give_regressionvalue(nearestneighbors[i]);
	predicted.regvalue /= p->nearcount;
	safe_free(nearestneighbors);
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x652e9(%rip), %rax     # 0x105840
movq (%rax), %rax
cmpl $0x3, 0x140713c(%rax)
jne 0xa057a
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x46670
movq %rax, -0x30(%rbp)
jmp 0xa0591
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x40(%rbp), %rax
movl (%rax), %edx
callq 0x467e0
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x40(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xa05d6
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x43580
movq -0x50(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa05a3
movq -0x50(%rbp), %rax
movq -0x40(%rbp), %rcx
cvtsi2sdl (%rcx), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rdi
callq 0x52e80
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: train_regstump
void* train_regstump(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
	Regressionnodeptr regtreenode;
	Regtree_parameterptr p;
	p = (Regtree_parameterptr) parameters;
 regtreenode = createnewregnode(NULL, 1, p->leaftype);
 regtreenode->cvinstances = *trdata;
 regtreenode->instances = *trdata;
	regtreenode->featureno = best_hybrid_regression_tree_split(regtreenode, p);
 make_regression_children(regtreenode, p->leaftype);
 setup_regressionnode_properties(regtreenode->left, p->leaftype);
 setup_regressionnode_properties(regtreenode->right, p->leaftype);
 make_leaf_regression_node(regtreenode->left, p->leaftype);
 make_leaf_regression_node(regtreenode->right, p->leaftype);
	*trdata = NULL;
	return regtreenode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edx
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0xa6d80
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa8860
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0xa7070
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0xa75f0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0xa75f0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0xa60c0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0xa60c0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: test_regressiontree
Prediction test_regressiontree(Instanceptr data, void* model, void* parameters, double* posterior)
{
	/*!Last Changed 06.03.2005*/
	/*!Last Changed 09.12.2004*/
	Regressionnodeptr regtreenode;
 Prediction predicted;
	regtreenode = (Regressionnodeptr) model;
 while (regtreenode->featureno != -1)
   regtreenode = next_regression_node(regtreenode, data); 
 if (regtreenode->leaftype == CONSTANTLEAF)
   predicted.regvalue = regtreenode->regressionvalue;
 else
   predicted.regvalue = linear_fit_value(regtreenode->w, data);
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $-0x1, 0x68(%rax)
je 0xa0775
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xa6e20
movq %rax, -0x28(%rbp)
jmp 0xa0758
movq -0x28(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
jne 0xa0792
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movsd 0x70(%rcx), %xmm0
movsd %xmm0, (%rax)
jmp 0xa07af
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rdx
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0xa6aa0
movq -0x38(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: train_softregstump
void* train_softregstump(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
	Regressionnodeptr regtreenode;
	Softregtree_parameterptr p;
	p = (Softregtree_parameterptr) parameters;
 regtreenode = createnewregnode(NULL, 1, p->leaftype);
 regtreenode->weight = 1.0;
 regtreenode->instances = *trdata;
 if (p->leaftype == CONSTANTLEAF)
   regtreenode->regressionvalue = produce_random_value(-0.01, +0.01);
 else
   regtreenode->w = random_matrix(current_dataset->multifeaturecount, 1, -0.01, +0.01);
 regtreenode->cvinstances = NULL;
 find_best_soft_regtree_split(regtreenode, regtreenode, *trdata, p);
 make_leaf_regression_node(regtreenode->left, p->leaftype);
 make_leaf_regression_node(regtreenode->right, p->leaftype);
 if (regtreenode->featureno != LEAF_NODE)
   deallocate(regtreenode->instances);
	*trdata = NULL;
	return regtreenode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edx
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0xa6d80
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsd 0x41818(%rip), %xmm0    # 0xe2018
movsd %xmm0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xa083d
movsd 0x42233(%rip), %xmm0    # 0xe2a58
movsd 0x417f3(%rip), %xmm1    # 0xe2020
callq 0x545a0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x70(%rax)
jmp 0xa088e
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x64ff4(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %edi
movl $0x1, %esi
movsd 0x421f6(%rip), %xmm0    # 0xe2a58
movsd 0x417b6(%rip), %xmm1    # 0xe2020
callq 0x5a130
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rcx
callq 0xbe560
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0xa60c0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0xa60c0
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x68(%rax)
je 0xa08ee
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x44510
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: train_regressiontree
void* train_regressiontree(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 25.05.2006 added in_list ...*/
	/*!Last Changed 06.03.2005*/
	/*!Last Changed 09.12.2004*/
	Regressionnodeptr regtreenode;
	Regtree_parameterptr p;
	p = (Regtree_parameterptr) parameters;
 regtreenode = createnewregnode(NULL, 1, p->leaftype);
 regtreenode->cvinstances = *cvdata;
 regtreenode->instances = *trdata;
	create_regtree(regtreenode, p);
 if (in_list(p->modelselectionmethod, 3, MODEL_SELECTION_CV, MODEL_SELECTION_AIC, MODEL_SELECTION_BIC) || p->prunetype == VALIDATIONPRUNING)
  	prune_regression_tree(regtreenode, p);
	*trdata = NULL;
	return regtreenode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edx
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0xa6d80
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa8920
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edi
movl $0x3, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x2, %r8d
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
jne 0xa0a2e
movq -0x28(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0xa0a3b
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa7390
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: train_softregressiontree
void* train_softregressiontree(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
	Regressionnodeptr regtreenode;
	Softregtree_parameterptr p;
	p = (Softregtree_parameterptr) parameters;
 regtreenode = createnewregnode(NULL, 1, p->leaftype);
 regtreenode->weight = 1.0;
 regtreenode->instances = *trdata;
 if (p->leaftype == CONSTANTLEAF)
   regtreenode->regressionvalue = produce_random_value(-0.01, +0.01);
 else
   regtreenode->w = random_matrix(current_dataset->multifeaturecount, 1, -0.01, +0.01);
 create_softregtree(regtreenode, regtreenode, *cvdata, p);
 if (regtreenode->featureno != LEAF_NODE)
   deallocate(regtreenode->instances);
 deallocate(*cvdata);
	*trdata = NULL;
	return regtreenode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edx
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0xa6d80
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsd 0x41588(%rip), %xmm0    # 0xe2018
movsd %xmm0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xa0acd
movsd 0x41fa3(%rip), %xmm0    # 0xe2a58
movsd 0x41563(%rip), %xmm1    # 0xe2020
callq 0x545a0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x70(%rax)
jmp 0xa0b1e
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x64d64(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %edi
movl $0x1, %esi
movsd 0x41f66(%rip), %xmm0    # 0xe2a58
movsd 0x41526(%rip), %xmm1    # 0xe2020
callq 0x5a130
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rcx
callq 0xbeb60
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x68(%rax)
je 0xa0b4d
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x44510
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x44510
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: train_svmregtree
void* train_svmregtree(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 01.11.2009*/
 Regressionnodeptr regtreenode;
 Regtree_parameterptr p;
 p = (Regtree_parameterptr) parameters;
 regtreenode = createnewregnode(NULL, 1, p->leaftype);
 regtreenode->cvinstances = *cvdata;
 regtreenode->instances = *trdata;
 create_svmregtree(regtreenode, p);
 if (in_list(p->modelselectionmethod, 3, MODEL_SELECTION_CV, MODEL_SELECTION_AIC, MODEL_SELECTION_BIC) || p->prunetype == VALIDATIONPRUNING)
   prune_regression_tree(regtreenode, p);
 *trdata = NULL;
 return regtreenode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edx
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0xa6d80
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xcbf60
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edi
movl $0x3, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x2, %r8d
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
jne 0xa0bfe
movq -0x28(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0xa0c0b
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa7390
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: test_rbfreg
Prediction test_rbfreg(Instanceptr data, void* model, void* parameters, double* posterior)
{
	Rbfnetworkptr network;
	double *p;
 Prediction predicted;
	network = (Rbfnetworkptr) model;
	p = safemalloc((network->hidden + 1) * sizeof(double), "test_rbfreg", 4);
	rbf_forward_propagation(network, data, p, &(predicted.regvalue));
	safe_free(p);
	return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0x4b4c9(%rip), %rsi     # 0xec1c8
movl $0x4, %edx
callq 0x52d70
movq -0x40(%rbp), %rcx
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x9d4f0
movq -0x30(%rbp), %rdi
callq 0x52e80
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: test_mlpgenericreg
Prediction test_mlpgenericreg(Instanceptr data, void* model, void* parameters, double* posterior)
{
	/*!Last Changed 08.12.2004 added matrix_free(cv)*/
 Mlpnetwork neuralnetwork;
	matrix test, testY, output_error;
 Prediction predicted;
 neuralnetwork = *((Mlpnetworkptr) model);
 output_error = matrix_alloc(1, 1);
	test = instancelist_to_matrix(data, REGRESSION, -1, MULTIVARIATE_LINEAR);
 testMlpnInput_reg(test.values[0], &testY, neuralnetwork, &output_error);
 matrix_free(output_error);
 matrix_free(testY);
	matrix_free(test);
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x110(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
movl $0x98, %edx
callq 0x42b0
movl $0x1, %esi
movl %esi, %edi
callq 0x57fc0
movq %rax, -0xf8(%rbp)
movq %rdx, -0xf0(%rbp)
movq -0xf8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x44720
movq %rax, -0x108(%rbp)
movq %rdx, -0x100(%rbp)
movq -0x108(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x100(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x118(%rbp)
movq %rsp, %rdi
movl $0x13, %ecx
leaq -0xb8(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x118(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
leaq -0xe8(%rbp), %rdx
callq 0x64e70
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
callq 0x59ea0
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0x59ea0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x59ea0
movq -0x110(%rbp), %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: train_dncreg
void* train_dncreg(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 16.04.2007*/
 Mlpparameters mlpparams;
 Mlpnetworkptr neuralnetwork;
 matrix train;
 neuralnetwork = safemalloc(sizeof(Mlpnetwork), "train_dncreg", 4);
 mlpparams = *((Mlpparametersptr) parameters);
 mlpparams.inputnum = data_size(*trdata);
 mlpparams.trnum = mlpparams.inputnum;
 train = instancelist_to_matrix(*trdata, REGRESSION, -1, MULTIVARIATE_LINEAR);
 *neuralnetwork = dnc_reg(train, &mlpparams);
 matrix_free(train);
 return neuralnetwork;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x98, %edi
leaq 0x4b1a5(%rip), %rsi     # 0xec1e8
movl $0x4, %edx
callq 0x52d70
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x90, %edx
callq 0x42b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x449f0
movl %eax, -0xa0(%rbp)
movl -0xa0(%rbp), %eax
movl %eax, -0x98(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x44720
movq %rax, -0xd0(%rbp)
movq %rdx, -0xc8(%rbp)
movq -0xd0(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x170(%rbp)
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x168(%rbp), %rdi
leaq -0xa8(%rbp), %rcx
callq 0x657f0
movq -0x170(%rbp), %rdi
leaq -0x168(%rbp), %rsi
movl $0x98, %edx
callq 0x42b0
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x59ea0
movq -0xb0(%rbp), %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: test_gprocessreg
Prediction test_gprocessreg(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 15.01.2009*/
 int i;
 Prediction predicted;
 Gprocess_parameterptr gp;
 Model_gprocessregressionptr m;
 Instanceptr tmp;
 Svm_parameter param;
 Svm_nodeptr x, y;
 predicted.regvalue = 0.0;
 gp = (Gprocess_parameterptr) parameters;
 param.kernel_type = gp->kernel_type;
 param.coef0 = gp->coef0;
 param.gamma = gp->gamma;
 param.degree = gp->degree;
 m = (Model_gprocessregressionptr) model;
 y = instance_to_svmnode(data);
 tmp = m->data;
 for (i = 0; i < m->size; i++)
  {
   x = instance_to_svmnode(tmp);
   predicted.regvalue += k_function(x, y, param) * m->weights[i];
   safe_free(x);
   tmp = tmp->next;
  }
 safe_free(y);
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x94(%rbp)
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
movq -0x30(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x42b00
movq %rax, -0xa8(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xa1707
movq -0x40(%rbp), %rdi
callq 0x42b00
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0x48(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x50(%rax)
movups -0x58(%rbp), %xmm0
movups %xmm0, 0x40(%rax)
movups -0x98(%rbp), %xmm0
movups -0x88(%rbp), %xmm1
movups -0x78(%rbp), %xmm2
movups -0x68(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xcaa90
movq -0xb8(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x24(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm2
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0xa0(%rbp), %rdi
callq 0x52e80
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa164f
movq -0xa8(%rbp), %rdi
callq 0x52e80
movq -0xb0(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: test_linearregression
Prediction test_linearregression(Instanceptr data, void* model, void* parameters, double* posterior)
{
	/*!Last Changed 10.12.2004*/
	Model_linearregressionptr m;
	int i;
 Prediction predicted;
 predicted.regvalue = 0.0;
	m = (Model_linearregressionptr) model;
	for (i = 0; i < current_dataset->multifeaturecount - 1; i++)
		 predicted.regvalue += real_feature(data, i) * m->w.values[0][i];
	predicted.regvalue += m->b;
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, (%rdi)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
leaq 0x63d2d(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
movl 0x1c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xa1b62
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x42c40
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx), %rcx
movslq -0x2c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm2
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa1b09
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rdx
movsd (%rdx), %xmm0
addsd (%rcx), %xmm0
movsd %xmm0, (%rcx)
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: test_quantizereg
Prediction test_quantizereg(Instanceptr data, void* model, void* parameters, double* posterior)
{
	/*!Last Changed 21.12.2004*/
	Model_quantizeregptr m;
	int x, y;
	double xvalue, yvalue;
 Prediction predicted;
	m = (Model_quantizeregptr) model;
	if (current_dataset->featurecount > 2)
		{
   dimension_reduce_with_pca(data, 2, m->eigenvectors);
			xvalue = real_feature(data, 0);
			yvalue = real_feature(data, 1);
			x = (int) ((xvalue - m->minx) / m->binx);
   check_and_put_in_between(&x, 0, m->partitioncount - 1);
			y = (int) ((yvalue - m->miny) / m->biny);
   check_and_put_in_between(&y, 0, m->partitioncount - 1);
   predicted.regvalue = m->meanstwo[x][y];
		}
	else
		{
			xvalue = real_feature(data, 0);
   x = (int) ((xvalue - m->minx) / m->binx);
   check_and_put_in_between(&x, 0, m->partitioncount - 1);
   predicted.regvalue = m->meansone[x];
  }
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x630d1(%rip), %rax     # 0x105840
movq (%rax), %rax
cmpl $0x2, 0x1bc(%rax)
jle 0xa2844
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rdx
movq 0x38(%rax), %rcx
movl $0x2, %esi
callq 0x170d0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x42c40
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x42c40
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
movq -0x28(%rbp), %rax
subsd (%rax), %xmm0
movq -0x28(%rbp), %rax
divsd 0x8(%rax), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl 0x40(%rax), %edx
subl $0x1, %edx
leaq -0x2c(%rbp), %rdi
xorl %esi, %esi
callq 0x53ac0
movsd -0x40(%rbp), %xmm0
movq -0x28(%rbp), %rax
subsd 0x10(%rax), %xmm0
movq -0x28(%rbp), %rax
divsd 0x18(%rax), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl 0x40(%rax), %edx
subl $0x1, %edx
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x53ac0
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x28(%rcx), %rcx
movslq -0x2c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x30(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax)
jmp 0xa289f
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x42c40
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movq -0x28(%rbp), %rax
subsd (%rax), %xmm0
movq -0x28(%rbp), %rax
divsd 0x8(%rax), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl 0x40(%rax), %edx
subl $0x1, %edx
leaq -0x2c(%rbp), %rdi
xorl %esi, %esi
callq 0x53ac0
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x20(%rcx), %rcx
movslq -0x2c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax)
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: train_regrule
void* train_regrule(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
	/*!Last Changed 06.03.2005*/
	Regressionruleset* r;
	Regrule_parameterptr param;
	param = (Regrule_parameterptr) parameters;
	r = safemalloc(sizeof(Regressionruleset), "train_regrule", 4);
	*r = regression_rule_learner(trdata, cvdata, param);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x38, %edi
leaq 0x4996c(%rip), %rsi     # 0xec244
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x60(%rbp), %rdi
callq 0xa5a20
movq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x38, %edx
callq 0x42b0
movq -0x20(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/regression.c
// Function: test_regrule
Prediction test_regrule(Instanceptr data, void* model, void* parameters, double* posterior)
{
	/*!Last Changed 06.03.2005*/
	Regressionruleset r;
 Regressionruleptr rule;
 Prediction predicted;
	r = *((Regressionruleset*) model);
 rule = r.start;
 while (rule)
  {
   if (regression_rule_cover_instance(data, rule))
    {
     if (rule->leaftype == CONSTANTLEAF)
      {
       predicted.regvalue = rule->regressionvalue; 
       return predicted;
      }
     else
      {
       predicted.regvalue = linear_fit_value(rule->w, data); 
       return predicted;
      }
    }
   rule = rule->next;
  }
 if (r.leaftype == CONSTANTLEAF)
   predicted.regvalue = r.regressionvalue;
 else
   predicted.regvalue = linear_fit_value(r.w, data);
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, -0x68(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movl $0x38, %edx
callq 0x42b0
movq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0xa29bc
movq -0x8(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xa4520
cmpl $0x0, %eax
je 0xa29ae
movq -0x60(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xa2990
movq -0x70(%rbp), %rax
movq -0x60(%rbp), %rcx
movsd 0x18(%rcx), %xmm0
movsd %xmm0, (%rax)
jmp 0xa29ec
movq -0x60(%rbp), %rax
movq -0x8(%rbp), %rdx
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0xa6aa0
movq -0x70(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0xa29ec
movq -0x60(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0xa295a
cmpl $0x0, -0x38(%rbp)
jne 0xa29d1
movq -0x70(%rbp), %rax
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0xa29ea
movq -0x8(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xa6aa0
movq -0x70(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0xa29ec
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)