LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/command.c
// Function: child_of_command
Command_nodeptr child_of_command(Command_nodeptr root, char* st)
{
	/*!Last Changed 23.10.2005*/
	Command_nodeptr tmp;
	tmp = root->child;
	while (tmp)
	 {
		 if (strIcmp(st, tmp->command) == 0)
				 return tmp;
		 tmp = tmp->next;
	 }
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x13d00
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x54990
cmpl $0x0, %eax
jne 0x13cf2
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x13d08
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x13ccc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/command.c
// Function: generate_command_tree
Command_nodeptr generate_command_tree()
{
	/*!Last Changed 23.10.2005*/
	int i;
	Command_nodeptr root, group, subgroup;
	root = safemalloc(sizeof(Command_node), "generate_command_tree", 3);
	root->child = NULL;
	root->next = NULL;
	root->command = strcopy(root->command, "COMMANDS");
	for (i = 0; i < ordercount; i++)
		 if (strcmp(orders[i].command, "!!!") != 0)
			 {
	  	 group = child_of_command(root, orders[i].command_group);
		  	if (!group)
			  	 group = add_command_child(root, orders[i].command_group);
		  	subgroup = child_of_command(group, orders[i].command_subgroup);
		  	if (!subgroup)
		  		 subgroup = add_command_child(group, orders[i].command_subgroup);
		  	add_command_child(subgroup, orders[i].command);
			 }
	return root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x18, %edi
leaq 0xcf106(%rip), %rsi     # 0xe2e3a
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xcf0e8(%rip), %rsi     # 0xe2e50
callq 0x54ba0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xf16f9(%rip), %eax     # 0x105480
jge 0x13e7f
movq 0xf16e4(%rip), %rax     # 0x105478
movslq -0x4(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
leaq 0xcf0b0(%rip), %rsi     # 0xe2e59
callq 0x4210
cmpl $0x0, %eax
je 0x13e6f
movq -0x10(%rbp), %rdi
movq 0xf16b6(%rip), %rax     # 0x105478
movslq -0x4(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x13cb0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x13e04
movq -0x10(%rbp), %rdi
movq 0xf168c(%rip), %rax     # 0x105478
movslq -0x4(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x13bc0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0xf1669(%rip), %rax     # 0x105478
movslq -0x4(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
callq 0x13cb0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x13e51
movq -0x18(%rbp), %rdi
movq 0xf163f(%rip), %rax     # 0x105478
movslq -0x4(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
callq 0x13bc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0xf161c(%rip), %rax     # 0x105478
movslq -0x4(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x13bc0
jmp 0x13e71
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x13d7e
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/command.c
// Function: print_command_node
void print_command_node(Command_nodeptr root, int level)
{
	/*!Last Changed 23.10.2005*/
	Command_nodeptr tmp;
	int i;
	for (i = 0; i < level; i++)
		 printf("\t");
	printf("%s\n", root->command);
 tmp = root->child;
	while (tmp)
	 {
		 print_command_node(tmp, level + 1);
		 tmp = tmp->next;
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x13ec7
leaq 0xda124(%rip), %rdi     # 0xedfd9
movb $0x0, %al
callq 0x4030
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13ea6
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0xd8df9(%rip), %rdi     # 0xeccce
movb $0x0, %al
callq 0x4030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x13f0c
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x13e90
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x13ee8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/command.c
// Function: deallocate_command_tree
void deallocate_command_tree(Command_nodeptr root)
{
	/*!Last Changed 23.10.2005*/
	if (root->child)
  	deallocate_command_tree(root->child);
	if (root->next)
		 deallocate_command_tree(root->next);
	safe_free(root->command);
	safe_free(root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x13f64
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x13f40
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x13f7c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x13f40
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/convex.c
// Function: copy_of_quadratic_program
Quadraticprogramptr copy_of_quadratic_program(Quadraticprogramptr src)
{
 Quadraticprogramptr dst;
 dst = safemalloc(sizeof(Quadraticprogram), "copy_of_quadratic_program", 2);
 dst->constraintcount = src->constraintcount;
 dst->m = src->m;
 dst->n = src->n;
 dst->variablecount = src->variablecount;
 dst->Q = matrix_copy(src->Q);
 dst->constraints = matrix_copy(src->constraints);
 dst->c = (double*) clone_void_array(src->c, src->n * sizeof(double));
 dst->objectives = (double*) clone_void_array(src->objectives, src->constraints.col * sizeof(double));
 dst->basic = (int*) clone_void_array(src->basic, src->constraintcount * sizeof(int));
 dst->isbasic = (BOOLEAN*) clone_void_array(src->isbasic, (src->constraints.col - 1) * sizeof(BOOLEAN));
 return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x50, %edi
leaq 0xceeb8(%rip), %rsi     # 0xe2e70
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq 0x28(%rax), %rsi
callq 0x58550
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rax), %rsi
callq 0x58550
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movslq (%rax), %rax
shlq $0x3, %rax
movl %eax, %esi
callq 0x4fa20
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x14(%rax), %rax
shlq $0x3, %rax
movl %eax, %esi
callq 0x4fa20
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rax
shlq $0x2, %rax
movl %eax, %esi
callq 0x4fa20
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
cltq
shlq $0x2, %rax
movl %eax, %esi
callq 0x4fa20
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/convex.c
// Function: is_program_in_canonical_form
BOOLEAN is_program_in_canonical_form(Linearprogramptr program)
{
 int i;
 for (i = 0; i < program->constraintcount; i++)
   if (program->constraints.values[i][program->constraints.col - 1] < 0)
     return BOOLEAN_FALSE;
 return BOOLEAN_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x14e28
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x14e1b
movl $0x0, -0x4(%rbp)
jmp 0x14e2f
jmp 0x14e1d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14ddf
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/convex.c
// Function: free_linear_program
void free_linear_program(Linearprogramptr program)
{
 safe_free(program->objectives);
 safe_free(program->isbasic);
 safe_free(program->basic);
 matrix_free(program->constraints);
 safe_free(program);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
callq 0x59ea0
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/convex.c
// Function: free_quadratic_program
void free_quadratic_program(Quadraticprogramptr program)
{
 safe_free(program->basic);
 safe_free(program->isbasic);
 safe_free(program->objectives);
 safe_free(program->c);
 matrix_free(program->Q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq 0x28(%rax), %rsi
callq 0x59ea0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/convex.c
// Function: find_variable_to_bring_into_basis
int find_variable_to_bring_into_basis(Linearprogramptr program)
{
 int i, index = -2;
 double mincoefficient = +INT_MAX;
 for (i = 0; i < program->variablecount + program->constraintcount; i++)
   if (!program->isbasic[i] && program->objectives[i] < mincoefficient)
    {
     index = i;
     mincoefficient = program->objectives[i];
    }
 if (mincoefficient == 0.0)
   return -1;
 else
   if (mincoefficient > 0.0)
     return -2;
   else
     return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0xfffffffe, -0x18(%rbp) # imm = 0xFFFFFFFE
movsd 0xcd0c9(%rip), %xmm0    # 0xe2010
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movq -0x10(%rbp), %rdx
addl 0x4(%rdx), %ecx
cmpl %ecx, %eax
jge 0x14fbe
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x14fb1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x14fb1
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x14fb3
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14f53
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x14fd7
jp 0x14fd7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14ff4
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x14fee
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x14ff4
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/convex.c
// Function: find_variable_to_remove_from_basis
int find_variable_to_remove_from_basis(matrix constraints, int constraintcount, int newbasic)
{
 int i, index = -1;
 double bi, ais, minratio = +INT_MAX;
 for (i = 0; i < constraintcount; i++)
  {
   bi = constraints.values[i][constraints.col - 1];
   ais = constraints.values[i][newbasic];
   if (ais > 0 && bi / ais < minratio)
    {
     index = i;
     minratio = bi / ais;
    }
  }
 return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movsd 0xcce1f(%rip), %xmm0    # 0xe2010
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1528a
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1527a
movsd -0x28(%rbp), %xmm1
divsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1527a
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x1527c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x151fd
movl -0x20(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/convex.c
// Function: find_variable_to_bring_into_basis_qp
int find_variable_to_bring_into_basis_qp(Quadraticprogramptr program)
{
 int i, index = -2, complementary, newnonbasic;
 double mincoefficient = +INT_MAX;
 for (i = 0; i < program->variablecount + program->constraintcount; i++)
   if (!program->isbasic[i] && program->objectives[i] < mincoefficient)
    {
     complementary = complementary_variable(program->m, program->n, i);
     newnonbasic = find_variable_to_remove_from_basis(program->constraints, program->constraintcount, i);
     if ((i >= 2 * program->m + 2 * program->n) || !program->isbasic[complementary] || (newnonbasic >= 0 && program->basic[newnonbasic] == complementary))
      {
       index = i;
       mincoefficient = program->objectives[i];
      }
    }
 if (mincoefficient == 0.0)
   return -1;
 else
   if (mincoefficient > 0.0)
     return -2;
   else
     return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0xfffffffe, -0x18(%rbp) # imm = 0xFFFFFFFE
movsd 0xccd65(%rip), %xmm0    # 0xe2010
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movq -0x10(%rbp), %rdx
addl 0x8(%rdx), %ecx
cmpl %ecx, %eax
jge 0x153b0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x153a0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x153a0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x10(%rbp), %rax
movl (%rax), %esi
movl -0x14(%rbp), %edx
callq 0x15000
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %edx
movl -0x14(%rbp), %ecx
movq 0x10(%rax), %rdi
movq 0x18(%rax), %rsi
callq 0x151d0
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
shll %ecx
movq -0x10(%rbp), %rdx
movl (%rdx), %edx
shll %edx
addl %edx, %ecx
cmpl %ecx, %eax
jge 0x15382
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x15382
cmpl $0x0, -0x20(%rbp)
jl 0x1539e
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x1c(%rbp), %eax
jne 0x1539e
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x153a0
jmp 0x153a2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x152b7
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x153c9
jp 0x153c9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x153e6
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x153e0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x153e6
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/convex.c
// Function: print_simplex_tableau
void print_simplex_tableau(matrix constraints, int* basic, double* objectives)
{
 int i, j;
 printf("------------------------------------------------\n");
 for (i = 0; i < constraints.row; i++)
  {
   printf("%3d ", basic[i]);
   for (j = 0; j < constraints.col; j++)
     printf("%7.3f ", constraints.values[i][j]);
   printf("\n");
  }
 printf("  F ");
 for (j = 0; j < constraints.col; j++)
   printf("%7.3f ", objectives[j]);
 printf("\n");
 printf("------------------------------------------------\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0xcd926(%rip), %rdi     # 0xe2ef5
movb $0x0, %al
callq 0x4030
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x15654
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0xcd930(%rip), %rdi     # 0xe2f27
movb $0x0, %al
callq 0x4030
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1563b
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0xcd903(%rip), %rdi     # 0xe2f2c
movb $0x1, %al
callq 0x4030
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x15605
leaq 0xd06f9(%rip), %rdi     # 0xe5d3b
movb $0x0, %al
callq 0x4030
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x155dd
leaq 0xcd8d8(%rip), %rdi     # 0xe2f33
movb $0x0, %al
callq 0x4030
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x15697
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0xcd8a7(%rip), %rdi     # 0xe2f2c
movb $0x1, %al
callq 0x4030
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x15669
leaq 0xd069d(%rip), %rdi     # 0xe5d3b
movb $0x0, %al
callq 0x4030
leaq 0xcd849(%rip), %rdi     # 0xe2ef5
movb $0x0, %al
callq 0x4030
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/convex.c
// Function: solve_lp
Convexsolutionptr solve_lp(Linearprogramptr program)
{
 Convexsolutionptr solution;
 Linearprogramptr newprogram;
 if (is_program_in_canonical_form(program))
   return solve_lp_with_basic_feasible_solution_using_simplex(program);
 newprogram = formulate_infeasibility_form(program);
 solution = solve_lp_with_basic_feasible_solution_using_simplex(newprogram);
 if (solution->optimalvalue <= DBL_DELTA)
  {
   drop_artificial_variables(newprogram);
   return solve_lp_with_basic_feasible_solution_using_simplex(newprogram);
  }
 return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14dd0
cmpl $0x0, %eax
je 0x15fa9
movq -0x10(%rbp), %rdi
callq 0x156c0
movq %rax, -0x8(%rbp)
jmp 0x15ff6
movq -0x10(%rbp), %rdi
callq 0x158a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x156c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsd 0xccaa1(%rip), %xmm0    # 0xe2a70
ucomisd 0x8(%rax), %xmm0
jb 0x15fee
movq -0x20(%rbp), %rdi
callq 0x15d70
movq -0x20(%rbp), %rdi
callq 0x156c0
movq %rax, -0x8(%rbp)
jmp 0x15ff6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/convex.c
// Function: solve_qp_wolfe_method
Convexsolutionptr solve_qp_wolfe_method(Quadraticprogramptr program)
{
 int iteration = 0;
 Convexsolutionptr solution, best;
 Quadraticprogramptr copy;
 double optimal;
 copy = copy_of_quadratic_program(program);
 best = solve_qp_using_simplex(copy, BOOLEAN_FALSE);
 optimal = fabs(best->optimalvalue);
 while (optimal > DBL_DELTA && iteration < 10)
  {
   free_quadratic_program(copy);
   copy = copy_of_quadratic_program(program);
   solution = solve_qp_using_simplex(copy, BOOLEAN_TRUE);
   iteration++;
   if (fabs(solution->optimalvalue) < optimal)
    {
     optimal = fabs(solution->optimalvalue);
     free_convex_solution(best);
     best = solution;
    }
   else
     free_convex_solution(solution);
  }
 free_quadratic_program(copy);
 return best;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13fa0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x16120
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movaps 0xcce21(%rip), %xmm1    # 0xe2e60
pand %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
xorl %eax, %eax
movsd 0xcca19(%rip), %xmm1    # 0xe2a70
ucomisd %xmm1, %xmm0
movb %al, -0x31(%rbp)
jbe 0x1606a
cmpl $0xa, -0xc(%rbp)
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x16076
jmp 0x16100
movq -0x28(%rbp), %rdi
callq 0x14ea0
movq -0x8(%rbp), %rdi
callq 0x13fa0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x16120
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
movaps 0xccda9(%rip), %xmm0    # 0xe2e60
pand %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x160f2
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movaps 0xccd8a(%rip), %xmm1    # 0xe2e60
pand %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x14f00
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x160fb
movq -0x18(%rbp), %rdi
callq 0x14f00
jmp 0x16048
movq -0x28(%rbp), %rdi
callq 0x14ea0
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: normalize_regression_values
void normalize_regression_values(Instanceptr myptr, double mean, double variance)
{
 /*!Last Changed 21.12.2005*/
 Instanceptr tmp;
 int classfno;
 NORMALIZATION_TYPE normtype = get_parameter_l("normalization");
 classfno = current_dataset->classdefno;
 tmp = myptr;
 while (tmp)
  {
   switch (normtype)
    {
     case        Z_NORMALIZATION:
     case   VECTOR_NORMALIZATION:tmp->values[classfno].floatvalue = (tmp->values[classfno].floatvalue - mean) / sqrt(variance);
                                 break;
     case STANDARD_NORMALIZATION:tmp->values[classfno].floatvalue = (tmp->values[classfno].floatvalue - current_dataset->features[classfno].min.floatvalue) / (current_dataset->features[classfno].max.floatvalue - current_dataset->features[classfno].min.floatvalue);
                                 break;
    }
   
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
leaq 0xccc93(%rip), %rdi     # 0xe2fe0
callq 0x792b0
movl %eax, -0x28(%rbp)
leaq 0xef4e4(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1407128(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x16482
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x1639f
jmp 0x16387
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x163e4
jmp 0x16391
movl -0x2c(%rbp), %eax
subl $0x2, %eax
jne 0x16471
jmp 0x1639f
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x42a0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
divsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x16471
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0xef445(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x24(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
subsd 0x8(%rax), %xmm0
leaq 0xef422(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x24(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movsd 0x10(%rax), %xmm1
leaq 0xef3ff(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x24(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
subsd 0x8(%rax), %xmm1
divsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x16370
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: normalize
void normalize(Instanceptr myptr, Instance mean, Instance variance)
{
 /*!Last Changed 20.03.2002*/
 Instanceptr temp;
 temp = myptr;
 while (temp)
  {
   normalize_instance(temp, mean, variance);
   temp = temp->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x16e2d
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x50(%rax)
movups %xmm1, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x16690
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x16dd7
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: realize
void realize(Instanceptr myptr)
{
 /*!Last Changed 10.03.2004 extended to regression*/
 Instanceptr tmp = myptr;
 while(tmp)
  {
   realize_instance(tmp);
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x170c2
movq -0x10(%rbp), %rdi
callq 0x16e40
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x170a4
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: distance_matrix
matrix distance_matrix(Instanceptr myptr)
{
 /*!Last Changed 17.01.2008*/
 int i, j, size;
 Instanceptr temp1, temp2;
 matrix result;
 size = data_size(myptr);
 result = matrix_alloc(size, size);
 for (i = 0, temp1 = myptr; i < size; i++, temp1 = temp1->next)
   for (j = 0, temp2 = myptr; j < size; j++, temp2 = temp2->next)
     result.values[i][j] = distance_between_instances(temp1, temp2);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x449f0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x57fc0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1735b
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x17342
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x442e0
movq -0x8(%rbp), %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)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x17301
jmp 0x17344
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x172ea
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: distance_matrix_with_threshold
matrix distance_matrix_with_threshold(Instanceptr myptr, double epsilon)
{
 /*!Last Changed 17.01.2008*/
 int i, j, size;
 Instanceptr temp1, temp2;
 matrix result;
 double distance;
 size = data_size(myptr);
 result = matrix_alloc(size, size);
 for (i = 0, temp1 = myptr; i < size; i++, temp1 = temp1->next)
   for (j = 0, temp2 = myptr; j < size; j++, temp2 = temp2->next)    
    {
     distance = distance_between_instances(temp1, temp2);
     if (distance < epsilon)
       result.values[i][j] = distance;
     else
       result.values[i][j] = +LONG_MAX;
    }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x449f0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
movl -0x2c(%rbp), %esi
callq 0x57fc0
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x17472
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x17456
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x442e0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x17420
movsd -0x48(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x1743d
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd 0xcbb78(%rip), %xmm0    # 0xe2fb0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x1743f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x173da
jmp 0x17458
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x173bf
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: find_bounds_of_feature
void find_bounds_of_feature(Datasetptr d, Instanceptr myptr, int fno, double* min, double* max)
{
 /*!Last Changed 16.09.2004*/
 Instanceptr tmp = myptr;
 double val;
 if (tmp)
  {
   if (d->features[fno].type == INTEGER)
     val = (double)tmp->values[fno].intvalue;
   else
     val = tmp->values[fno].floatvalue;
  }
 else
   val = 0;
 *min = val;
 *max = val;
 while (tmp)
  { 
   if (d->features[fno].type == INTEGER)
     val = (double)tmp->values[fno].intvalue;
   else
     val = tmp->values[fno].floatvalue;
   if (val > *max)
     *max = val;
   else
     if (val < *min)
       *min = val;
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x17931
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x14(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0x1791a
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x1792f
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x17939
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x179f8
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x14(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0x17992
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x179a7
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movq -0x28(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0x179c5
movsd -0x38(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x179e7
movsd -0x38(%rbp), %xmm1
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x179e5
movsd -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x179e7
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x17953
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: find_bounds_of_feature_class
void find_bounds_of_feature_class(Instanceptr myptr, int fno, int cno, double* min, double* max)
{
 /*oya -- Last Changed 21.4.2006*/
 Instanceptr tmp = myptr;
 double val;
 int i;
 if (tmp)
   val = tmp->values[fno].floatvalue;
 else
   val = 0;
 *min = val;
 *max = val;
 while (tmp)
  { 
   i = give_classno(tmp);
   if (i == cno)
    {
     val = tmp->values[fno].floatvalue;
     if (val > *max)
       *max = val;
     else
       if (val < *min)
         *min = val;
    }
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x17a40
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x17a48
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x17ae2
movq -0x28(%rbp), %rdi
callq 0x43530
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x10(%rbp), %eax
jne 0x17ad4
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0x17ab0
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x17ad2
movsd -0x30(%rbp), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x17ad0
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x17ad2
jmp 0x17ad4
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x17a62
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: find_thresholded_class_count
int find_thresholded_class_count(Instanceptr myptr, int classno, int fno, double fval, int dir)
{
 /*oya -- Last Changed 21.04.2006*/
 /*
 dir:LOWER val must be less than fval
 dir:UPPER val must be greater than fval
 */
 int result = 0;
 Instanceptr temp = myptr;
 double val;
 while (temp)
  {
   if (give_classno(temp) == classno)
    {
     val = temp->values[fno].floatvalue;
     if ((dir == LOWER) && (val < fval))
       result++;
     else 
       if ((dir == UPPER) && (val > fval))
         result++;
     }
   temp = temp->next;
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x17b91
movq -0x28(%rbp), %rdi
callq 0x43530
cmpl -0xc(%rbp), %eax
jne 0x17b83
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x17b64
movsd -0x30(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x17b64
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x17b81
cmpl $0x1, -0x1c(%rbp)
jne 0x17b7f
movsd -0x30(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x17b7f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x17b81
jmp 0x17b83
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x17b19
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: find_class_count
int find_class_count(Instanceptr myptr, int classno)
{
 /*!Last Changed 03.12.2003*/
 int result = 0;
 Instanceptr temp = myptr;
 while (temp)
  {
   if (give_classno(temp) == classno)
     result++;
   temp = temp->next;
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1828a
movq -0x18(%rbp), %rdi
callq 0x43530
cmpl -0xc(%rbp), %eax
jne 0x1827c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1825e
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: class_exists_in_list
BOOLEAN class_exists_in_list(Instanceptr myptr, int classno)
{
 /*!Last Changed 09.05.2003*/
 Instanceptr temp = myptr;
 while (temp)
  {
   if (give_classno(temp) == classno)
     return BOOLEAN_TRUE;
   temp = temp->next;
  }
 return BOOLEAN_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x182e3
movq -0x20(%rbp), %rdi
callq 0x43530
cmpl -0x14(%rbp), %eax
jne 0x182d5
movl $0x1, -0x4(%rbp)
jmp 0x182ea
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x182b7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: find_error_as_leaf
int find_error_as_leaf(Instanceptr myptr)
{
 /*!Last Changed 23.05.2006*/
 int i, *result, maxclass = 0, sum = 0;
 result = find_class_counts(myptr);
 for (i = 0; i < current_dataset->classno; i++)
  {
   sum += result[i];
   if (result[i] > maxclass)
     maxclass = result[i];
  } 
 safe_free(result);
 return sum - maxclass;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x183a0
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0xed508(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x1837c
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x1c(%rbp), %eax
jle 0x1836f
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
jmp 0x18371
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1832e
movq -0x18(%rbp), %rdi
callq 0x52e80
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: find_class_counts
int* find_class_counts(Instanceptr myptr)
{
 /*!Last Changed 02.02.2004 added safealloc*/
 /*!Last Changed 16.03.2002*/
 int i;
 Instanceptr temp = myptr;
 int *result;
 result = (int *) safecalloc(current_dataset->classno, sizeof(int), "find_class_counts", 4);
 while (temp)
  {
   i = give_classno(temp);
   result[i]++;
   temp = temp->next;
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xed485(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
movl $0x4, %esi
leaq 0xcac72(%rip), %rdx     # 0xe3040
movl $0x4, %ecx
callq 0x52f40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1840e
movq -0x18(%rbp), %rdi
callq 0x43530
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x183dc
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: all_in_one_class
int all_in_one_class(Instanceptr myptr, int* maxcount)
{
 /*!Last Changed 01.11.2005*/
 /*!Last Changed 23.03.2002*/
 int i, *result, maxindex = -1, maxclass = 0, alone, sum = 0;
 result = find_class_counts(myptr);
 for (i = 0; i < current_dataset->classno; i++)
  {
   sum += result[i];
   if (result[i] > maxclass)
    {
     maxclass = result[i];
     maxindex = i;
    }
  }
 safe_free(result);
 if (sum != maxclass)
   alone = 1;
 else
   alone = 0;
 *maxcount = maxclass;
 if (maxindex == -1)
   return 0;
 else
   return maxindex * 10 + alone;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x183a0
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0xed3dd(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x184ad
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x30(%rbp), %eax
jle 0x184a0
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x184a2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x18459
movq -0x28(%rbp), %rdi
callq 0x52e80
movl -0x38(%rbp), %eax
cmpl -0x30(%rbp), %eax
je 0x184c7
movl $0x1, -0x34(%rbp)
jmp 0x184ce
movl $0x0, -0x34(%rbp)
movl -0x30(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpl $-0x1, -0x2c(%rbp)
jne 0x184e6
movl $0x0, -0x4(%rbp)
jmp 0x184f0
imull $0xa, -0x2c(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: find_classes
int* find_classes(Instanceptr myptr)
{
 /*!Last Changed 28.10.2005*/
 int i = 0;
 Instanceptr temp = myptr;
 int *result;
 result = (int *) safemalloc(data_size(myptr) * sizeof(int), "find_classes", 4);
 while (temp)
  {
   result[i] = give_classno(temp);
   i++;
   temp = temp->next;
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x449f0
movslq %eax, %rdi
shlq $0x2, %rdi
leaq 0xcab01(%rip), %rsi     # 0xe3033
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x18574
movq -0x18(%rbp), %rdi
callq 0x43530
movl %eax, %edx
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x18540
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: empty_link_list_of_instances
Instanceptr empty_link_list_of_instances(int fcount, int count)
{
 /*!Last Changed 26.11.2005*/
 /*!Last Changed 24.03.2005*/
 /*!Last Changed 22.03.2005*/
 int i;
 Instanceptr result, tmpbefore, tmp;
 result = empty_instance(fcount);
 tmpbefore = result;
 for (i = 1; i < count; i++)
  {
   tmp = empty_instance(fcount);
   tmpbefore->next = tmp;
   tmpbefore = tmp;
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
callq 0x1e140
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x185dc
movl -0x4(%rbp), %edi
callq 0x1e140
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x185a9
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: allocate_feature_counts
int*** allocate_feature_counts()
{
 /*!Last Changed 11.08.2007*/
 int i, j;
 int*** feature_counts;
 feature_counts = (int ***)safemalloc(current_dataset->classno * sizeof(int **), "allocate_feature_counts", 3);
 for (i = 0;i < current_dataset->classno; i++)
   {
    feature_counts[i] = (int **)safemalloc(current_dataset->featurecount * sizeof(int *), "allocate_feature_counts", 6);
    for (j = 0;j < current_dataset->featurecount; j++)
      if (current_dataset->features[j].type == STRING)
        feature_counts[i][j] = (int *)safecalloc(current_dataset->features[j].valuecount, sizeof(int), "allocate_feature_counts", 9);
   }
 return feature_counts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xed241(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0xcaa41(%rip), %rsi     # 0xe3052
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0xed210(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x18723
leaq 0xed1fd(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x1bc(%rax), %rdi
shlq $0x3, %rdi
leaq 0xca9fa(%rip), %rsi     # 0xe3052
movl $0x6, %edx
callq 0x52d70
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0xed1be(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0x18713
leaq 0xed1a8(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x8(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x18703
leaq 0xed185(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x8(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movslq 0x18(%rax), %rdi
movl $0x4, %esi
leaq 0xca970(%rip), %rdx     # 0xe3052
movl $0x9, %ecx
callq 0x52f40
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x18705
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x18678
jmp 0x18715
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x18626
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)