LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dataset.c
// Function: numeric_features
int* numeric_features(Datasetptr d, int* count)
{
 /*!Last Changed 12.06.2006*/
 int i, *result = NULL;
 *count = 0;
 for (i = 0; i < d->featurecount; i++)
   if (in_list(d->features[i].type, 2, REAL, INTEGER))
    {
     result = alloc(result, (*count + 1) * sizeof(int), *count + 1);
     result[*count] = i;
     (*count)++;
    }
 return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x0, (%rsi)
cmpl $0x0, 0x1bc(%rdi)
jle 0x151d6
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30f08(%rdi), %r12
xorl %r13d, %r13d
xorl %r15d, %r15d
movl (%r12), %edi
movl $0x2, %esi
movl $0x2, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x3aa8c
testl %eax, %eax
je 0x151be
movslq (%rbx), %rdx
leaq 0x4(,%rdx,4), %rsi
incq %rdx
movq %r15, %rdi
callq 0x3a0b4
movq %rax, %r15
movslq (%rbx), %rax
movl %r13d, (%r15,%rax,4)
incl (%rbx)
incq %r13
movslq 0x1bc(%r14), %rax
addq $0x340, %r12            # imm = 0x340
cmpq %rax, %r13
jl 0x15181
jmp 0x151d9
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dataset.c
// Function: number_of_numeric_features
int number_of_numeric_features(char * datasetname)
{
 /*!Last Changed 25.03.2004*/
 Datasetptr tmp;
 int i, count = 0;
 tmp = search_dataset(Datasets, datasetname);
 if (!tmp)
   return -1;
 for (i = 0; i < tmp->featurecount; i++)
   if (in_list(tmp->features[i].type, 2, REAL, INTEGER))
     count++;
 return count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0xc0683(%rip), %rax     # 0xd5878
movq (%rax), %r15
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %r15, %r15
je 0x1526f
movq %rdi, %r14
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x4260
testl %eax, %eax
je 0x15223
movq 0x1407270(%r15), %r15
testq %r15, %r15
jne 0x15205
jmp 0x1526f
cmpl $0x0, 0x1bc(%r15)
jle 0x1526d
leaq 0x30f08(%r15), %r14
xorl %r12d, %r12d
xorl %ebx, %ebx
movl (%r14), %edi
movl $0x2, %esi
movl $0x2, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x3aa8c
cmpl $0x1, %eax
sbbl $-0x1, %ebx
incq %r12
movslq 0x1bc(%r15), %rax
addq $0x340, %r14            # imm = 0x340
cmpq %rax, %r12
jl 0x15239
jmp 0x1526f
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dataset.c
// Function: generate_random_data
Instanceptr generate_random_data(Datasetptr d, int datasize)
{
 /*!Last Changed 24.09.2006 added string type*/
 /*!Last Changed 09.03.2006*/
 Instanceptr tmp, head = NULL, tmpbefore = NULL;
 double value;
 int i, j;
 for (i = 0; i < datasize; i++)
  {
   tmp = empty_instance(d->featurecount);
   for (j = 0; j < d->featurecount - 1; j++)
     switch (d->features[j].type)
      {
       case REAL  :tmp->values[j].floatvalue = produce_random_value(-1, 1);
                   break;
       case STRING:tmp->values[j].stringindex = myrand() % d->features[j].valuecount;
                   break;
      }
   value = produce_random_value(-1, 1);
   if (value < 0)
     tmp->values[d->featurecount - 1].stringindex = 0;
   else
     tmp->values[d->featurecount - 1].stringindex = 1;
   if (tmpbefore)
     tmpbefore->next = tmp;
   else
     head = tmp;
   tmpbefore = tmp;
  }
 return head;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, 0x4(%rsp)
testl %esi, %esi
jle 0x15380
movq %rdi, %r14
leaq 0x30f20(%rdi), %rax
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
xorl %ecx, %ecx
xorl %r12d, %r12d
movq %rcx, 0x10(%rsp)
movl 0x1bc(%r14), %edi
callq 0x15391
movq %rax, %r15
cmpl $0x2, 0x1bc(%r14)
jl 0x1532a
movq 0x8(%rsp), %rbx
xorl %r13d, %r13d
movl -0x18(%rbx), %eax
cmpl $0x1, %eax
je 0x15300
cmpl $0x2, %eax
jne 0x15311
movsd 0x90ac0(%rip), %xmm0    # 0xa5da8
movsd 0x90230(%rip), %xmm1    # 0xa5520
callq 0x3af6a
movq (%r15), %rax
movsd %xmm0, (%rax,%r13,8)
jmp 0x15311
xorl %eax, %eax
callq 0x3af20
cltd
idivl (%rbx)
movq (%r15), %rax
movl %edx, (%rax,%r13,8)
incq %r13
movslq 0x1bc(%r14), %rax
decq %rax
addq $0x340, %rbx            # imm = 0x340
cmpq %rax, %r13
jl 0x152d3
movsd 0x90a76(%rip), %xmm0    # 0xa5da8
movsd 0x901e6(%rip), %xmm1    # 0xa5520
callq 0x3af6a
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
setbe %al
movq (%r15), %rcx
movslq 0x1bc(%r14), %rdx
movl %eax, -0x8(%rcx,%rdx,8)
movq %r15, %rax
testq %r12, %r12
je 0x1536c
movq %r15, 0x10(%r12)
movq 0x10(%rsp), %rax
incl %ebp
movq %rax, %rcx
movq %r15, %r12
cmpl 0x4(%rsp), %ebp
jne 0x152ad
jmp 0x15382
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dataset.c
// Function: empty_instance
Instanceptr empty_instance(int fcount)
{
 /*!Last Changed 07.01.2007 added sublist*/
 /*!Last Changed 26.11.2005 removed unused dataset parameter*/
 /*!Last Changed 24.03.2005*/
 Instanceptr currentinstance;
 currentinstance = (Instanceptr)safemalloc(sizeof(Instance), "empty_instance", 2);
 currentinstance->values = (union value*) safemalloc(fcount * sizeof(union value), "empty_instance", 3);
 currentinstance->isexception = NO;
 currentinstance->next = NULL;
 currentinstance->sublist = NULL;
 currentinstance->class_labels = NULL;
 return currentinstance;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x91db9(%rip), %r14     # 0xa7158
movl $0x30, %edi
movq %r14, %rsi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %r15
movslq %ebx, %rdi
shlq $0x3, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0x3a0e1
movq %rax, (%r15)
movl $0x0, 0x20(%r15)
movq $0x0, 0x28(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dataset.c
// Function: empty_dataset
Datasetptr empty_dataset(char* datasetname, char* directoryname, char* filename, char separator)
{
 /*!Last Changed 24.12.2006*/
 Datasetptr tmp;
 tmp = safemalloc(sizeof(Dataset), "create_dataset", 12);
 tmp->name = strcopy(tmp->name, datasetname);
 tmp->directory = strcopy(tmp->directory, directoryname);
 tmp->file = strcopy(tmp->file, filename);
 tmp->separator = separator;
 tmp->active = 1;
 tmp->dsnname = NULL;
 tmp->tablename = NULL;
 tmp->storetype = STORE_TEXT;
 tmp->kernel = NULL;
 tmp->next = NULL;
 tmp->sigma = 0.0;
 return tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x91841(%rip), %rsi     # 0xa6e4d
movl $0x1407278, %edi        # imm = 0x1407278
movl $0xc, %edx
callq 0x3a0e1
movq %rax, %r14
movq 0x8(%rax), %rdi
movq %r13, %rsi
callq 0x3b494
movq %rax, 0x8(%r14)
movq 0x1407118(%r14), %rdi
movq %r12, %rsi
callq 0x3b494
movq %rax, 0x1407118(%r14)
movq 0x1b0(%r14), %rdi
movq %r15, %rsi
callq 0x3b494
movq %rax, 0x1b0(%r14)
movb %bl, 0x1a8(%r14)
movl $0x1, (%r14)
movl $0x0, 0x140713c(%r14)
xorl %eax, %eax
movq %rax, 0x1407210(%r14)
movq %rax, 0x1407270(%r14)
movq %rax, 0x1407130(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x1407108(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dataset.c
// Function: discretization_equalwidth
double* discretization_equalwidth(Datasetptr original, int fno, int valuecount)
{
 int i;
 double* splits, max, min;
 splits = safemalloc((valuecount - 1) * sizeof(double), "discretization_equalwidth", 1);
 switch (original->features[fno].type)
  {
   case INTEGER:min = original->features[fno].min.intvalue;
                max = original->features[fno].max.intvalue;
                break;
   case    REAL:min = original->features[fno].min.floatvalue;
                max = original->features[fno].max.floatvalue;
                break;
  }
 for (i = 0; i < valuecount - 1; i++)
   splits[i] = min + (i + 1) * ((max - min) / valuecount);
 return splits;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movslq %edx, %rax
leaq -0x8(,%rax,8), %rdi
leaq 0x90f09(%rip), %rsi     # 0xa68c6
movl $0x1, %edx
callq 0x3a0e1
movslq %ebp, %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %r14, %rcx
addq $0x30f08, %rcx          # imm = 0x30F08
movl (%rcx), %edx
cmpl $0x2, %edx
je 0x159f8
testl %edx, %edx
jne 0x15a02
xorps %xmm0, %xmm0
cvtsi2sdl 0x8(%rcx), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0x10(%rcx), %xmm1
jmp 0x15a02
movsd 0x8(%rcx), %xmm0
movsd 0x10(%rcx), %xmm1
cmpl $0x2, %ebx
jl 0x15afd
subsd %xmm0, %xmm1
cvtsi2sd %ebx, %xmm2
divsd %xmm2, %xmm1
movl %ebx, %ecx
addq $-0x2, %rcx
movq %rcx, %xmm2
pshufd $0x44, %xmm2, %xmm2     # xmm2 = xmm2[0,1,0,1]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
shrl %ebx
andl $0x3fffffff, %ebx       # imm = 0x3FFFFFFF
shlq $0x4, %rbx
movdqa 0x909fd(%rip), %xmm3    # 0xa6440
xorl %ecx, %ecx
movdqa 0x90a03(%rip), %xmm4    # 0xa6450
pxor %xmm4, %xmm2
pcmpeqd %xmm5, %xmm5
pxor %xmm6, %xmm6
movdqa 0x90a1f(%rip), %xmm7    # 0xa6480
movdqa 0x90a26(%rip), %xmm8    # 0xa6490
movdqa %xmm3, %xmm9
pxor %xmm4, %xmm9
movdqa %xmm9, %xmm10
pcmpgtd %xmm2, %xmm10
pcmpeqd %xmm2, %xmm9
pshufd $0xf5, %xmm9, %xmm9     # xmm9 = xmm9[1,1,3,3]
pand %xmm10, %xmm9
pshufd $0xf5, %xmm10, %xmm10   # xmm10 = xmm10[1,1,3,3]
por %xmm9, %xmm10
movdqa %xmm3, %xmm9
psubq %xmm5, %xmm9
pshufd $0xd8, %xmm9, %xmm9     # xmm9 = xmm9[0,2,1,3]
punpckldq %xmm6, %xmm9    # xmm9 = xmm9[0],xmm6[0],xmm9[1],xmm6[1]
por %xmm7, %xmm9
subpd %xmm7, %xmm9
mulpd %xmm1, %xmm9
addpd %xmm0, %xmm9
movd %xmm10, %edx
notl %edx
testb $0x1, %dl
je 0x15ad4
movlpd %xmm9, (%rax,%rcx)
pxor %xmm5, %xmm10
pextrw $0x4, %xmm10, %edx
testb $0x1, %dl
je 0x15aeb
movhpd %xmm9, 0x8(%rax,%rcx)
paddq %xmm8, %xmm3
addq $0x10, %rcx
cmpq %rcx, %rbx
jne 0x15a6a
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dataset.c
// Function: kernel_file_name
char* kernel_file_name(Datasetptr dataset)
{
 char *fname;
 fname = (char *)safemalloc(200, "kernel_file_name", 2);
 if (get_parameter_l("currentos"))
   sprintf(fname, "%s/%s/%s", datadir, dataset->directory, dataset->kernelfiles[get_parameter_i("kernelindex")]);
 else
   sprintf(fname, "%s\\%s\\%s", datadir, dataset->directory, dataset->kernelfiles[get_parameter_i("kernelindex")]);
 return fname;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x9024e(%rip), %rsi     # 0xa725f
movl $0xc8, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x901d4(%rip), %rdi     # 0xa71fe
callq 0x54afc
movl %eax, %ebp
leaq 0xbe848(%rip), %rax     # 0xd5880
movq (%rax), %r15
movq 0x1407118(%r14), %r12
leaq 0x90227(%rip), %rdi     # 0xa7270
callq 0x54920
testl %ebp, %ebp
cltq
movq 0x1407218(%r14,%rax,8), %r8
leaq 0x901f5(%rip), %rax     # 0xa7256
leaq 0x901e5(%rip), %rsi     # 0xa724d
cmoveq %rax, %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x41b0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dataset.c
// Function: delete_dataset
void delete_dataset(char *dataset_name)
{
 Datasetptr previous = NULL, dataset = Datasets;
 while (dataset)
  {
   if (!strcmp(dataset->name, dataset_name))
    {
     if (previous)
       previous->next = dataset->next;
     else
       Datasets = dataset->next;
     free_dataset(dataset);
     break;
    }
   previous = dataset;
   dataset = dataset->next;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0xbe4a5(%rip), %r15     # 0xd5878
movq (%r15), %rbx
testq %rbx, %rbx
je 0x17416
movq %rdi, %r14
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x4260
testl %eax, %eax
je 0x17422
movq %rbx, %r12
movq 0x1407270(%r12), %rbx
testq %rbx, %rbx
je 0x17416
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x4260
movq %r12, %rcx
movq %rbx, %r12
testl %eax, %eax
jne 0x173f1
jmp 0x17424
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %ecx, %ecx
movq 0x1407270(%rbx), %rax
testq %rcx, %rcx
je 0x1743a
addq $0x1407270, %rcx        # imm = 0x1407270
movq %rcx, %r15
movq %rax, (%r15)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1376b
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dataset.c
// Function: type_change
void type_change(Datasetptr d)
{
/*!Last Changed 19.03.2002*/
 int i;
 for (i = 0; i < d->featurecount; i++)
  {
   d->features[i].oldtype = d->features[i].type;
   if (d->features[i].type == INTEGER)
     d->features[i].type = REAL;
  }
}

// Assembly:
movslq 0x1bc(%rdi), %rax
testq %rax, %rax
jle 0x18878
imulq $0x340, %rax, %rax      # imm = 0x340
xorl %ecx, %ecx
movl 0x30f08(%rdi,%rcx), %edx
movl %edx, 0x30f0c(%rdi,%rcx)
testl %edx, %edx
jne 0x1886c
movl $0x2, 0x30f08(%rdi,%rcx)
addq $0x340, %rcx            # imm = 0x340
cmpq %rcx, %rax
jne 0x1884f
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dataset.c
// Function: print_datasets
void print_datasets(Datasetptr header, DATASET_TYPE printwhat)
{
 int i=1;
 Datasetptr dataset=header;
 if (!dataset)
  {
   printf(m1056);
   return;
  }
 printf("|Dataset Name      |# of Classes|# of Features|# of Instances|Base Error|\n");
 while (dataset)
  {
   if (printwhat == ALL || (printwhat == CLASSIFICATION_DATASETS && dataset->classno > 0) || (printwhat == REGRESSION_DATASETS && dataset->classno == 0) || (printwhat == TWOCLASS_DATASETS && dataset->classno == 2) || (printwhat == KCLASS_DATASETS && dataset->classno > 2) || (printwhat == DISCRETE_DATASETS && number_of_symbolic_features(dataset->name) == dataset->featurecount - 1) || (printwhat == CONTINUOUS_DATASETS && number_of_numeric_features(dataset->name) == dataset->featurecount - 1) || (printwhat == MIXED_DATASETS && number_of_numeric_features(dataset->name) != dataset->featurecount - 1 && number_of_symbolic_features(dataset->name) != dataset->featurecount - 1))
    {
     printf("|%18s|%12d|%13d|%14d|%10.2f|\n", dataset->name, dataset->classno, dataset->featurecount, dataset->datacount, dataset->baseerror);
     i++;  
    }
   dataset=dataset->next;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x189aa
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8ee9c(%rip), %rdi     # 0xa7765
callq 0x4090
movl %ebx, %r12d
leaq 0x8dc4c(%rip), %r13     # 0xa6524
leaq 0x8e85b(%rip), %r15     # 0xa713a
cmpl $0x7, %ebx
ja 0x1898b
movslq (%r13,%r12,4), %rax
addq %r13, %rax
jmpq *%rax
cmpl $0x0, 0x10(%r14)
jg 0x18962
jmp 0x1898b
cmpl $0x2, 0x10(%r14)
jg 0x18962
jmp 0x1898b
cmpl $0x0, 0x10(%r14)
jne 0x1898b
jmp 0x18962
cmpl $0x2, 0x10(%r14)
je 0x18962
jmp 0x1898b
movq 0x8(%r14), %rdi
callq 0x151e6
movl 0x1bc(%r14), %ebp
decl %ebp
cmpl %ebp, %eax
je 0x1898b
movq 0x8(%r14), %rdi
callq 0x150dd
cmpl %ebp, %eax
jne 0x18962
jmp 0x1898b
movq 0x8(%r14), %rdi
callq 0x150dd
jmp 0x18955
movq 0x8(%r14), %rdi
callq 0x151e6
movl 0x1bc(%r14), %ecx
decl %ecx
cmpl %ecx, %eax
jne 0x1898b
movq 0x8(%r14), %rsi
movl 0x10(%r14), %edx
movl 0x1bc(%r14), %ecx
movl 0x1407120(%r14), %r8d
movsd 0x1407208(%r14), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x4030
movq 0x1407270(%r14), %r14
testq %r14, %r14
jne 0x188df
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8ed9e(%rip), %rdi     # 0xa774f
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8dc98(%rip), %rdi     # 0xa730c
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x8dc88(%rip), %rdi     # 0xa7315
movl $0xf, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x8dc7f(%rip), %rdi     # 0xa7325
movl $0xf, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
movl 0x1c0(%r14), %edx
decl %edx
leaq 0x8dc6d(%rip), %rsi     # 0xa7335
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
movl 0x10(%r14), %edx
testl %edx, %edx
je 0x196ed
leaq 0x8dc65(%rip), %rsi     # 0xa7346
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
jmp 0x19706
leaq 0x8dc64(%rip), %rdi     # 0xa7358
movl $0x10, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
cmpl $0x2, 0x1c0(%r14)
jl 0x19737
leaq 0x8dc52(%rip), %r15     # 0xa7369
xorl %ebp, %ebp
incl %ebp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x42e0
movl 0x1c0(%r14), %eax
decl %eax
cmpl %eax, %ebp
jl 0x19719
movl $0xa, %edi
movq %rbx, %rsi
callq 0x4150
cmpl $0x0, 0x10(%r14)
je 0x1976f
jle 0x19788
leaq 0x8dc25(%rip), %r15     # 0xa7379
xorl %ebp, %ebp
incl %ebp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x42e0
cmpl 0x10(%r14), %ebp
jl 0x19756
jmp 0x19788
leaq 0x8dc16(%rip), %rdi     # 0xa738c
movl $0xf, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x8dbd7(%rip), %rdi     # 0xa7366
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x42c0
// File: /workspace/github_c_makefile_star2_O3/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:
movl $0x1, %eax
testl %edi, %edi
jle 0x1b209
movq %rdi, %rcx
shrq $0x20, %rcx
movq %rdi, %rdx
sarq $0x20, %rdx
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %r8d, %r8d
movsd 0x8b164(%rip), %xmm0    # 0xa6330
xorl %r9d, %r9d
movq %r9, %r10
incq %r9
cmpq %rdx, %r9
jge 0x1b1fd
movq (%rsi,%r10,8), %r10
addq %r8, %r10
movl $0x1, %r11d
movsd (%r10,%r11,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x1b1f5
jnp 0x1b20a
incq %r11
cmpq %r11, %rcx
jne 0x1b1e7
addq $0x8, %r8
decq %rcx
cmpq %rdi, %r9
jne 0x1b1cf
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movslq %ecx, %r13
movl $0x1, (%rdx,%r13,4)
testl %r15d, %r15d
jle 0x1b273
movq %rdx, %rbx
movq %rsi, %r14
movl %r15d, %ebp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %r12d, %r12d
cmpl $0x0, (%rbx,%r12,4)
jne 0x1b26b
movq (%r14,%r13,8), %rax
movsd (%rax,%r12,8), %xmm0
ucomisd 0x8a2ca(%rip), %xmm0    # 0xa5520
jne 0x1b26b
jp 0x1b26b
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r12d, %ecx
callq 0x1b20d
incq %r12
cmpq %r12, %rbp
jne 0x1b23d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %r14
movslq %r14d, %r13
leaq (,%r13,4), %rdi
leaq 0x8c53d(%rip), %rsi     # 0xa77e0
movl $0x1, %ebx
movl $0x1, %edx
callq 0x3a0e1
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x1b20d
testl %r13d, %r13d
jle 0x1b2e6
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %eax, %eax
cmpl $0x0, (%r15,%rax,4)
je 0x1b2e4
incq %rax
cmpq %rax, %r14
jne 0x1b2d3
jmp 0x1b2e6
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x3a180
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq (%rdi), %rax
testq %rax, %rax
jle 0x1b34b
movq 0x8(%rdi), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
xorl %edi, %edi
movq (%rcx,%rdi,8), %r8
xorl %r9d, %r9d
movsd (%r8,%r9,8), %xmm1
movsd (%r8,%rdx,8), %xmm0
addsd (%rsi,%r9,8), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x1b333
movsd %xmm0, (%r8,%r9,8)
incq %r9
cmpq %r9, %rax
jne 0x1b315
incq %rdi
cmpq %rax, %rdi
jne 0x1b30e
incq %rdx
cmpq %rax, %rdx
jne 0x1b308
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl %edi, %ebx
movl $0xf46288, %edi         # imm = 0xF46288
callq 0x40e0
movl $0x0, 0xf46284(%rax)
movl %ebx, 0xf46280(%rax)
testl %ebx, %ebx
jle 0x1b390
movl %ebx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movl %edx, 0xf433a0(%rax,%rsi,4)
movl %edx, 0xf44340(%rax,%rsi,4)
movl %edx, 0xf42400(%rax,%rsi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0x1b373
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0xf46280(%rdi), %eax
testl %eax, %eax
jle 0x1b419
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
xorl %r14d, %r14d
leaq 0x8c43b(%rip), %r15     # 0xa77f3
cmpl $0x0, 0xf42400(%rbx,%r14,4)
jle 0x1b3f9
movq %r12, %r13
xorl %ebp, %ebp
movl -0x8(%r13), %edx
movsd (%r13), %xmm0
movq %r15, %rdi
movl %r14d, %esi
movb $0x1, %al
callq 0x4030
incq %rbp
movslq 0xf42400(%rbx,%r14,4), %rax
addq $0x10, %r13
cmpq %rax, %rbp
jl 0x1b3c8
movl 0xf46280(%rbx), %eax
incq %r14
movslq %eax, %rcx
addq $0x3e80, %r12           # imm = 0x3E80
cmpq %rcx, %r14
jl 0x1b3b8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq %esi, %rax
movslq 0xf42400(%rdi,%rax,4), %rcx
cmpq $0x3e7, %rcx            # imm = 0x3E7
jl 0x1b43c
leaq 0x8c3cf(%rip), %rdi     # 0xa7804
xorl %eax, %eax
jmp 0x4030
imulq $0x3e80, %rax, %rsi     # imm = 0x3E80
addq %rdi, %rsi
shlq $0x4, %rcx
movl %edx, (%rcx,%rsi)
movslq 0xf42400(%rdi,%rax,4), %rcx
leal 0x1(%rcx), %edx
shlq $0x4, %rcx
movsd %xmm0, 0x8(%rcx,%rsi)
movl %edx, 0xf42400(%rdi,%rax,4)
incl 0xf46284(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x0, 0xf46280(%rdi)
jle 0x1b4dd
xorl %eax, %eax
movl $0x0, (%rsi,%rax,4)
incq %rax
movslq 0xf46280(%rdi), %rdx
cmpq %rdx, %rax
jl 0x1b47b
testl %edx, %edx
jle 0x1b4dd
xorl %eax, %eax
movq %rdi, %rcx
cmpl $0x0, 0xf42400(%rdi,%rax,4)
jle 0x1b4cb
movq %rcx, %rdx
xorl %r8d, %r8d
movslq (%rdx), %r9
incl (%rsi,%r9,4)
incq %r8
movslq 0xf42400(%rdi,%rax,4), %r9
addq $0x10, %rdx
cmpq %r9, %r8
jl 0x1b4aa
movl 0xf46280(%rdi), %edx
incq %rax
movslq %edx, %r8
addq $0x3e80, %rcx           # imm = 0x3E80
cmpq %r8, %rax
jl 0x1b49a
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0x1b71e
movslq 0xf46280(%rbx), %rcx
testq %rcx, %rcx
jle 0x1b941
xorl %edx, %edx
xorl %ebx, %ebx
movsd (%rax,%rdx,8), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %ebx, %xmm1
ucomisd %xmm1, %xmm0
cvttsd2si %xmm0, %esi
cmoval %esi, %ebx
incq %rdx
cmpq %rdx, %rcx
jne 0x1b920
jmp 0x1b943
xorl %ebx, %ebx
movq %rax, %rdi
callq 0x3a180
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/datastructure.c
// Function: topological_sort
int* topological_sort(Graphptr g)
{
 int x, y, i, j;
 int *node;
 int* sorted = safemalloc(sizeof(int) * g->nvertices, "topological_sort", 1);
 int indegree[MAXV];
 Queueptr zeroin = queue();
 compute_indegrees(g, indegree);
 for (i = 0; i < g->nvertices; i++)
   if (indegree[i] == 0)
    {
     node = safemalloc(sizeof(int), "topological_sort", 11);
     node[0] = i;
     enqueue(zeroin, node);
    }
 j = 0;
 while (!queue_empty(zeroin))
  {
   node = dequeue(zeroin);
   x = node[0];
   safe_free(node);
   sorted[j] = x;
   j++;
   for (i = 0; i < g->degree[x]; i++)
    {
     y = g->edges[x][i].v;
     indegree[y]--;
     if (indegree[y] == 0)
      {
       node = safemalloc(sizeof(int), "topological_sort", 29);
       node[0] = y;
       enqueue(zeroin, node);
      }
    }
  }
 free_queue(zeroin);
 return sorted;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xfb8, %rsp            # imm = 0xFB8
movq %rdi, %rbx
movslq 0xf46280(%rdi), %rdi
shlq $0x2, %rdi
leaq 0x8bed2(%rip), %rsi     # 0xa7847
movl $0x1, %edx
callq 0x3a0e1
movq %rax, 0x8(%rsp)
leaq 0x8bf45(%rip), %rsi     # 0xa78d0
movl $0x1f58, %edi           # imm = 0x1F58
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %rbp
movabsq $0x3e700000000, %rax    # imm = 0x3E700000000
movq %rax, 0x1f48(%rbp)
movl $0x0, 0x1f50(%rbp)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b470
movq %rbx, (%rsp)
movl 0xf46280(%rbx), %eax
testl %eax, %eax
jle 0x1bac4
xorl %r14d, %r14d
leaq 0x8be66(%rip), %r12     # 0xa7847
cmpl $0x0, 0x10(%rsp,%r14,4)
jne 0x1ba13
movl $0x4, %edi
movq %r12, %rsi
movl $0xb, %edx
callq 0x3a0e1
movl %r14d, (%rax)
movq %rbp, %rdi
movq %rax, %rsi
callq 0x1bae3
movq (%rsp), %rax
movl 0xf46280(%rax), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x1b9e1
cmpl $0x0, 0x1f50(%rbp)
jle 0x1bac4
xorl %r13d, %r13d
movq %rbp, %r15
movq %rbp, %rdi
callq 0x1bb4d
movslq (%rax), %rbp
movq %rax, %rdi
callq 0x3a180
movq 0x8(%rsp), %rax
movl %ebp, (%rax,%r13,4)
movq (%rsp), %rax
movl 0xf42400(%rax,%rbp,4), %eax
testl %eax, %eax
jle 0x1bab0
imulq $0x3e80, %rbp, %r14     # imm = 0x3E80
addq (%rsp), %r14
xorl %r12d, %r12d
movslq (%r14), %rbx
decl 0x10(%rsp,%rbx,4)
jne 0x1baa1
movl $0x4, %edi
leaq 0x8bdc8(%rip), %rsi     # 0xa7847
movl $0x1d, %edx
callq 0x3a0e1
movl %ebx, (%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x1bae3
movq (%rsp), %rax
movl 0xf42400(%rax,%rbp,4), %eax
incq %r12
movslq %eax, %rcx
addq $0x10, %r14
cmpq %rcx, %r12
jl 0x1ba6a
incq %r13
movq %r15, %rbp
cmpl $0x0, 0x1f50(%r15)
jg 0x1ba2e
movq %rbp, %rdi
callq 0x3a180
movq 0x8(%rsp), %rax
addq $0xfb8, %rsp            # imm = 0xFB8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x1f50(%rdi), %eax
cmpl $0x3e8, %eax            # imm = 0x3E8
jl 0x1bafc
leaq 0x8bdb3(%rip), %rdi     # 0xa78aa
jmp 0x4090
movl 0x1f4c(%rdi), %ecx
movl %ecx, %edx
incl %edx
movslq %edx, %rdx
imulq $0x10624dd3, %rdx, %rdx # imm = 0x10624DD3
movq %rdx, %r8
shrq $0x3f, %r8
sarq $0x26, %rdx
addl %r8d, %edx
imull $0x3e8, %edx, %edx      # imm = 0x3E8
negl %edx
addl %edx, %ecx
incl %ecx
movl %ecx, 0x1f4c(%rdi)
movslq %ecx, %rcx
movq %rsi, (%rdi,%rcx,8)
incl %eax
movl %eax, 0x1f50(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x1f50(%rdi), %ecx
testl %ecx, %ecx
jle 0x1bb93
movslq 0x1f48(%rdi), %rdx
movq (%rdi,%rdx,8), %rax
incl %edx
movslq %edx, %rdx
imulq $0x10624dd3, %rdx, %rsi # imm = 0x10624DD3
movq %rsi, %r8
shrq $0x3f, %r8
sarq $0x26, %rsi
addl %r8d, %esi
imull $0x3e8, %esi, %esi      # imm = 0x3E8
subl %esi, %edx
movl %edx, 0x1f48(%rdi)
decl %ecx
movl %ecx, 0x1f50(%rdi)
retq
pushq %rax
leaq 0x8bd1e(%rip), %rdi     # 0xa78b9
callq 0x4090
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1b34c
testl %r14d, %r14d
jle 0x1bc38
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movsd 0x8a1d2(%rip), %xmm0    # 0xa5da8
movq (%rbx,%rcx,8), %rdx
imulq $0x3e80, %rcx, %rsi     # imm = 0x3E80
addq %rax, %rsi
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x1bbf3
jnp 0x1bc28
incl 0xf46284(%rax)
movslq 0xf42400(%rax,%rcx,4), %r8
shlq $0x4, %r8
movl %edi, (%r8,%rsi)
movslq 0xf42400(%rax,%rcx,4), %r8
leal 0x1(%r8), %r9d
shlq $0x4, %r8
movsd %xmm1, 0x8(%r8,%rsi)
movl %r9d, 0xf42400(%rax,%rcx,4)
incq %rdi
cmpq %rdi, %r14
jne 0x1bbe6
incq %rcx
cmpq %r14, %rcx
jne 0x1bbd6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0x8bbaf(%rip), %rsi     # 0xa785e
movl $0x10, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %rbx, (%rax)
movq $0x0, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8bb63(%rip), %rsi     # 0xa785e
movl $0x10, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %r14, (%rax)
movq $0x0, 0x8(%rax)
cmpq $0x0, (%rbx)
movq %rbx, %rcx
je 0x1bd26
movq 0x8(%rbx), %rcx
addq $0x8, %rcx
movq %rax, (%rcx)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x1bd76
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rbx), %rsi
movq %r12, %rdi
callq *%rdx
testl %eax, %eax
je 0x1bd7a
movq %rbx, %r13
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x1bd76
movq (%rbx), %rsi
movq %r12, %rdi
callq *%r15
testl %eax, %eax
jne 0x1bd5b
jmp 0x1bd7d
xorl %eax, %eax
jmp 0x1bdad
xorl %r13d, %r13d
testq %r13, %r13
je 0x1bd8c
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r13)
jmp 0x1bd96
movq (%r14), %rax
movq 0x8(%rax), %rax
movq %rax, (%r14)
cmpq %rbx, 0x8(%r14)
jne 0x1bda0
movq %r13, 0x8(%r14)
movq %rbx, %rdi
callq 0x3a180
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
testq %r12, %r12
je 0x1bde9
movq %rdx, %r14
movq %rsi, %r15
xorl %ebx, %ebx
movq (%r12), %rsi
movq %r15, %rdi
callq *%r14
testl %eax, %eax
je 0x1bded
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x1bdcf
jmp 0x1bdf1
xorl %ebx, %ebx
jmp 0x1bdf1
movq (%r12), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x1be70
movq %rsi, %r14
movq (%r15), %rdi
movq 0x8(%r15), %r12
callq *%r14
movq %r15, %rdi
callq 0x3a180
movq %r12, %r15
testq %r12, %r12
jne 0x1be56
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/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 %rax
leaq 0x8ba45(%rip), %rsi     # 0xa78d0
movl $0x1f58, %edi           # imm = 0x1F58
movl $0x2, %edx
callq 0x3a0e1
movabsq $0x3e700000000, %rcx    # imm = 0x3E700000000
movq %rcx, 0x1f48(%rax)
movl $0x0, 0x1f50(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x1f40(%rdi), %rax
testq %rax, %rax
je 0x1bf18
cmpl $0x3e8, %eax            # imm = 0x3E8
jne 0x1bf1d
leaq 0x8b9d1(%rip), %rdi     # 0xa78d6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4090
movq %rbx, %r12
jmp 0x1bf96
movq %rdx, %r15
movq -0x8(%rbx,%rax,8), %rsi
movq %r14, %rdi
callq *%rdx
testl %eax, %eax
js 0x1bf3b
movslq 0x1f40(%rbx), %rax
leaq (%rbx,%rax,8), %r12
jmp 0x1bf96
leaq -0x8(%rbx), %r12
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movabsq $-0x100000000, %r13     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %r13
movq 0x8(%r12), %rsi
addq $0x8, %r12
movq %r14, %rdi
callq *%r15
incl %ebp
testl %eax, %eax
js 0x1bf4e
movl 0x1f40(%rbx), %eax
cmpl %ebp, %eax
jle 0x1bf96
movslq %eax, %rcx
sarq $0x20, %r13
movq -0x8(%rbx,%rcx,8), %rdx
movq %rdx, (%rbx,%rcx,8)
leaq -0x1(%rcx), %rdx
movq %rdx, %rcx
cmpq %r13, %rdx
jg 0x1bf81
movq %r14, (%r12)
incl %eax
movl %eax, 0x1f40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x1f40(%rdi), %ecx
testl %ecx, %ecx
jle 0x1bfee
movq %rdx, %r14
movq %rsi, %r15
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r15, %rdi
callq *%r14
movl 0x1f40(%rbx), %ecx
testl %eax, %eax
je 0x1c002
movslq %ecx, %rax
incq %r12
cmpq %rax, %r12
jl 0x1bfcf
decl %ecx
movl %ecx, 0x1f40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
decl %ecx
cmpl %r12d, %ecx
jle 0x1bff0
movl %ecx, %eax
movq 0x8(%rbx,%r12,8), %rdx
movq %rdx, (%rbx,%r12,8)
leaq 0x1(%r12), %rdx
movq %rdx, %r12
cmpq %rdx, %rax
jne 0x1c00b
jmp 0x1bff0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
leaq 0x8b7e5(%rip), %rsi     # 0xa787d
movl $0x1f88, %edi           # imm = 0x1F88
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %rbx
xorl %r15d, %r15d
leaq 0x8b7b4(%rip), %r14     # 0xa7868
movl $0x10, %edi
movq %r14, %rsi
movl $0x2, %edx
callq 0x3a0e1
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, (%rbx,%r15,8)
incq %r15
cmpq $0x3f1, %r15            # imm = 0x3F1
jne 0x1c0b4
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/datastructure.c
// Function: hash_table_insert
void hash_table_insert(Hashtableptr h, void* x, int (*hash_function)(const void *a, int tablesize))
{
 /*!Last Changed 21.01.2009*/
 int location;
 location = hash_function(x, HASHTABLESIZE);
 link_list_insert(h->elements[location], x);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x3f1, %esi            # imm = 0x3F1
callq *%rdx
cltq
movq (%r14,%rax,8), %r14
leaq 0x8b758(%rip), %rsi     # 0xa785e
movl $0x10, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %rbx, (%rax)
movq $0x0, 0x8(%rax)
cmpq $0x0, (%r14)
movq %r14, %rcx
je 0x1c131
movq 0x8(%r14), %rcx
addq $0x8, %rcx
movq %rax, (%rcx)
movq %rax, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/datastructure.c
// Function: hash_table_search
void* hash_table_search(Hashtableptr h, void* x, int (*hash_function)(const void *a, int tablesize), int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 21.01.2009*/
 int location;
 location = hash_function(x, HASHTABLESIZE);
 return link_list_search(h->elements[location], x, compare);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movl $0x3f1, %esi            # imm = 0x3F1
callq *%rdx
cltq
movq (%r15,%rax,8), %rax
movq (%rax), %r12
xorl %r15d, %r15d
testq %r12, %r12
je 0x1c1b2
movq (%r12), %rsi
movq %r14, %rdi
callq *%rbx
testl %eax, %eax
je 0x1c1ae
movq 0x8(%r12), %r12
jmp 0x1c195
movq (%r12), %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0x8b689(%rip), %rsi     # 0xa7888
movl $0x18, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1c2e5
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
xorl %ebx, %ebx
movq (%r15), %rsi
movq %r12, %rdi
callq *%r14
testl %eax, %eax
js 0x1c2d5
movq (%r15), %rsi
movq %r12, %rdi
callq *%r14
movl $0x10, %ecx
testl %eax, %eax
jg 0x1c2da
jmp 0x1c2e9
movl $0x8, %ecx
movq (%r15,%rcx), %r15
testq %r15, %r15
jne 0x1c2b4
jmp 0x1c2ec
xorl %ebx, %ebx
jmp 0x1c2ec
movq (%r15), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/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:
testq %rdi, %rdi
je 0x1c31f
movq %rdi, %rax
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
jne 0x1c312
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x1c372
movq %rdx, %r15
movq (%rax), %rsi
movq %rbx, %rdi
callq *%r15
movq (%r14), %rcx
testl %eax, %eax
js 0x1c363
movq (%rcx), %rsi
movq %rbx, %rdi
callq *%r15
testl %eax, %eax
jle 0x1c395
movq (%r14), %r14
addq $0x10, %r14
jmp 0x1c36a
addq $0x8, %rcx
movq %rcx, %r14
movq (%r14), %rax
testq %rax, %rax
jne 0x1c33d
leaq 0x8b50f(%rip), %rsi     # 0xa7888
movl $0x18, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, (%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1c419
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rax), %rsi
movq %r14, %rdi
callq *%rbx
movq (%r15), %rcx
testl %eax, %eax
js 0x1c3dd
movq (%rcx), %rsi
movq %r14, %rdi
callq *%rbx
movq (%r15), %rdi
testl %eax, %eax
jle 0x1c3e6
addq $0x10, %rdi
movq %rdi, %r15
jmp 0x1c411
addq $0x8, %rcx
movq %rcx, %r15
jmp 0x1c411
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rax
testq %rcx, %rcx
je 0x1c41f
testq %rax, %rax
je 0x1c422
movq %rax, %rcx
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x1c3f8
movq (%rcx), %rax
movq %rax, (%rdi)
movq (%r15), %r15
addq $0x10, %r15
movq (%r15), %rax
testq %rax, %rax
jne 0x1c3b6
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rcx
movq %rcx, (%r15)
popq %rbx
popq %r14
popq %r15
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x1c468
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1c444
movq 0x10(%rbx), %rdi
callq 0x1c444
movq %rbx, %rdi
popq %rbx
jmp 0x3a180
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x1f40(%rdi), %eax
cmpl $0x3e7, %eax            # imm = 0x3E7
jne 0x1c4c7
leaq 0x8b427(%rip), %rdi     # 0xa78e9
jmp 0x4090
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leal 0x1(%rax), %ebp
movl %ebp, 0x1f40(%rdi)
testl %eax, %eax
jle 0x1c50d
movq %rdx, %r15
movl %ebp, %r12d
shrl %r12d
movq (%r14,%r12,8), %rsi
movq %rbx, %rdi
callq *%r15
testl %eax, %eax
jns 0x1c50d
movq (%r14,%r12,8), %rax
movl %ebp, %ecx
movq %rax, (%r14,%rcx,8)
cmpl $0x3, %ebp
movl %r12d, %ebp
ja 0x1c4e8
jmp 0x1c510
movl %ebp, %r12d
movslq %r12d, %rax
movq %rbx, (%r14,%rax,8)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq