LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/dataset.c
// Function: definition_file_name
char* definition_file_name(Datasetptr dataset)
{
 /*!Last Changed 31.10.2005*/
 char *fname;
 fname = (char *)safemalloc(200, "definition_file_name", 2);
 if (get_parameter_l("currentos"))
   sprintf(fname, "%s/%s/data.def", datadir, dataset->directory);
 else
   sprintf(fname, "%s\\%s\\data.def", datadir, dataset->directory);
 return fname;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xc8, %edi
leaq 0xc0e36(%rip), %rsi     # 0xe3fee
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
leaq 0xc0e17(%rip), %rdi     # 0xe3fe4
callq 0x792b0
cmpl $0x0, %eax
je 0x23200
movq -0x10(%rbp), %rdi
leaq 0xe266e(%rip), %rax     # 0x105850
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x1407118(%rax), %rcx
leaq 0xc0e0c(%rip), %rsi     # 0xe4003
movb $0x0, %al
callq 0x4170
jmp 0x23227
movq -0x10(%rbp), %rdi
leaq 0xe2645(%rip), %rax     # 0x105850
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x1407118(%rax), %rcx
leaq 0xc0df2(%rip), %rsi     # 0xe4012
movb $0x0, %al
callq 0x4170
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/dataset.c
// Function: print_cmu_data_header
void print_cmu_data_header(FILE* outfile, Datasetptr d)
{
 /*!Last Changed 02.05.2007 added regression*/
 /*!Last Changed 21.04.2007*/
 int i;
 fprintf(outfile, "$SETUP\n\n");
 fprintf(outfile, "PROTOCOL:  IO;\n");
 fprintf(outfile, "OFFSET:     0;\n");
 fprintf(outfile, "INPUTS:     %d;\n", d->multifeaturecount - 1);
 if (d->classno != 0)
   fprintf(outfile, "OUTPUTS:    %d;\n\n", d->classno);
 else
   fprintf(outfile, "OUTPUTS:    1;\n\n");
 for (i = 0; i < d->multifeaturecount - 1; i++)
   fprintf(outfile, "IN [%d]: CONT;\n", i + 1);
 fprintf(outfile, "\n");
 if (d->classno != 0)
   for (i = 0; i < d->classno; i++)
     fprintf(outfile, "OUT [%d]: BINARY;\n", i + 1);
 else
   fprintf(outfile, "OUT [1]: CONT;\n");
 fprintf(outfile, "\n\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc00cc(%rip), %rsi     # 0xe4107
movb $0x0, %al
callq 0x4280
movq -0x8(%rbp), %rdi
leaq 0xc00c3(%rip), %rsi     # 0xe4110
movb $0x0, %al
callq 0x4280
movq -0x8(%rbp), %rdi
leaq 0xc00c1(%rip), %rsi     # 0xe4120
movb $0x0, %al
callq 0x4280
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %edx
subl $0x1, %edx
leaq 0xc00b2(%rip), %rsi     # 0xe4130
movb $0x0, %al
callq 0x4280
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x240aa
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0xc00a0(%rip), %rsi     # 0xe4141
movb $0x0, %al
callq 0x4280
jmp 0x240bc
movq -0x8(%rbp), %rdi
leaq 0xc009e(%rip), %rsi     # 0xe4153
movb $0x0, %al
callq 0x4280
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x1c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x240fa
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
addl $0x1, %edx
leaq 0xc007c(%rip), %rsi     # 0xe4164
movb $0x0, %al
callq 0x4280
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x240c3
movq -0x8(%rbp), %rdi
leaq 0xc1c36(%rip), %rsi     # 0xe5d3b
movb $0x0, %al
callq 0x4280
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x2414e
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x2414c
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
addl $0x1, %edx
leaq 0xc003a(%rip), %rsi     # 0xe4174
movb $0x0, %al
callq 0x4280
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2411d
jmp 0x24160
movq -0x8(%rbp), %rdi
leaq 0xc002e(%rip), %rsi     # 0xe4187
movb $0x0, %al
callq 0x4280
movq -0x8(%rbp), %rdi
leaq 0xbfff6(%rip), %rsi     # 0xe4161
movb $0x0, %al
callq 0x4280
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: graph_connected
BOOLEAN graph_connected(matrix distancematrix)
{
 int i, j;
 for (i = 0; i < distancematrix.row; i++)
   for (j = i + 1; j < distancematrix.col; j++)
     if (distancematrix.values[i][j] == +LONG_MAX)
       return BOOLEAN_FALSE;
 return BOOLEAN_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x26324
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x26317
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0xbccb7(%rip), %xmm1    # 0xe2fb0
ucomisd %xmm1, %xmm0
jne 0x2630a
jp 0x2630a
movl $0x0, -0x4(%rbp)
jmp 0x2632b
jmp 0x2630c
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x262d4
jmp 0x26319
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x262c3
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: simple_dfs
void simple_dfs(matrix adjacencymatrix, BOOLEAN* discovered, int v)
{
 /*!Last Changed 04.04.2008*/
 int i;
 discovered[v] = BOOLEAN_TRUE;
 for (i = 0; i < adjacencymatrix.row; i++)
   if (discovered[i] == BOOLEAN_FALSE && adjacencymatrix.values[v][i] == BOOLEAN_TRUE)
     simple_dfs(adjacencymatrix, discovered, i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x263b9
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x263ac
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0xbbc88(%rip), %xmm1    # 0xe2018
ucomisd %xmm1, %xmm0
jne 0x263ac
jp 0x263ac
movq -0x18(%rbp), %rdx
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x26330
jmp 0x263ae
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2635d
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: is_graph_connected
int is_graph_connected(matrix adjacencymatrix)
{
 /*!Last Changed 04.04.2008*/
 int i; 
 BOOLEAN* discovered = safemalloc(adjacencymatrix.row * sizeof(BOOLEAN), "is_graph_connected", 1);
 BOOLEAN connected = BOOLEAN_TRUE;
 simple_dfs(adjacencymatrix, discovered, 0);
 for (i = 0; i < adjacencymatrix.row; i++)
   if (!discovered[i])
    {
     connected = BOOLEAN_FALSE;
     break;
    } 
 safe_free(discovered);
 return connected;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movslq -0x10(%rbp), %rdi
shlq $0x2, %rdi
leaq 0xbdfd0(%rip), %rsi     # 0xe43af
movl $0x1, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %ecx, %ecx
callq 0x26330
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2643a
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x2642d
movl $0x0, -0x24(%rbp)
jmp 0x2643a
jmp 0x2642f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2640e
movq -0x20(%rbp), %rdi
callq 0x52e80
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: floyds_all_pairs_shortest_path_algorithm
void floyds_all_pairs_shortest_path_algorithm(matrix* distancematrix)
{
 int i, j, k, N = distancematrix->row;
 for (k = 0; k < N; k++)
   for (i = 0; i < N; i++)
     for (j = 0; j < N; j++)
       if (distancematrix->values[i][j] > distancematrix->values[i][k] + distancematrix->values[k][j])
         distancematrix->values[i][j] = distancematrix->values[i][k] + distancematrix->values[k][j];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x26566
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x26556
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x26546
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x26536
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x26538
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2648e
jmp 0x26548
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2647b
jmp 0x26558
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x26468
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: graph
Graphptr graph(int vertexcount)
{
 int i;
 Graphptr g;
 g = malloc(sizeof(Graph));
 g->nedges = 0;
 g->nvertices = vertexcount;
 for (i = 0; i < vertexcount; i++)
  {
   g->visitorder[i] = 0;
   g->height[i] = 0;
   g->degree[i] = 0;
  }
 return g;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0xf46288, %edi         # imm = 0xF46288
callq 0x40b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0xf46284(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xf46280(%rax)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x265f7
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
movl $0x0, 0xf433a0(%rax,%rcx,4)
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
movl $0x0, 0xf44340(%rax,%rcx,4)
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
movl $0x0, 0xf42400(%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x265ab
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: print_graph
void print_graph(Graphptr g)
{
 int i, j;
 for (i = 0; i < g->nvertices; i++)
   for (j = 0; j < g->degree[i]; j++)
     printf("%d -> %d (%.2f)\n", i, g->edges[i][j].v, g->edges[i][j].weight);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xf46280(%rcx), %eax
jge 0x266be
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
cmpl 0xf42400(%rcx,%rdx,4), %eax
jge 0x266ae
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x3e80, %rcx, %rcx     # imm = 0x3E80
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x3e80, %rcx, %rcx     # imm = 0x3E80
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
leaq 0xbdd26(%rip), %rdi     # 0xe43c2
movb $0x1, %al
callq 0x4030
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2663d
jmp 0x266b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x26623
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: graph_insert_edge
void graph_insert_edge(Graphptr g, int x, int y, double weight)
{
 if (g->degree[x] >= MAXDEGREE - 1)
  {
   printf(m1443, x, y);
   return;
  }
 g->edges[x][g->degree[x]].v = y;
 g->edges[x][g->degree[x]].weight = weight;
 g->degree[x]++;
 g->nedges++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x3e7, 0xf42400(%rax,%rcx,4) # imm = 0x3E7
jl 0x26715
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0xbdcca(%rip), %rdi     # 0xe43d3
movb $0x0, %al
callq 0x4030
jmp 0x267a2
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
imulq $0x3e80, %rdx, %rdx     # imm = 0x3E80
addq %rdx, %rax
movq -0x8(%rbp), %rdx
movslq -0xc(%rbp), %rsi
movslq 0xf42400(%rdx,%rsi,4), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x3e80, %rcx, %rcx     # imm = 0x3E80
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movslq 0xf42400(%rcx,%rdx,4), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0xf42400(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0xf42400(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0xf46284(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xf46284(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: compute_indegrees
void compute_indegrees(Graphptr g, int* in)
{
 int i, j;
 for (i = 0; i < g->nvertices; i++)
   in[i] = 0;
 for (i = 0; i < g->nvertices; i++)
   for (j = 0; j < g->degree[i]; j++)
     in[g->edges[i][j].v]++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xf46280(%rcx), %eax
jge 0x267ec
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x267c3
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xf46280(%rcx), %eax
jge 0x26862
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
cmpl 0xf42400(%rcx,%rdx,4), %eax
jge 0x26855
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
imulq $0x3e80, %rdx, %rdx     # imm = 0x3E80
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movslq (%rcx), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x26809
jmp 0x26857
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x267f3
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: eccentricity
int eccentricity(Graphptr g, int node)
{
 int i, eccentricity = 0;
 double* path_lengths = shortest_path(g, node);
 for (i = 0; i < g->nvertices; i++)
   if (path_lengths[i] > eccentricity)
     eccentricity = path_lengths[i];
 safe_free(path_lengths);
 return eccentricity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x26af0
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xf46280(%rcx), %eax
jge 0x26db1
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x26da4
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
cvttsd2si (%rax,%rcx,8), %eax
movl %eax, -0x14(%rbp)
jmp 0x26da6
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x26d6d
movq -0x20(%rbp), %rdi
callq 0x52e80
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: enqueue
void enqueue(Queueptr q, void* x)
{
 /*!Last Changed 21.01.2009*/
 if (q->count >= QUEUESIZE)
   printf("Queue overflow\n");
 else
  {
   q->last = (q->last + 1) % QUEUESIZE;
   q->elements[q->last] = x;
   q->count = q->count + 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3e8, 0x1f50(%rax)    # imm = 0x3E8
jl 0x26fe0
leaq 0xbd470(%rip), %rdi     # 0xe4447
movb $0x0, %al
callq 0x4030
jmp 0x2702d
movq -0x8(%rbp), %rax
movl 0x1f4c(%rax), %eax
addl $0x1, %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movq -0x8(%rbp), %rax
movl %edx, 0x1f4c(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x1f4c(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0x1f50(%rax), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1f50(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: dequeue
void* dequeue(Queueptr q)
{
 /*!Last Changed 21.01.2009*/
 void* x = NULL;
 if (q->count <= 0)
   printf("Warning: Empty queue dequeue\n");
 else
  {
   x = q->elements[q->first];
   q->first = (q->first + 1) % QUEUESIZE;
   q->count = q->count - 1;
  }
 return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1f50(%rax)
jg 0x270a1
leaq 0xbd3bf(%rip), %rdi     # 0xe4457
movb $0x0, %al
callq 0x4030
jmp 0x270ee
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x1f48(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x1f48(%rax), %eax
addl $0x1, %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movq -0x8(%rbp), %rax
movl %edx, 0x1f48(%rax)
movq -0x8(%rbp), %rax
movl 0x1f50(%rax), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1f50(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: graph_from_distancematrix
Graphptr graph_from_distancematrix(matrix distancematrix)
{
 int i, j;
 Graphptr g;
 g = graph(distancematrix.row);
 for (i = 0; i < distancematrix.row; i++)
   for (j = 0; j < distancematrix.row; j++)
     if (distancematrix.values[i][j] != -1)
      {
       (g->nedges)++;
       g->edges[i][g->degree[i]].v = j;
       g->edges[i][g->degree[i]].weight = distancematrix.values[i][j];
       (g->degree[i])++;
      }
 return g;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl -0x10(%rbp), %edi
callq 0x26570
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x27269
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x27259
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0xbb8a9(%rip), %xmm1    # 0xe2a48
ucomisd %xmm1, %xmm0
jne 0x271ac
jp 0x271ac
jmp 0x27249
movq -0x20(%rbp), %rax
movl 0xf46284(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xf46284(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rdx
imulq $0x3e80, %rdx, %rdx     # imm = 0x3E80
addq %rdx, %rax
movq -0x20(%rbp), %rdx
movslq -0x14(%rbp), %rsi
movslq 0xf42400(%rdx,%rsi,4), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x3e80, %rcx, %rcx     # imm = 0x3E80
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movslq 0xf42400(%rcx,%rdx,4), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0xf42400(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0xf42400(%rax,%rcx,4)
jmp 0x2724b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x27176
jmp 0x2725b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x27163
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: pop
int pop(Stackptr s)
{
	/*!Last Changed 01.06.2007*/
	int value;
	if (s->top > -1)
	 {
	  value = s->elements[s->top];
	  s->top--;
	  return value;
	 }
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0xfa0(%rax)
jle 0x27355
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0xfa0(%rcx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0xfa0(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xfa0(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2735c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: list_item
Listitemptr list_item(void* item)
{
 /*!Last Changed 21.01.2009*/
 Listitemptr l;
 l = safemalloc(sizeof(Listitem), "list_item", 2);
 l->item = item;
 l->next = NULL;
 return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
leaq 0xbd085(%rip), %rsi     # 0xe442d
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: link_list
Linklistptr link_list()
{
 /*!Last Changed 21.01.2009*/
 Linklistptr l;
 l = safemalloc(sizeof(Linklist), "link_list", 2);
 l->head = NULL;
 l->tail = NULL;
 return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
leaq 0xbd043(%rip), %rsi     # 0xe4437
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: link_list_insert
void link_list_insert(Linklistptr l, void* item)
{
 /*!Last Changed 21.01.2009*/
 Listitemptr listitem = list_item(item);
 if (l->head == NULL)
   l->head = listitem;
 else
   l->tail->next = listitem;
 l->tail = listitem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x27390
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x27464
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x27474
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: link_list_remove
BOOLEAN link_list_remove(Linklistptr l, void* item, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 21.01.2009*/
 Listitemptr tmp = l->head, tmpbefore = NULL;
 while (tmp && compare(item, tmp->item) != 0)
  {
   tmpbefore = tmp;
   tmp = tmp->next;
  }
 if (tmp != NULL)
  {
   if (tmpbefore == NULL) /*first element is deleted*/
     l->head = l->head->next;
   else
     tmpbefore->next = tmp->next;
   if (l->tail == tmp) /*last element is deleted*/
     l->tail = tmpbefore;
   safe_free(tmp);
   return BOOLEAN_TRUE;
  }
 else
   return BOOLEAN_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
je 0x274dd
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x274e6
jmp 0x274fc
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x274b7
cmpq $0x0, -0x28(%rbp)
je 0x2755a
cmpq $0x0, -0x30(%rbp)
jne 0x2751e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2752e
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x27548
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rdi
callq 0x52e80
movl $0x1, -0x4(%rbp)
jmp 0x27561
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: link_list_search
void* link_list_search(Linklistptr l, void* item, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 21.01.2009*/
 Listitemptr tmp = l->head;
 while (tmp && compare(item, tmp->item) != 0)
   tmp = tmp->next;
 if (tmp)
   return tmp->item;
 else
   return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x29(%rbp)
je 0x275b5
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x275be
jmp 0x275cc
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2758f
cmpq $0x0, -0x28(%rbp)
je 0x275e0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x275e8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: link_list_size
int link_list_size(Linklistptr l)
{
 int count = 0;
 Listitemptr tmp = l->head;
 while (tmp != NULL)
 {
  tmp = tmp->next;
  count++;
 }
 return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x27638
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2761a
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: link_list_get_i
void* link_list_get_i(Linklistptr l, int i)
{
 int count = 0;
 Listitemptr tmp = l->head;
 while (tmp != NULL && count < i)
  {
   tmp = tmp->next;
   count++;
  }
 return tmp->item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x27675
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2767e
jmp 0x27695
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2765d
movq -0x18(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: free_link_list
void free_link_list(Linklistptr l, void (*free_node_contents) (void* a))
{
 /*!Last Changed 21.01.2009*/
 Listitemptr tmp = l->head, next = NULL;
 while (tmp != NULL)
  {
   next = tmp->next;
   free_node_contents(tmp->item);
   safe_free(tmp);
   tmp = next;
  }
 safe_free(l);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x276f6
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rdi
callq 0x52e80
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x276c3
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: queue
Queueptr queue()
{
 /*!Last Changed 21.01.2009*/
 Queueptr q;
 q = safemalloc(sizeof(Queue), "queue", 2);
 q->first = 0;
 q->last = QUEUESIZE - 1;
 q->count = 0;
 return q; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1f58, %edi           # imm = 0x1F58
leaq 0xbcd1d(%rip), %rsi     # 0xe4441
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x1f48(%rax)
movq -0x8(%rbp), %rax
movl $0x3e7, 0x1f4c(%rax)    # imm = 0x3E7
movq -0x8(%rbp), %rax
movl $0x0, 0x1f50(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: dictionary_insert
void dictionary_insert(Dictionaryptr d, void* x, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 21.01.2009*/
 int i, j;
 if (d->count == DICTIONARYSIZE)
  {
   printf("Dictionary is full\n");
   return;
  }
 if (d->count == 0)
   d->elements[0] = x;
 else
   if (compare(x, d->elements[d->count - 1]) >= 0)
     d->elements[d->count] = x;
   else
    {
     i = 0;
     while (compare(x, d->elements[i]) < 0)
       i++;
     for (j = d->count - 1; j >= i; j--)
       d->elements[j + 1] = d->elements[j];
     d->elements[i] = x;
    }
 d->count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3e8, 0x1f40(%rax)    # imm = 0x3E8
jne 0x277e7
leaq 0xbcca5(%rip), %rdi     # 0xe4480
movb $0x0, %al
callq 0x4030
jmp 0x278d6
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1f40(%rax)
jne 0x27804
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x278c3
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rdx
movl 0x1f40(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rsi
callq *%rax
cmpl $0x0, %eax
jl 0x27844
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x1f40(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x278c1
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
callq *%rax
cmpl $0x0, %eax
jge 0x27871
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2784b
movq -0x8(%rbp), %rax
movl 0x1f40(%rax), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0x278b1
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x27881
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x278c3
movq -0x8(%rbp), %rax
movl 0x1f40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1f40(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: dictionary_delete
void dictionary_delete(Dictionaryptr d, void* x, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 21.01.2009*/
 int i, j;
 for (i = 0; i < d->count; i++)
   if (compare(x, d->elements[i]) == 0)
    {
     for (j = i; j < d->count - 1; j++)
       d->elements[j] = d->elements[j + 1];
     break;
    }
 d->count--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1f40(%rcx), %eax
jge 0x27976
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x27969
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x1f40(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x27967
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2792b
jmp 0x27976
jmp 0x2796b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x278fb
movq -0x8(%rbp), %rax
movl 0x1f40(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1f40(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: dictionary_search
int dictionary_search(Dictionaryptr d, void* x, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 21.01.2009*/
 int i;
 for (i = 0; i < d->count; i++)
   if (compare(x, d->elements[i]) == 0)
     return i;
 return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1f40(%rcx), %eax
jge 0x279ea
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x279dd
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x279f1
jmp 0x279df
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x279ab
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: hash_table
Hashtableptr hash_table()
{
 /*!Last Changed 21.01.2009*/
 int i;
 Hashtableptr h;
 h = safemalloc(sizeof(Hashtable), "hash_table", 2);
 for (i = 0; i < HASHTABLESIZE; i++)
   h->elements[i] = link_list();
 return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1f88, %edi           # imm = 0x1F88
leaq 0xbca10(%rip), %rsi     # 0xe4494
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x3f1, -0x4(%rbp)      # imm = 0x3F1
jge 0x27ac1
callq 0x273e0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x27a99
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: free_hash_table
void free_hash_table(Hashtableptr h, void (*free_node_contents) (void* a))
{
 /*!Last Changed 21.01.2009*/
 int i;
 for (i = 0; i < HASHTABLESIZE; i++)
   free_link_list(h->elements[i], free_node_contents);
 safe_free(h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x3f1, -0x14(%rbp)     # imm = 0x3F1
jge 0x27c00
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x276a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x27bd7
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: tree_node
Treenodeptr tree_node(void* item)
{
 /*!Last Changed 22.01.2009*/
 Treenodeptr t;
 t = safemalloc(sizeof(Treenode), "tree_node", 2);
 t->item = item;
 t->left = NULL;
 t->right = NULL;
 return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
leaq 0xbc877(%rip), %rsi     # 0xe449f
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%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/datastructure.c
// Function: binary_tree_node_search
void* binary_tree_node_search(Treenodeptr t, void* x, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 22.01.2009*/
 if (t == NULL)
   return NULL;
 else
   if (compare(x, t->item) < 0)
     return binary_tree_node_search(t->left, x, compare);
   else
     if (compare(x, t->item) > 0)
       return binary_tree_node_search(t->right, x, compare);
     else
       return t->item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x27d05
movq $0x0, -0x8(%rbp)
jmp 0x27d72
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jge 0x27d36
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x27ce0
movq %rax, -0x8(%rbp)
jmp 0x27d72
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jle 0x27d67
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x27ce0
movq %rax, -0x8(%rbp)
jmp 0x27d72
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: find_min
Treenodeptr find_min(Treenodeptr t)
{
 /*!Last Changed 22.01.2009*/
 if (t == NULL)
   return NULL;
 if (t->left == NULL)
   return t;
 return find_min(t->left);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x27d9d
movq $0x0, -0x8(%rbp)
jmp 0x27dc3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x27db2
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x27dc3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x27d80
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: find_max
Treenodeptr find_max(Treenodeptr t)
{
 /*!Last Changed 22.01.2009*/
 if (t != NULL)
   while (t->right != NULL)
     t = t->right;
 return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x27dfc
jmp 0x27de1
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x27dfa
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x27de1
jmp 0x27dfc
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: binary_tree_node_insert
void binary_tree_node_insert(Treenodeptr* t, void* x, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 22.01.2009*/
 if (*t == NULL)
   *t = tree_node(x);
 else
   if (compare(x, (*t)->item) < 0)
     binary_tree_node_insert(&((*t)->left), x, compare);
   else
     if (compare(x, (*t)->item) > 0)
       binary_tree_node_insert(&((*t)->right), x, compare);
     else
       ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x27e73
movq -0x10(%rbp), %rdi
callq 0x27c10
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x27edf
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jge 0x27ea6
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x27e40
jmp 0x27edd
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jle 0x27ed9
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x27e40
jmp 0x27edb
jmp 0x27edb
jmp 0x27edd
jmp 0x27edf
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: binary_tree_node_remove
void binary_tree_node_remove(Treenodeptr* t, void* x, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 22.01.2009*/
 Treenodeptr oldnode;
 if (*t == NULL)
   return;
 if (compare(x, (*t)->item) < 0)
   binary_tree_node_remove(&((*t)->left), x, compare);
 else
   if (compare(x, (*t)->item) > 0)
     binary_tree_node_remove(&((*t)->right), x, compare);
   else
     if ((*t)->left != NULL && (*t)->right != NULL)
      {
       (*t)->item = find_min((*t)->right)->item;
       binary_tree_node_remove(&((*t)->right), x, compare);
      }
     else
      {
       oldnode = *t;
       *t = ((*t)->left != NULL) ? (*t)->left : (*t)->right;
       safe_free(oldnode);
      }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x27f43
jmp 0x28053
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jge 0x27f79
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x27f20
jmp 0x28053
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jle 0x27faf
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x27f20
jmp 0x28051
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x28002
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x28002
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x27d80
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x27f20
jmp 0x2804f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x2802c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2803b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x52e80
jmp 0x28051
jmp 0x28053
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: free_binary_tree_node
void free_binary_tree_node(Treenodeptr t)
{
 /*!Last Changed 22.01.2009*/
 if (t != NULL)
  {
   free_binary_tree_node(t->left);
   free_binary_tree_node(t->right);
   safe_free(t);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x280c6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28090
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x28090
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: heap_insert
void heap_insert(Heapptr h, void* x, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 22.01.2009*/
 int hole;
 if (heap_full(h))
  {
   printf("Heap is full\n");
   return;
  }
 hole = ++(h->count);
 for (; hole > 1 && compare(x, h->elements[hole / 2]) < 0; hole /= 2)
   h->elements[hole] = h->elements[hole / 2];
 h->elements[hole] = x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28130
cmpl $0x0, %eax
je 0x281c5
leaq 0xbc308(%rip), %rdi     # 0xe44c1
movb $0x0, %al
callq 0x4030
jmp 0x28271
movq -0x8(%rbp), %rcx
movl 0x1f40(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x1f40(%rcx)
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x1, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
jle 0x28219
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl -0x1c(%rbp), %eax
movl $0x2, %esi
cltd
idivl %esi
movl %eax, %edx
movq -0x28(%rbp), %rax
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rsi
callq *%rax
cmpl $0x0, %eax
setl %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x28222
jmp 0x28261
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
jmp 0x281db
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: delete_min
void* delete_min(Heapptr h, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 22.01.2009*/
 void* item;
 if (heap_empty(h))
  {
   printf("Heap is empty\n");
   return NULL;
  }
 item = h->elements[1];
 h->elements[1] = h->elements[(h->count)--];
 percolate_down(h, 1, compare);
 return item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x28160
cmpl $0x0, %eax
je 0x282b6
leaq 0xbc22a(%rip), %rdi     # 0xe44cf
movb $0x0, %al
callq 0x4030
movq $0x0, -0x8(%rbp)
jmp 0x28304
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movl 0x1f40(%rdx), %ecx
movl %ecx, %esi
addl $-0x1, %esi
movl %esi, 0x1f40(%rdx)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1, %esi
callq 0x28310
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/datastructure.c
// Function: percolate_down
void percolate_down(Heapptr h, int hole, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 22.01.2009*/
 int child;
 void* tmp = h->elements[hole];
 for (; hole * 2 <= h->count; hole = child)
  {
   child = hole * 2;
   if (child != h->count && compare(h->elements[child + 1], h->elements[child]) < 0)
     child++;
   if (compare(h->elements[child], tmp) < 0)
     h->elements[hole] = h->elements[child];
   else
     break;
  }
 h->elements[hole] = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
shll %eax
movq -0x8(%rbp), %rcx
cmpl 0x1f40(%rcx), %eax
jg 0x283d4
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1f40(%rcx), %eax
je 0x28390
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rdi
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
callq *%rax
cmpl $0x0, %eax
jge 0x28390
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq -0x28(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jge 0x283c5
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x283c7
jmp 0x283d4
jmp 0x283c9
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x28333
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: make_leaf_node
void make_leaf_node(Decisionnodeptr node)
{
 /*!Last Changed 22.09.2004*/
 node->featureno = LEAF_NODE;
 node->left = NULL;
 node->right = NULL;
 node->string = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopl (%rax,%rax)