LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: find_arc_no
int find_arc_no(bayesiangraphptr G,int from, int to, int *arc_no, int *before)
{
/* eger belirtilen arc yoksa 0 a varsa 1 e donsun....*/
/* arc_no from-->to arcinin numarasi, before bundan bir oncekinin numarasi*/
/*!Last Changed 03.01.2001*/
 *before = -1;
 if ((to<0)||(to>=G->nodecount))
   return 0;
 if ((from<0)||(from>=G->nodecount))
   return 0;
 *arc_no=G->nodes[to].pointer;
 while ((*arc_no!=-1)&&(G->dest[*arc_no]!=from))
  {
   *before=*arc_no;
   *arc_no=G->arcs[*arc_no].pointer;
  }
 if (*arc_no==-1)
   return 0;
 else
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
cmpl $0x0, -0x18(%rbp)
jl 0x70ec2
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jl 0x70ece
movl $0x0, -0x4(%rbp)
jmp 0x70f79
cmpl $0x0, -0x14(%rbp)
jl 0x70ee0
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jl 0x70eec
movl $0x0, -0x4(%rbp)
jmp 0x70f79
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movl 0x30(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl $-0x1, (%rcx)
movb %al, -0x29(%rbp)
je 0x70f31
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x70f3a
jmp 0x70f60
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x70f08
movq -0x20(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x70f72
movl $0x0, -0x4(%rbp)
jmp 0x70f79
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: create_graph
bayesiangraphptr create_graph(char *graph_name)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 07.03.2001*/
 bayesiangraphptr result;
 result = (bayesiangraphptr)safemalloc(sizeof(bayesiangraph), "create_graph", 2);
 result->nodecount=0;
 result->arccount=0;
 result->ordering=NULL;
 result->independence=NULL;
 result->one_independence=NULL;
 result->name=strcopy(result->name,graph_name);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x48, %edi
leaq 0x762db(%rip), %rsi     # 0xe7273
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x54ba0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: deallocate_graph
void deallocate_graph(bayesiangraphptr G)
{
 /*!Last Changed 07.03.2001*/
 int i;
 safe_free(G->name);
 for (i = 0; i < G->nodecount; i++)
  {
   safe_free(G->nodes[i].name);
			free_2d((void**)G->nodes[i].values, G->nodes[i].value_count);
   if (G->nodes[i].parents)
     safe_free(G->nodes[i].parent_counts);
			free_2d((void**)G->nodes[i].table, G->nodes[i].table_count);
  }
 if (G->independence!=NULL)
		 free_2d((void**)G->independence, G->nodecount);
 if (G->one_independence!=NULL)
		 free_3d((void***)G->one_independence, G->nodecount, G->nodecount);
 safe_free(G->dest);
 safe_free(G->arcs);
 safe_free(G->nodes);
 safe_free(G);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x52e80
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x71104
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %esi
callq 0x52e20
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x20(%rax)
je 0x710c1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rax
movl %eax, %esi
callq 0x52e20
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7102f
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x71123
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x52e20
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x71149
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x52ea0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: swap_independence
void swap_independence(double **result,int i,int j)
{
/*!Last Changed 11.02.2001*/
 double temp;
 int k;
 for (k=0;k<3;k++)
  {
   temp=result[i][k];
   result[i][k]=result[j][k];
   result[j][k]=temp;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x71204
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x71195
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: qsort_independence
void qsort_independence(double **result,int left,int right)
{
/*!Last Changed 11.02.2001*/
 int i,last;
 if (left>=right)
   return;
 swap_independence(result,left,(left+right)/2);
 last=left;
 for (i=left+1;i<=right;i++)
   if (result[i][2]>result[left][2])
    {
     last++;
     swap_independence(result,last,i);
    }
 swap_independence(result,left,last);
 qsort_independence(result,left,last-1);
 qsort_independence(result,last+1,right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jl 0x7122f
jmp 0x712de
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edx
callq 0x71180
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x712ab
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
ucomisd 0x10(%rax), %xmm0
jbe 0x7129e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x71180
jmp 0x712a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7125a
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x71180
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
subl $0x1, %edx
callq 0x71210
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x71210
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: sort_independence
double **sort_independence(bayesiangraphptr mygraph)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 21.01.2001*/
 int total=(mygraph->nodecount)*(mygraph->nodecount-1)/2,i,j,k;
 double **result;
 result = (double **)safemalloc_2d(sizeof(double *), sizeof(double), total, 3, "sort_independence", 3);
 k=0;
 for (i=0;i<mygraph->nodecount;i++)
   for (j=i+1;j<mygraph->nodecount;j++)
    {
     result[k][0]=i;
     result[k][1]=j;
     result[k][2]=mygraph->independence[i][j];
     k++;
    }
 qsort_independence(result,0,total-1);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edx
movl $0x8, %esi
movl $0x3, %r9d
leaq 0x75f50(%rip), %r8      # 0xe7280
movq %rsi, %rdi
movl %r9d, %ecx
callq 0x53120
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x713eb
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x713db
cvtsi2sdl -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd %xmm0, (%rax)
cvtsi2sdl -0x14(%rbp), %xmm0
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd %xmm0, 0x10(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x71366
jmp 0x713dd
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7134d
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x71210
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: cycle_now
int cycle_now(bayesiangraphptr mygraph,int from,int to)
{
/*!Last Changed 25.02.2001*/
/*Daha onceden fromdan toya bir arc vard. Bu arc yon degistirince cycle oluyor mu?*/
 int pos;
 pos=mygraph->nodes[to].pointer;
 while (pos!=-1)
  {
   if (from==mygraph->dest[pos])
     return 1;
   if (cycle_now(mygraph,from,mygraph->dest[pos]))
     return 1;
   pos=mygraph->arcs[pos].pointer;
  }
 return 0; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movl 0x30(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x7149b
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x7145e
movl $0x1, -0x4(%rbp)
jmp 0x714a2
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x71410
cmpl $0x0, %eax
je 0x71487
movl $0x1, -0x4(%rbp)
jmp 0x714a2
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
jmp 0x7143b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: add_arcs_according_to_ordering
void add_arcs_according_to_ordering(bayesiangraphptr mygraph,double **edges,int edgecount)
{
/*!Last Changed 13.03.2001*/
 int i,j,k;
 for (i = 0; i < edgecount; i++)
  {
   j = (int) edges[i][0];
   k = (int) edges[i][1];
   add_one_arc(mygraph);
   if (mygraph->ordering[j]>mygraph->ordering[k])
    {
     add_one_pointer(mygraph,&mygraph->nodes[j],k);
     add_parent_counts(mygraph,&mygraph->nodes[j],k);
    }
   else
    {
     add_one_pointer(mygraph,&mygraph->nodes[k],j);
     add_parent_counts(mygraph,&mygraph->nodes[k],j);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x71ed4
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cvttsd2si (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cvttsd2si 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x70a70
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
movslq -0x20(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x71e86
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x1c(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rsi
movl -0x20(%rbp), %edx
callq 0x70b20
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x1c(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rsi
movl -0x20(%rbp), %edx
callq 0x70c80
jmp 0x71ec4
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x20(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rsi
movl -0x1c(%rbp), %edx
callq 0x70b20
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x20(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rsi
movl -0x1c(%rbp), %edx
callq 0x70c80
jmp 0x71ec6
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x71dea
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: load_network
void load_network(char *filename)
{
 int i = net_extension(filename);
 bayesiangraphptr newnetwork = NULL;
 switch (i)
  {
   case NET_FILE  :newnetwork = (bayesiangraphptr)read_network_net(filename);
                   break;
   case XML_FILE  :newnetwork = (bayesiangraphptr)read_network_xml(filename);
                   break;
   case HUGIN_FILE:newnetwork = (bayesiangraphptr)read_network_hugin(filename);
                   break;
   case BIF_FILE  :newnetwork = (bayesiangraphptr)read_network_bif(filename);
                   break;
 };
 if (newnetwork==NULL)
  {
   printf(m1044);
   return;
  }
 add_network(newnetwork);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x514e0
movl %eax, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0x726eb
movq -0x20(%rbp), %rax
leaq 0x74b98(%rip), %rcx     # 0xe7240
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x9fbd0
movq %rax, -0x18(%rbp)
jmp 0x726eb
movq -0x8(%rbp), %rdi
callq 0x9ef90
movq %rax, -0x18(%rbp)
jmp 0x726eb
movq -0x8(%rbp), %rdi
callq 0x9eb30
movq %rax, -0x18(%rbp)
jmp 0x726eb
movq -0x8(%rbp), %rdi
callq 0x9e430
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x72702
leaq 0x74bbf(%rip), %rdi     # 0xe72b8
movb $0x0, %al
callq 0x4030
jmp 0x7270b
movq -0x18(%rbp), %rdi
callq 0x725f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: print_independences
void print_independences(void (*print)(bayesiangraphptr mygraph), char* networkname)
{
 bayesiangraphptr G;
 if (networkname)
  {
   G = find_network(networkname);
   if (G)
     print(G);
   else
     printf(m1273, networkname);
  }
 else
   printf(m1020);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7276b
movq -0x10(%rbp), %rdi
callq 0x72780
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x72757
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rdi
callq *%rax
jmp 0x72769
movq -0x10(%rbp), %rsi
leaq 0x74b71(%rip), %rdi     # 0xe72d3
movb $0x0, %al
callq 0x4030
jmp 0x72779
leaq 0x74b7a(%rip), %rdi     # 0xe72ec
movb $0x0, %al
callq 0x4030
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: find_network
bayesiangraphptr find_network(char *name)
{
 int i;
 for (i=0;i<graphcount;i++)
   if (strcmp(Graphs[i]->name,name)==0)
     return Graphs[i];
 return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x92d33(%rip), %rcx     # 0x1054d0
cmpl (%rcx), %eax
jge 0x727e9
leaq 0x2f5690(%rip), %rax    # 0x367e38
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4210
cmpl $0x0, %eax
jne 0x727dc
leaq 0x2f566d(%rip), %rax    # 0x367e38
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x727f1
jmp 0x727de
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x72793
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: learn_network
void learn_network(char *graph_name, char *train_file, char *cv_file, char *test_file, int algorithm)
{
 bayesiangraphptr newnetwork;
 switch (algorithm){
   case 0:newnetwork = (bayesiangraphptr)simulated_annealing_bn(graph_name, train_file, cv_file, test_file, get_parameter_l("ordering"), get_parameter_f("infthreshold"));
          break;
   case 1:newnetwork = (bayesiangraphptr)k2_bn(graph_name, train_file, cv_file, test_file, get_parameter_l("ordering"), 2);
          break;
 }
 if (newnetwork)
   add_network(newnetwork);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x72838
jmp 0x7282b
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0x72892
jmp 0x728e0
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x74cf5(%rip), %rdi     # 0xe7554
callq 0x792b0
movl %eax, -0x38(%rbp)
leaq 0x74a92(%rip), %rdi     # 0xe7300
callq 0x79040
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
movl -0x38(%rbp), %r8d
callq 0xc5920
movq %rax, -0x30(%rbp)
jmp 0x728e0
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x74c9b(%rip), %rdi     # 0xe7554
callq 0x792b0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rcx
movl %eax, %r8d
movl $0x2, %r9d
callq 0xc5ab0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x728f0
movq -0x30(%rbp), %rdi
callq 0x725f0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/nodeboundedtree.c
// Function: prune_node_bounded_tree_nodes
void prune_node_bounded_tree_nodes(Decisionnodeptr root, Decisionnodeptr toberemoved, Nodeboundedtree_parameterptr param, Decisionnodeptr* nodes, double* generalizationerror, int* index, int datasize)
{
 /*!Last Changed 30.09.2007*/
 int tmp, h;
 double error;
 if (toberemoved->featureno == LEAF_NODE)
   return;
 (*index)++;
 nodes[*index] = toberemoved;
 tmp = toberemoved->featureno;
 toberemoved->featureno = LEAF_NODE;
 error = decisiontree_falsepositive_count(root) / (datasize + 0.0);
 h = decisiontree_vc_dimension_wrt_nodetype(current_dataset, decisiontree_node_count(root), param->model - 5);
 generalizationerror[*index] = srm_classification(error, h, datasize, param->a1, param->a2);
 toberemoved->featureno = tmp;
 prune_node_bounded_tree_nodes(root, toberemoved->left, param, nodes, generalizationerror, index, datasize);
 prune_node_bounded_tree_nodes(root, toberemoved->right, param, nodes, generalizationerror, index, datasize);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x72932
jmp 0x72a3f
movq -0x30(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movslq (%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0x28a70
cvtsi2sd %eax, %xmm0
cvtsi2sdl 0x10(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
leaq 0x92eb2(%rip), %rax     # 0x105840
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28de0
movq -0x48(%rbp), %rdi
movl %eax, %esi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
subl $0x5, %edx
callq 0xe0580
movl %eax, -0x38(%rbp)
movsd -0x40(%rbp), %xmm0
movl -0x38(%rbp), %edi
movl 0x10(%rbp), %esi
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm2
callq 0x67a20
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movslq (%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movl 0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x72900
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movl 0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x72900
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/nodeboundedtree.c
// Function: add_node_to_heap
void add_node_to_heap(Decisionnodeptr node, Node_expandedptr* list, int nodeindex)
{
 /*!Last Changed 11.07.2006*/
 Node_expandedptr newexpanded, tmp, tmpbefore = NULL;
 newexpanded = safemalloc(sizeof(Node_expanded), "add_node_to_expanded_list", 8);
 newexpanded->next = NULL;
 newexpanded->node = node;
 if (nodeindex == -1)
   newexpanded->value = -log_likelihood_for_classification(node->counts);
 else
   if (nodeindex == -2)
     newexpanded->value = -entropy(node->counts);
   else
     newexpanded->value = -nodeindex;
 if (!(*list))
   *list = newexpanded;
 else
  {
   tmp = *list;
   while (tmp && tmp->value > newexpanded->value)
    {
     tmpbefore = tmp;
     tmp = tmp->next;
    }
   if (tmpbefore)
    {
     newexpanded->next = tmpbefore->next;
     tmpbefore->next = newexpanded;
    }
   else
    {
     newexpanded->next = *list;
     *list = newexpanded;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x18, %edi
leaq 0x74705(%rip), %rsi     # 0xe733c
movl $0x8, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpl $-0x1, -0x14(%rbp)
jne 0x72c94
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0x2ab10
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x72ce0
cmpl $-0x2, -0x14(%rbp)
jne 0x72ccc
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0x2a600
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x72cde
xorl %eax, %eax
subl -0x14(%rbp), %eax
cvtsi2sd %eax, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x72ce0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x72cfa
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x72d89
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
je 0x72d29
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
seta %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x72d32
jmp 0x72d48
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x72d05
cmpq $0x0, -0x30(%rbp)
je 0x72d6d
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x72d87
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x72d89
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/nodeboundedtree.c
// Function: add_node_to_expanded_list
int add_node_to_expanded_list(Decisionnodeptr node, Node_expandedptr* list, int nodeindex, int usediscrete)
{
 /*!Last Changed 01.07.2006 added nodeindex*/
 /*!Last Changed 19.03.2006*/
 if (!usediscrete)
   node->conditiontype = HYBRID_CONDITION;
 else
   node->conditiontype = UNIVARIATE_CONDITION;
 if (!can_be_divided(node, NULL))
  {
   make_leaf_node(node);
   return 0;
  }
 add_node_to_heap(node, list, nodeindex);
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x72dbc
movq -0x10(%rbp), %rax
movl $0x2, 0x98(%rax)
jmp 0x72dca
movq -0x10(%rbp), %rax
movl $0x0, 0x98(%rax)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x29340
cmpl $0x0, %eax
jne 0x72dee
movq -0x10(%rbp), %rdi
callq 0x28a30
movl $0x0, -0x4(%rbp)
jmp 0x72e05
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x72c10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/nodeboundedtree.c
// Function: empty_heap
void empty_heap(Node_expandedptr header)
{
 /*!Last Changed 01.07.2006*/
 Node_expandedptr nextexpanded;
 while (header)
  {
   nextexpanded = header->next;
   make_leaf_node(header->node);
   safe_free(header);
   header = nextexpanded;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x72e4e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x28a30
movq -0x8(%rbp), %rdi
callq 0x52e80
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x72e1c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/nodeboundedtree.c
// Function: create_binary_tree_according_model_string
Decisionnodeptr create_binary_tree_according_model_string(char* model)
{
 /*!Last Changed 11.07.2006*/
 Node_expandedptr header = NULL, nextexpanded;
 int nodeindex = 0;
 char ch;
 Decisionnodeptr rootnode, expanded_node, leftnode, rightnode;
 rootnode = createnewnode(NULL, 1);
 add_node_to_heap(rootnode, &header, nodeindex);
 nodeindex++;
 while (header)
  {
   nextexpanded = header->next;
   expanded_node = header->node;
   ch = model[-2 * (int) (header->value) + 1];
   safe_free(header);
   header = nextexpanded;
   expanded_node->featureno = DUMMY_MODEL;
   leftnode = createnewnode(expanded_node, 1);
   expanded_node->left = leftnode;
   rightnode = createnewnode(expanded_node, 1);
   expanded_node->right = rightnode; 
   switch (ch)
    {
     case '1':add_node_to_heap(leftnode, &header, nodeindex);
              nodeindex++;
              break;
     case '2':add_node_to_heap(leftnode, &header, nodeindex);
              nodeindex++;
              add_node_to_heap(rightnode, &header, nodeindex);
              nodeindex++;
              break;
    }
  }
 return rootnode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x29480
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq -0x10(%rbp), %rsi
callq 0x72c10
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x72fa7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cvttsd2si 0x8(%rcx), %edx
addl %edx, %edx
movl $0x1, %ecx
movl %ecx, -0x48(%rbp)
subl %edx, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
callq 0x52e80
movl -0x48(%rbp), %esi
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
movl $0xfffffc18, 0x30(%rax) # imm = 0xFFFFFC18
movq -0x30(%rbp), %rdi
callq 0x29480
movl -0x48(%rbp), %esi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
callq 0x29480
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movsbl -0x1d(%rbp), %eax
movl %eax, -0x44(%rbp)
subl $0x31, %eax
je 0x72f55
jmp 0x72f4b
movl -0x44(%rbp), %eax
subl $0x32, %eax
je 0x72f70
jmp 0x72fa2
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq -0x10(%rbp), %rsi
callq 0x72c10
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x72fa2
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq -0x10(%rbp), %rsi
callq 0x72c10
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq -0x10(%rbp), %rsi
callq 0x72c10
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x72ea6
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/omnivariaterule.c
// Function: write_nodetypes_rule
void write_nodetypes_rule(Ruleset r, char* st)
{
 /*!Last Changed 19.02.2005*/
 /*!Last Changed 24.01.2004*/
 Decisionruleptr tmprule;
 Decisionconditionptr tmpcondition;
 sprintf(st, "%s", "");
 tmprule = r.start;
 while (tmprule)
  {
   tmpcondition = tmprule->start;
   while (tmpcondition)
    {     
     if (tmpcondition->featureindex == LINEAR)
       sprintf(st, "%sL", st);
     else
       if (tmpcondition->featureindex == QUADRATIC)
         sprintf(st, "%sQ", st);
       else 
         if (tmpcondition->featureindex == UNIVARIATE)
           sprintf(st, "%sU", st);
         else
           if (tmpcondition->featureindex == DISCRETEMIX)
             sprintf(st, "%s%c", st, 'A' + tmpcondition->ksplit.featurecount - 1);
           else
             sprintf(st, "%sU", st);
     tmpcondition = tmpcondition->next;
    }
   sprintf(st, "%s-%d;", st, tmprule->classno);
   tmprule = tmprule->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x71279(%rip), %rsi     # 0xe4a98
leaq 0x7a7b4(%rip), %rdx     # 0xedfda
movb $0x0, %al
callq 0x4170
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x73948
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7391b
movq -0x18(%rbp), %rax
cmpl $-0x2, (%rax)
jne 0x7387e
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x73b49(%rip), %rsi     # 0xe73bb
movb $0x0, %al
callq 0x4170
jmp 0x7390a
movq -0x18(%rbp), %rax
cmpl $-0x3, (%rax)
jne 0x7389f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x73b29(%rip), %rsi     # 0xe73bf
movb $0x0, %al
callq 0x4170
jmp 0x73908
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x738c0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x73b0c(%rip), %rsi     # 0xe73c3
movb $0x0, %al
callq 0x4170
jmp 0x73906
movq -0x18(%rbp), %rax
cmpl $-0x5, (%rax)
jne 0x738ee
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x50(%rax), %ecx
addl $0x41, %ecx
subl $0x1, %ecx
leaq 0x6f90b(%rip), %rsi     # 0xe31f0
movb $0x0, %al
callq 0x4170
jmp 0x73904
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x73ac6(%rip), %rsi     # 0xe73c3
movb $0x0, %al
callq 0x4170
jmp 0x73906
jmp 0x73908
jmp 0x7390a
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7384f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
leaq 0x73a97(%rip), %rsi     # 0xe73c7
movb $0x0, %al
callq 0x4170
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x73838
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/omnivariaterule.c
// Function: write_datasizes_and_nodetypes_rule
void write_datasizes_and_nodetypes_rule(Ruleset r, char* st)
{
 /*!Last Changed 19.02.2005*/
 /*!Last Changed 24.01.2004*/
 Decisionruleptr tmprule;
 Decisionconditionptr tmpcondition;
 sprintf(st, "%s", "");
 tmprule = r.start;
 while (tmprule)
  {
   tmpcondition = tmprule->start;
   while (tmpcondition)
    {
     sprintf(st,"%s-%d,",st,tmpcondition->datasize);
     if (tmpcondition->featureindex == LINEAR)
       sprintf(st,"%sL",st);
     else 
       if (tmpcondition->featureindex == QUADRATIC)         
         sprintf(st,"%sQ",st);
       else
         sprintf(st,"%sU",st);
     tmpcondition = tmpcondition->next;
    }
   sprintf(st,"%s;",st);
   tmprule = tmprule->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x71129(%rip), %rsi     # 0xe4a98
leaq 0x7a664(%rip), %rdx     # 0xedfda
movb $0x0, %al
callq 0x4170
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x73a59
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x73a32
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x38(%rax), %ecx
leaq 0x73a0e(%rip), %rsi     # 0xe73ce
movb $0x0, %al
callq 0x4170
movq -0x18(%rbp), %rax
cmpl $-0x2, (%rax)
jne 0x739e8
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x739dc(%rip), %rsi     # 0xe73bb
movb $0x0, %al
callq 0x4170
jmp 0x73a21
movq -0x18(%rbp), %rax
cmpl $-0x3, (%rax)
jne 0x73a09
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x739bf(%rip), %rsi     # 0xe73bf
movb $0x0, %al
callq 0x4170
jmp 0x73a1f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x739ab(%rip), %rsi     # 0xe73c3
movb $0x0, %al
callq 0x4170
jmp 0x73a21
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7399f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x73994(%rip), %rsi     # 0xe73d5
movb $0x0, %al
callq 0x4170
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x73988
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/omnivariaterule.c
// Function: log_likelihood_for_rule_induction
double log_likelihood_for_rule_induction(int poscount, int negcount)
{
 /*!Last Changed 20.02.2005*/
 int sum;
 double ratio;
 sum = poscount + negcount;
 if (sum * poscount * negcount == 0)
   return 0;
 ratio = poscount / (sum + 0.0);
 return poscount * log2(ratio);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
imull -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
cmpl $0x0, %eax
jne 0x73a91
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x73ad0
cvtsi2sdl -0xc(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x52ad0
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/omnivariaterule.c
// Function: log_likelihood_of_condition
double log_likelihood_of_condition(Decisionconditionptr c, Instanceptr list, int positive, int* covered)
{
 /*!Last Changed 19.02.2005*/
 int poscovered = 0, negcovered = 0, posuncovered = 0, neguncovered = 0, classno;
 Instanceptr tmp;
 tmp = list;
 while (tmp)
  {
   classno = give_classno(tmp);
   if (condition_cover_instance(tmp, c))
     if (classno == positive)
       poscovered++;
     else
       negcovered++;
   else
     if (classno == positive)
       posuncovered++;
     else
       neguncovered++;
   tmp = tmp->next;
  }
 *covered = poscovered + posuncovered;
 return log_likelihood_for_rule_induction(poscovered, negcovered) + log_likelihood_for_rule_induction(posuncovered, neguncovered);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x73b8a
movq -0x40(%rbp), %rdi
callq 0x43530
movl %eax, -0x34(%rbp)
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xabfc0
cmpl $0x0, %eax
je 0x73b5e
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x73b53
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x73b5c
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x73b7c
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x73b71
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x73b7a
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x73b7c
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x73b1b
movl -0x24(%rbp), %ecx
addl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
callq 0x73a60
movsd %xmm0, -0x48(%rbp)
movl -0x2c(%rbp), %edi
movl -0x30(%rbp), %esi
callq 0x73a60
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
addsd %xmm1, %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/omnivariaterule.c
// Function: log_likelihood_of_rule
double log_likelihood_of_rule(Decisionruleptr c, Instanceptr list, int* covered)
{
 /*!Last Changed 19.02.2005*/
 int poscovered = 0, negcovered = 0, posuncovered = 0, neguncovered = 0, classno;
 Instanceptr tmp;
 tmp = list;
 while (tmp)
  {
   classno = give_classno(tmp);
   if (rule_cover_instance(tmp, *c))
     if (classno == c->classno)
       poscovered++;
     else
       negcovered++;
   else
     if (classno == c->classno)
       posuncovered++;
     else
       neguncovered++;
   tmp = tmp->next;
  }
 *covered = poscovered + posuncovered;
 return log_likelihood_for_rule_induction(poscovered, negcovered) + log_likelihood_for_rule_induction(posuncovered, neguncovered);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x73ca8
movq -0x38(%rbp), %rdi
callq 0x43530
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xacfd0
cmpl $0x0, %eax
je 0x73c76
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x73c6b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x73c74
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x73c97
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x73c8c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x73c95
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x73c97
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x73c0b
movl -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x73a60
movsd %xmm0, -0x40(%rbp)
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
callq 0x73a60
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
addsd %xmm1, %xmm0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/omnivariaterule.c
// Function: generalization_error_after_pruning
double generalization_error_after_pruning(Ruleset r, Instanceptr data, int positive, int modelselectionmethod)
{
 /*!Last Changed 19.02.2005*/
 int *deleted, rulecount, i;
 double result, tmp;
 Decisionruleptr rule;
 deleted = safecalloc(r.rulecount, sizeof(int), "generalization_error_after_pruning", 4);
 result = generalization_error_of_ruleset_with_deleted_rules(r, data, deleted, positive, modelselectionmethod);
 rule = r.start;
 rulecount = 0;
 while (rule && rule->classno != positive)
  {
   rule = rule->next;
   rulecount++;
  }
 for (i = r.rulecount - 1; i >= rulecount; i--)
  {
   deleted[i] = 1;
   tmp = generalization_error_of_ruleset_with_deleted_rules(r, data, deleted, positive, modelselectionmethod);
   if (tmp > result)
     deleted[i] = 0;
   else
     result = tmp;
  }
 safe_free(deleted);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movslq 0x10(%rax), %rdi
movl $0x4, %esi
leaq 0x7320c(%rip), %rdx     # 0xe7426
movl $0x4, %ecx
callq 0x52f40
movq -0x40(%rbp), %r8
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movq 0x20(%r8), %r9
movq %rsp, %rax
movq %r9, 0x20(%rax)
movups (%r8), %xmm0
movups 0x10(%r8), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x73f10
movq -0x40(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x41(%rbp)
je 0x7428c
movq -0x38(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x74295
jmp 0x742ac
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x74271
movq -0x40(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0x7433e
movq -0x40(%rbp), %r8
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movq 0x20(%r8), %r9
movq %rsp, %rax
movq %r9, 0x20(%rax)
movups (%r8), %xmm0
movups 0x10(%r8), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x73f10
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x74324
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x7432e
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x74330
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x742b9
movq -0x18(%rbp), %rdi
callq 0x52e80
movsd -0x28(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/omnivariaterule.c
// Function: find_best_hybrid_condition
Decisionconditionptr find_best_hybrid_condition(Instanceptr* growset, int positive, Ripper_parameterptr param)
{
 /*!Last Changed 19.02.2005*/
 switch (param->modelselectionmethod)
  {
   case MODEL_SELECTION_CV :return find_best_hybrid_condition_crossvalidation(growset, positive, param);
                            break;
   case MODEL_SELECTION_AIC:return find_best_hybrid_condition_aic(growset, positive, param);
                            break;
   case MODEL_SELECTION_BIC:return find_best_hybrid_condition_bic(growset, positive, param);
                            break;
   default                 :return find_best_hybrid_condition_crossvalidation(growset, positive, param);
                            break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x75657
jmp 0x75643
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x7566d
jmp 0x7564d
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x75683
jmp 0x75699
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x756c0
movq %rax, -0x8(%rbp)
jmp 0x756ad
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x75200
movq %rax, -0x8(%rbp)
jmp 0x756ad
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x75410
movq %rax, -0x8(%rbp)
jmp 0x756ad
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x756c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/omnivariatetree.c
// Function: find_uni_and_multi_splits
void find_uni_and_multi_splits(Decisionnodeptr node, matrix* qw, double* qw0, double points[3], double variance_explained, int hybridspace)
{
 /*!Last Changed 22.11.2004*/
 node->featureno = find_best_ldt_feature_for_realized(node->instances, &(node->split));
 points[0] = node->featureno;
 node->lineard = find_best_multi_ldt_split(&(node->instances), &(node->w), &(node->w0), MULTIVARIATE_LINEAR, variance_explained);
 points[1] = node->lineard - 1;
 if (points[1] == -1)
   matrix_free(node->w);
 points[2] = -1;
 if (hybridspace == 3)
  {
   node->quadraticd = find_best_multi_ldt_split(&(node->instances), qw, qw0, MULTIVARIATE_QUADRATIC, variance_explained);
   points[2] = node->quadraticd - 1;
   if (points[2] == -1)
     matrix_free(*qw);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
callq 0xdec70
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
cvtsi2sdl 0x30(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x8(%rbp), %rsi
addq $0x38, %rsi
movq -0x8(%rbp), %rdx
addq $0x48, %rdx
movsd -0x28(%rbp), %xmm0
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x6fd20
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x90(%rax)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x6beca(%rip), %xmm1    # 0xe2a48
ucomisd %xmm1, %xmm0
jne 0x76b97
jp 0x76b97
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x59ea0
movq -0x20(%rbp), %rax
movsd 0x6bea5(%rip), %xmm0    # 0xe2a48
movsd %xmm0, 0x10(%rax)
cmpl $0x3, -0x2c(%rbp)
jne 0x76c1e
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movsd -0x28(%rbp), %xmm0
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
callq 0x6fd20
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x94(%rax)
movq -0x8(%rbp), %rax
movl 0x94(%rax), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd 0x6be44(%rip), %xmm1    # 0xe2a48
ucomisd %xmm1, %xmm0
jne 0x76c1c
jp 0x76c1c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x59ea0
jmp 0x76c1e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)