LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: free_multidimensional_array
void free_multidimensional_array(variableptr myvar)
{
 /*!Last Changed 22.12.2006 added array of matrices*/
 /*!Last Changed 04.01.2006*/
 int j;
 for (j = 0; j < myvar->arraysize; j++)
   if (myvar->value.array[j].type == ARRAY_TYPE)
     free_multidimensional_array(&(myvar->value.array[j]));
   else
    {
     if (in_list(myvar->value.array[j].type, 2, STRING_TYPE, FILE_TYPE))
      {
       if (myvar->value.array[j].value.stringvalue)
         safe_free(myvar->value.array[j].value.stringvalue);
      }
     else
       if (myvar->value.array[j].type == MATRIX_TYPE && myvar->value.array[j].value.matrixvalue)
        {
         matrix_free(*(myvar->value.array[j].value.matrixvalue));
         safe_free(myvar->value.array[j].value.matrixvalue);
        }
    }
 safe_free(myvar->value.array);
}

// 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 0x20(%rcx), %eax
jge 0x4ccf2
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x3, (%rax)
jne 0x4cc08
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x4cbb0
jmp 0x4cce2
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %edi
movl $0x2, %edx
movl $0x4, %ecx
movl %edx, %esi
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0x4cc6d
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x28(%rax)
je 0x4cc6b
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
callq 0x52e80
jmp 0x4cce0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x5, (%rax)
jne 0x4ccde
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x28(%rax)
je 0x4ccde
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x59ea0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
callq 0x52e80
jmp 0x4cce0
jmp 0x4cce2
jmp 0x4cce4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4cbc3
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: create_multidimensional_array
void create_multidimensional_array(variableptr myvar, int* dimensions, int curdimension, int dimcount, int type)
{
 /*!Last Changed 04.01.2006*/
 int k, size;
 size = dimensions[curdimension];
 myvar->arraysize = size;
 myvar->value.array = (variableptr)safemalloc(size * sizeof(struct variable), "create_multidimensional_array", 4);
 for (k = 0; k < size; k++)
   if (curdimension + 1 < dimcount)
    {
     myvar->value.array[k].type = ARRAY_TYPE;
     myvar->value.array[k].name = NULL;
     create_multidimensional_array(&(myvar->value.array[k]), dimensions, curdimension + 1, dimcount, type);
    }
   else
    {
     myvar->value.array[k].name = NULL;
     myvar->value.array[k].type = type;
     myvar->value.array[k].arraysize = 0;
     set_default_value(&(myvar->value.array[k]));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movslq -0x24(%rbp), %rax
imulq $0x30, %rax, %rdi
leaq 0x994e8(%rip), %rsi     # 0xe6239
movl $0x4, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x4ce58
movl -0x14(%rbp), %eax
addl $0x1, %eax
cmpl -0x18(%rbp), %eax
jge 0x4cde3
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x3, (%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movslq -0x20(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0x4cd10
jmp 0x4ce48
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x18(%rax)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x20(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movslq -0x20(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x4c9b0
jmp 0x4ce4a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4cd6d
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: set_for_variable
int set_for_variable(char* name, char* end, int step, int ip)
{
 /*!Last Changed 03.01.2006*/
 /*!Last Changed 05.04.2002*/
 int i;
 variableptr myvar;
 myvar = get_variable(name);
 if (!myvar)
   return 0;
 if (myvar->type != INTEGER_TYPE)
   return 0;
 i = atoi(end);
 myvar->end = i;
 myvar->step = step;
 myvar->ip = ip;
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4b5e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4ce93
movl $0x0, -0x4(%rbp)
jmp 0x4ced6
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4cea5
movl $0x0, -0x4(%rbp)
jmp 0x4ced6
movq -0x18(%rbp), %rdi
callq 0x41c0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x20(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xc(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: change_special_characters
void change_special_characters(char* st)
{
	/*!Last Changed 13.07.2005*/
	int i, len;
	len = strlen(st);
	for (i = 0; i < len; i++)
		 switch (st[i])
	   {
		   case '_':st[i] = ' ';
						        break;
					case '#':st[i] = '_';
						        break;
	   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4150
movl %eax, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x4d16e
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
subl $0x23, %eax
je 0x4d155
jmp 0x4d13d
movl -0x14(%rbp), %eax
subl $0x5f, %eax
jne 0x4d161
jmp 0x4d147
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x20, (%rax,%rcx)
jmp 0x4d161
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x5f, (%rax,%rcx)
jmp 0x4d163
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4d11f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: add_expnode
void add_expnode(char* st, Expnodeptr* tmpbefore, Expnodeptr* start)
{
 /*!Last Changed 03.01.2006*/
 Expnodeptr tmp;
 variableptr myvar;
 if (st[0] == '\0')
   return;
 tmp = safemalloc(sizeof(Expnode), "add_expnode", 5);
 if (!isfloat(st) && (myvar = get_variable(st)) != NULL && myvar->type != ARRAY_TYPE)
  {
   tmp->type = myvar->type;
   tmp->value = myvar->value;
  }
 else
   if (isinteger(st) && strcmp(st, "+") != 0 && strcmp(st, "-") != 0)
    {
     tmp->type = INTEGER_TYPE;
     tmp->value.intvalue = atoi(st);
    }
   else
     if (isfloat(st) && strcmp(st, "+") != 0 && strcmp(st, "-") != 0)
      {
       tmp->type = REAL_TYPE;
       tmp->value.floatvalue = atof(st);
      }
     else
      {
       tmp->type = NO_TYPE;
       tmp->name = strcopy(tmp->name, st);
      }
 tmp->next = NULL;
 if (*tmpbefore)
   (*tmpbefore)->next = tmp;
 else
   *start = tmp;
 *tmpbefore = tmp;
}

// 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
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4d1e5
jmp 0x4d35f
movl $0x20, %edi
leaq 0x990c2(%rip), %rsi     # 0xe62b3
movl $0x5, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x53b00
cmpl $0x0, %eax
jne 0x4d24b
movq -0x8(%rbp), %rdi
callq 0x4b5e0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x4d24b
movq -0x28(%rbp), %rax
cmpl $0x3, (%rax)
je 0x4d24b
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x4d322
movq -0x8(%rbp), %rdi
callq 0x53bd0
cmpl $0x0, %eax
je 0x4d2a2
movq -0x8(%rbp), %rdi
leaq 0x98b03(%rip), %rsi     # 0xe5d67
callq 0x4210
cmpl $0x0, %eax
je 0x4d2a2
movq -0x8(%rbp), %rdi
leaq 0x98909(%rip), %rsi     # 0xe5b82
callq 0x4210
cmpl $0x0, %eax
je 0x4d2a2
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x41c0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x4d320
movq -0x8(%rbp), %rdi
callq 0x53b00
cmpl $0x0, %eax
je 0x4d2f9
movq -0x8(%rbp), %rdi
leaq 0x98aac(%rip), %rsi     # 0xe5d67
callq 0x4210
cmpl $0x0, %eax
je 0x4d2f9
movq -0x8(%rbp), %rdi
leaq 0x988b2(%rip), %rsi     # 0xe5b82
callq 0x4210
cmpl $0x0, %eax
je 0x4d2f9
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x4100
movq -0x20(%rbp), %rax
movsd %xmm0, 0x10(%rax)
jmp 0x4d31e
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x54ba0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4d320
jmp 0x4d322
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4d349
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x4d354
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: print_expression_list
void print_expression_list(Expnodeptr list)
{
 /*!Last Changed 03.01.2006*/
 Expnodeptr tmp = list;
 while (tmp)
  {
   switch (tmp->type)
    {
     case  NO_TYPE     :printf("%s ", tmp->name);
                        break;
     case  INTEGER_TYPE:printf("%d ", tmp->value.intvalue);
                        break;
     case  REAL_TYPE   :printf("%.4f ", tmp->value.floatvalue);
                        break;
     case  STRING_TYPE :
     case  FILE_TYPE   :printf("%s ", tmp->value.stringvalue);
                        break;
     default           :break;
    }
   tmp = tmp->next;
  }
 printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4d429
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
incl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x5, %eax
ja 0x4d416
movq -0x18(%rbp), %rax
leaq 0x986aa(%rip), %rcx     # 0xe5a58
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xa00f6(%rip), %rdi     # 0xed4bb
movb $0x0, %al
callq 0x4030
jmp 0x4d418
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0x9f0b9(%rip), %rdi     # 0xec495
movb $0x0, %al
callq 0x4030
jmp 0x4d418
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
leaq 0xa03ec(%rip), %rdi     # 0xed7e1
movb $0x1, %al
callq 0x4030
jmp 0x4d418
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0xa00ae(%rip), %rdi     # 0xed4bb
movb $0x0, %al
callq 0x4030
jmp 0x4d418
jmp 0x4d418
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4d384
leaq 0x9890b(%rip), %rdi     # 0xe5d3b
movb $0x0, %al
callq 0x4030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: has_higher_or_equal_precedence
int has_higher_or_equal_precedence(int op1, int op2)
{
 if (op1 >= op2)
   return YES;
 if (op1 == 0 && op2 == 1)
   return YES;
 if (op1 == 2 && op2 == 3)
   return YES;
 return NO;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x4d68b
movl $0x1, -0x4(%rbp)
jmp 0x4d6bc
cmpl $0x0, -0x8(%rbp)
jne 0x4d6a0
cmpl $0x1, -0xc(%rbp)
jne 0x4d6a0
movl $0x1, -0x4(%rbp)
jmp 0x4d6bc
cmpl $0x2, -0x8(%rbp)
jne 0x4d6b5
cmpl $0x3, -0xc(%rbp)
jne 0x4d6b5
movl $0x1, -0x4(%rbp)
jmp 0x4d6bc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: insert_into_exp_list
Expnodeptr insert_into_exp_list(Expnodeptr* list, Expnodeptr tmp, Expnodeptr inserted)
{
 if (tmp != NULL)
   tmp->next = inserted;
 else 
   *list = inserted;
 return inserted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4d6f5
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x4d700
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lerils.c
// Function: rule_cover_instance_lerils
int rule_cover_instance_lerils(Decisionconditionptr* rule, int* relevant, Instanceptr inst)
{
 int i, covered;
 covered = YES;
 for (i = 0; i < current_dataset->featurecount; i++)
   if (relevant[i])
     if (!condition_cover_instance(inst, rule[i]))
      {
       covered = NO;
       break;
      }
 return covered;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0xb75f4(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0x4e297
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x4e28a
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xabfc0
cmpl $0x0, %eax
jne 0x4e288
movl $0x0, -0x20(%rbp)
jmp 0x4e297
jmp 0x4e28a
jmp 0x4e28c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4e242
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lerils.c
// Function: description_length_of_rule_lerils
double description_length_of_rule_lerils(Decisionconditionptr* rule, int* relevant, Instanceptr instances, int positive)
{
 int i, s = 0, n = 0, p = 0;
 Instanceptr tmp;
 for (i = 0; i < current_dataset->featurecount; i++)
   if (relevant[i])
     s++;
 if (s == 0)
   return +INT_MAX;
 tmp = instances;
 while (tmp)
  {
   if (rule_cover_instance_lerils(rule, relevant, tmp))
    {
     if (give_classno(tmp) == positive)
       p++;
     else
       n++;
    }
   tmp = tmp->next;
  }
 if (p != 0)
   return (s + n) / (p + 0.0);
 else 
   return INT_MAX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
leaq 0xb7563(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0x4e30c
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x4e2ff
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4e301
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4e2d3
cmpl $0x0, -0x2c(%rbp)
jne 0x4e324
movsd 0x93cf6(%rip), %xmm0    # 0xe2010
movsd %xmm0, -0x8(%rbp)
jmp 0x4e3af
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x4e37b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x4e220
cmpl $0x0, %eax
je 0x4e36d
movq -0x40(%rbp), %rdi
callq 0x43530
cmpl -0x24(%rbp), %eax
jne 0x4e362
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4e36b
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4e36d
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x4e32c
cmpl $0x0, -0x34(%rbp)
je 0x4e3a2
movl -0x2c(%rbp), %eax
addl -0x30(%rbp), %eax
cvtsi2sd %eax, %xmm0
cvtsi2sdl -0x34(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4e3af
movsd 0x93c66(%rip), %xmm0    # 0xe2010
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lerils.c
// Function: split_point_lower_and_upper_limits
int split_point_lower_and_upper_limits(double splitpoint, double* limits, int count)
{
 int lower = 0, upper = count - 1, middle = (lower + upper) / 2;
 while (upper - lower > 1)
  {
   if (splitpoint < limits[middle])
     upper = middle;
   else 
     lower = middle;
   middle = (upper + lower) / 2;
  }
 return lower;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl $0x1, %eax
jle 0x4e435
movsd -0x8(%rbp), %xmm1
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4e41c
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x4e422
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
jmp 0x4e3f1
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lerils.c
// Function: learn_ruleset_lerils_oneclass
Ruleset learn_ruleset_lerils_oneclass(Instanceptr instances, Lerils_parameterptr param, int positive)
{
 Ruleset rule_pool, result;
 rule_pool = generate_rule_pool(instances, positive, param->pool_size, param->flip_probability);
 result = optimal_subset_of_rule_pool(rule_pool, instances, positive, param->restarts);
 free_ruleset(rule_pool);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, -0x98(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
leaq -0x68(%rbp), %rdi
callq 0x4e440
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x28, %edx
callq 0x42b0
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x20(%rbp), %rdi
movq %rsp, %rax
movq %rdi, 0x20(%rax)
movups -0x40(%rbp), %xmm0
movups -0x30(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x90(%rbp), %rdi
callq 0x4f2e0
movq -0xa0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
movl $0x28, %edx
callq 0x42b0
movq -0x20(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x40(%rbp), %xmm0
movups -0x30(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xaddb0
movq -0x98(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lerils.c
// Function: learn_ruleset_lerils
Ruleset learn_ruleset_lerils(Instanceptr* instances, Lerils_parameterptr param)
{
 int i;
 Ruleset* sets;
 Ruleset result;
 sets = safemalloc(current_dataset->classno * sizeof(Ruleset), "learn_ruleset_lerils", 3);
 for (i = 0; i < current_dataset->classno; i++) 
   sets[i] = learn_ruleset_lerils_oneclass(*instances, param, i);
 result = order_rulesets(sets, instances);
 for (i = 0; i < current_dataset->classno; i++) 
   safe_free(sets[i].counts);
 safe_free(sets);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, -0x78(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
leaq 0xb5fce(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rax
imulq $0x28, %rax, %rdi
leaq 0x96ae3(%rip), %rsi     # 0xe6367
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0xb5f9d(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x4f8f8
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq -0x48(%rbp), %rdi
callq 0x4f590
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0x28, %edx
callq 0x42b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4f899
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x4f660
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x28, %edx
callq 0x42b0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0xb5f14(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x4f957
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x52e80
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4f922
movq -0x20(%rbp), %rdi
callq 0x52e80
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: clone_array_2d
double** clone_array_2d(double** source, int size1, int size2)
{
 /*!Last Changed 15.03.2007 Oya*/
 int i;
 double** result;
 result = (double **) safemalloc_2d(sizeof(double*), sizeof(double), size1, size2, "clone_array_2d", 3);
 for (i = 0; i < size1; i++)
   memcpy(result[i], source[i], size2 * sizeof(double));
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movl $0x8, %esi
leaq 0x96905(%rip), %r8      # 0xe6399
movl $0x3, %r9d
movq %rsi, %rdi
callq 0x53120
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4fae5
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movslq -0x10(%rbp), %rdx
shlq $0x3, %rdx
callq 0x42b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4faad
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: sort_function_array_2d
int sort_function_array_2d(double** array, int i, int j, int index, int sort_type)
{
 if (sort_type == ASCENDING)
  {
   if (array[i][index] < array[j][index])
     return -1;
   else
     if (array[i][index] > array[j][index])
       return 1;
     else
       return 0;
  }
 else
  {
   if (array[i][index] < array[j][index])
     return 1;
   else
     if (array[i][index] > array[j][index])
       return -1;
     else
       return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x4fb85
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4fb47
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4fbfa
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x4fb7c
movl $0x1, -0x4(%rbp)
jmp 0x4fbfa
movl $0x0, -0x4(%rbp)
jmp 0x4fbfa
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4fbbe
movl $0x1, -0x4(%rbp)
jmp 0x4fbfa
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x4fbf3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4fbfa
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: exchange_array_2d
void exchange_array_2d(double** array, int i, int j, int size2)
{
 double* tmp;
 tmp = safemalloc(size2 * sizeof(double), "exchange_array_2d", 2);
 memcpy(tmp, array[i], size2 * sizeof(double));
 memcpy(array[i], array[j], size2 * sizeof(double));
 memcpy(array[j], tmp, size2 * sizeof(double));
 safe_free(tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x96784(%rip), %rsi     # 0xe63a8
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movslq -0x14(%rbp), %rdx
shlq $0x3, %rdx
callq 0x42b0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movslq -0x14(%rbp), %rdx
shlq $0x3, %rdx
callq 0x42b0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x20(%rbp), %rsi
movslq -0x14(%rbp), %rdx
shlq $0x3, %rdx
callq 0x42b0
movq -0x20(%rbp), %rdi
callq 0x52e80
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: quicksort_three_elements_array_2d
int quicksort_three_elements_array_2d(double** array, int size2, int index, int sort_type, int start, int end)
{
 int mid = (start + end) / 2;
 if (sort_function_array_2d(array, mid, start, index, sort_type) < 0)
   exchange_array_2d(array, start, mid, size2);
 if (sort_function_array_2d(array, end, mid, index, sort_type) < 0)
   exchange_array_2d(array, end, mid, size2);
 if (sort_function_array_2d(array, mid, start, index, sort_type) < 0)
   exchange_array_2d(array, mid, start, size2);
 exchange_array_2d(array, mid, end, size2);
 return end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
callq 0x4faf0
cmpl $0x0, %eax
jge 0x4fcfb
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0xc(%rbp), %ecx
callq 0x4fc00
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
callq 0x4faf0
cmpl $0x0, %eax
jge 0x4fd28
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0xc(%rbp), %ecx
callq 0x4fc00
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
callq 0x4faf0
cmpl $0x0, %eax
jge 0x4fd55
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0xc(%rbp), %ecx
callq 0x4fc00
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
movl -0xc(%rbp), %ecx
callq 0x4fc00
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: quicksort_partition_array_2d
int quicksort_partition_array_2d(double** array, int size2, int index, int sort_type, int start, int end)
{
 int i = start - 1, j, pivot;
 pivot = quicksort_three_elements_array_2d(array, size2, index, sort_type, start, end);
 for (j = start; j < end; j++)
   if (sort_function_array_2d(array, j, pivot, index, sort_type) <= 0)
    {
     i++;
     exchange_array_2d(array, i, j, size2);
    }
 exchange_array_2d(array, i + 1, end, size2);
 return i + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
callq 0x4fca0
movl %eax, -0x28(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4fe04
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
callq 0x4faf0
cmpl $0x0, %eax
jg 0x4fdf7
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movl -0xc(%rbp), %ecx
callq 0x4fc00
jmp 0x4fdf9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4fdb9
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
addl $0x1, %esi
movl -0x1c(%rbp), %edx
movl -0xc(%rbp), %ecx
callq 0x4fc00
movl -0x20(%rbp), %eax
addl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: quicksort_check_array_2d
int quicksort_check_array_2d(double** array, int size2, int index, int sort_type, int start, int end)
{
 int i;
 for (i = start + 1; i <= end; i++)
   if (sort_function_array_2d(array, i - 1, i, index, sort_type) > 0)
     return 0;
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jg 0x4fe92
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
subl $0x1, %esi
movl -0x28(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0x4faf0
cmpl $0x0, %eax
jle 0x4fe85
movl $0x0, -0x4(%rbp)
jmp 0x4fe99
jmp 0x4fe87
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4fe56
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: quicksort_array_2d
void quicksort_array_2d(double** array, int size2, int index, int sort_type, int start, int end)
{
 int pivot;
 if (start < end)
  {
   if (quicksort_check_array_2d(array, size2, index, sort_type, start, end))
     return;
   pivot = quicksort_partition_array_2d(array, size2, index, sort_type, start, end);
   quicksort_array_2d(array, size2, index, sort_type, start, pivot - 1);
   quicksort_array_2d(array, size2, index, sort_type, pivot + 1, end);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4ff4f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
callq 0x4fe30
cmpl $0x0, %eax
je 0x4fef6
jmp 0x4ff4f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
callq 0x4fd70
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x20(%rbp), %r9d
subl $0x1, %r9d
callq 0x4feb0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x20(%rbp), %r8d
addl $0x1, %r8d
movl -0x1c(%rbp), %r9d
callq 0x4feb0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: divide_array
void divide_array(double* list1, double div, int size)
{
 /*!Last Changed 13.03.2007 Oya*/
 int i;
 for (i = 0; i < size; i++)
   if (div != 0)
     list1[i] /= div;
   else
    {
     printf(m1377, "divide_array");
     list1[i] = 0.0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4ffe4
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4ff95
jp 0x4ff95
jmp 0x4ffb2
movsd -0x10(%rbp), %xmm1
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x4ffd7
leaq 0x96401(%rip), %rdi     # 0xe63ba
leaq 0x9641b(%rip), %rsi     # 0xe63db
movb $0x0, %al
callq 0x4030
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x4ffd9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4ff7b
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: find_bin
int find_bin(double* bins, int bincount, double value)
{
 /*!Last Changed 26.01.2005*/
 int i;
 double sum = 0;
 for (i = 0; i < bincount; i++)
  {
   sum += bins[i];
   if (value < sum)
     return i;
  }
 return bincount - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x50053
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x50046
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5005c
jmp 0x50048
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5000f
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: find_max_in_list
int find_max_in_list(int *list,int size)
{
/*!Last Changed 14.07.2001*/
 int max = -INT_MAX, i, res = -1;
 for (i = 0; i < size; i++)
   if (list[i] > max)
    {
     max = list[i];
     res = i;
    }
 return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x80000001, -0x10(%rbp) # imm = 0x80000001
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x500c9
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x10(%rbp), %eax
jle 0x500bc
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x500be
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x50090
movl -0x18(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: find_max_in_list_double
int find_max_in_list_double(double* list, int size)
{ 
 double max = 0;
 int i, res = -1;
 for (i = 0; i < size; i++)
   if (list[i] != -1)
     if (list[i] > max)
      {
       max = list[i];
       res = i;
      }
 return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x50153
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x9293a(%rip), %xmm1    # 0xe2a48
ucomisd %xmm1, %xmm0
jne 0x50118
jp 0x50118
jmp 0x50146
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x50144
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x50146
jmp 0x50148
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x500f1
movl -0x20(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: find_mean_stdev_of_list
double find_mean_stdev_of_list(double* list, int size, double* stdev)
{
 /*!Last Changed 26.01.2005*/
 int i;
 double sum = 0, mean;
 for (i = 0; i < size; i++)
   sum += list[i];
 mean = sum / size;
 sum = 0;
 for (i = 0; i < size; i++)
   sum += (list[i] - mean) * (list[i] - mean);
 *stdev = sqrt(sum / (size - 1));
 return mean;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5039c
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x50372
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x50407
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
subsd -0x30(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x503be
movsd -0x28(%rbp), %xmm0
movl -0xc(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
callq 0x42a0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: find_min_in_list_double
int find_min_in_list_double(double* list, int size)
{
 /*!Last Changed 01.02.2005*/
 double min = +INT_MAX;
 int i, res = -1;
 for (i = 0; i < size; i++)
   if (list[i] != -1)
     if (list[i] < min)
      {
       min = list[i];
       res = i;
      }
 return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd 0x91b6d(%rip), %xmm0    # 0xe2010
movsd %xmm0, -0x18(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5051c
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x92575(%rip), %xmm1    # 0xe2a48
ucomisd %xmm1, %xmm0
jne 0x504dd
jp 0x504dd
jmp 0x5050f
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5050d
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x5050f
jmp 0x50511
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x504b6
movl -0x20(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: find_mod_of_list
int find_mod_of_list(int *list, int size, int newlistsize)
{
 /*!Last Changed 03.03.2006 added by aydin*/
 int mod, *newlist, i;
 newlist = safecalloc(newlistsize, sizeof(int), "find_mod_of_list", 2);
 for (i = 0 ; i < size ; i++)
   if (list[i] >= 0 && list[i] < newlistsize)
     newlist[list[i]]++;
   else
     printf(m1322, "find_mod_of_list");
 mod = find_max_in_list(newlist, newlistsize);
 safe_free(newlist);
 return mod;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movslq -0x10(%rbp), %rdi
movl $0x4, %esi
leaq 0x95ea7(%rip), %rdx     # 0xe63f9
movl $0x2, %ecx
callq 0x52f40
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x505ca
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x505a8
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x10(%rbp), %eax
jge 0x505a8
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x505bd
leaq 0x95e5b(%rip), %rdi     # 0xe640a
leaq 0x95e43(%rip), %rsi     # 0xe63f9
movb $0x0, %al
callq 0x4030
jmp 0x505bf
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x50567
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x50070
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
callq 0x52e80
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: findMaxOutput
int findMaxOutput(double *Y, int length)
{
 int max = 0;
 int c;
 for (c = 0; c < length; c++)
  {
   if (Y[max] <= Y[c])
     max = c;
  }
 return max;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x50644
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x50637
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x50639
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x50609
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: log_of_array
double* log_of_array(double* list, int size)
{
 /*!Last Changed 22.01.2007*/
 int i;
 double* result;
 result = safemalloc(size * sizeof(double), "log_of_array", 3);
 for (i = 0; i < size; i++)
   result[i] = safelog(list[i]);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x95d7c(%rip), %rsi     # 0xe642a
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x506f5
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x52b10
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x506c3
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: multiply_two_arrays
double multiply_two_arrays(double* list1, double* list2, int size)
{
 /*!Last Changed 13.03.2007 Oya*/
 int i;
 double result = 0.0;
 for (i = 0; i < size; i++)
   result += list1[i] * list2[i];
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x507ad
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5076e
movsd -0x20(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: multiply_two_arrays_by_value
double* multiply_two_arrays_by_value(double* list1, double* list2, int size)
{
 /*!Last Changed 13.03.2007 Oya*/
 int i;
 double* result;
 result = safemalloc(size * sizeof(double), "multiply_two_arrays_by_value", 3);
 for (i = 0; i < size; i++)
   result[i] = list1[i] * list2[i];
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x95c55(%rip), %rsi     # 0xe6437
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x50831
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x507f7
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: search_and_add_into_list
void search_and_add_into_list(int* list, int* itemcount, int newitem)
{
 /*!Last Changed 17.07.2005*/
 int i, j;
 for (i = 0; i < *itemcount; i++)
   if (list[i] > newitem)
     break;
   else
     if (list[i] == newitem)
       return;
 for (j = *itemcount - 1; j >= i; j--)
   list[j + 1] = list[j];
 list[i] = newitem;
 (*itemcount)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x50894
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jle 0x50873
jmp 0x50894
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x50885
jmp 0x508e7
jmp 0x50887
jmp 0x50889
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x50856
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x508ce
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x508a0
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: search_list
int search_list(int* list, int itemcount, int item)
{
 /*!Last Changed 18.07.2005*/
 int i;
 for (i = 0; i < itemcount; i++)
   if (list[i] == item)
     return i;
 return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x50932
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rbp), %eax
jne 0x50925
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x50939
jmp 0x50927
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x50905
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: sum_of_list
int sum_of_list(int* list, int size)
{
 /*!Last Changed 28.05.2005*/
 int i, sum = 0;
 for (i = 0; i < size; i++)
   sum += list[i];
 return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5097d
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x50959
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)