LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: scaletractions
void scaletractions(mesh theMesh)
{ restraint tr; 
  tr = (restraint)restraint_dll(theMesh->mesh_t,START,0);
  while (tr!=(restraint)NULL)
  { tr->f1=tr->f1/theMesh->T_SCALE;
    tr->f2=tr->f2/theMesh->T_SCALE;
    tr->f3=tr->f3/theMesh->T_SCALE;
    tr=tr->NEXT;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcee9
testq %rax, %rax
je 0x9d3e
movsd 0x40(%rbx), %xmm0
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movupd 0x18(%rax), %xmm2
divpd %xmm1, %xmm2
movupd %xmm2, 0x18(%rax)
movsd 0x28(%rax), %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, 0x28(%rax)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x9d19
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: scaletractionsback
void scaletractionsback(mesh theMesh)
{ point q;
  q = (point)point_dll(theMesh->mesh_p,START,0);
  while (q!=(point)NULL)
  { q->fx=q->fx*theMesh->T_SCALE;
    q->fy=q->fy*theMesh->T_SCALE;
    q->fz=q->fz*theMesh->T_SCALE;
    q=q->NEXT;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcc2f
testq %rax, %rax
je 0x9d87
movsd 0x40(%rbx), %xmm0
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movupd 0x38(%rax), %xmm2
mulpd %xmm1, %xmm2
movupd %xmm2, 0x38(%rax)
movsd 0x48(%rax), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, 0x48(%rax)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x9d62
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: determineEscale
void determineEscale(mesh theMesh)
{ /* find the smallest distance between two nodes: */
  double mindist=1.0E6;
  double curdist;
  element e;

  e = (element)element_dll(theMesh->mesh_e,START,0);
  while (e!=(element)NULL)
  { curdist = e->z1; if (curdist<mindist) mindist=curdist;
    curdist = e->z2; if (curdist<mindist) mindist=curdist;
    curdist = e->z3; if (curdist<mindist) mindist=curdist;
	e=e->NEXT;
  }
  theMesh->E_SCALE=mindist;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb570
movsd 0x50b6(%rip), %xmm0     # 0xee58
testq %rax, %rax
je 0x9dd1
movsd 0x88(%rax), %xmm1
minsd %xmm0, %xmm1
movsd 0x90(%rax), %xmm2
minsd %xmm1, %xmm2
movsd 0x98(%rax), %xmm0
minsd %xmm2, %xmm0
movq 0x8(%rax), %rax
jmp 0x9da2
movsd %xmm0, 0x48(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/linearc.c
// Function: tijdbalkje
void tijdbalkje(int deKnoop)
{ /* deze functie tekent een nifty tijdbalkje om te kunnen zien of de
   * de software nog ergens mee bezig is...
   */
   float fraction;
   int pos, pos2;

   if (deKnoop==0) /* teken het tijdbalkje */
   { /* lengte van de lijn is 65 */
   fprintf(stderr,"\n* Building system of equations...\n");
fprintf(stderr,"=================================================================\n");
	 curpos = 0;
   }
   else if (deKnoop==-1) /* maak het tijdbalkje af */
		{
fprintf(stderr,"\n=================================================================\n\n");
		}
		else /* teken het percentage */
		{ fraction = (float)((float)deKnoop/(float)n_nodes);
		  pos = (int)(fraction*(float)65.0);
		  if (pos>curpos) {
			pos2 = 0;
			while (pos2<pos)
			  { fprintf(stderr,">");
				pos2++;
              }
			  fprintf(stderr,"\r");
			}
            curpos=pos;
		}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $-0x1, %edi
je 0x9e69
testl %edi, %edi
je 0x9e62
cvtsi2ss %edi, %xmm0
cvtsi2ssl 0xba8b(%rip), %xmm1 # 0x15898
divss %xmm1, %xmm0
mulss 0x41eb(%rip), %xmm0     # 0xe004
cvttss2si %xmm0, %ebx
cmpl %ebx, 0xba85(%rip)      # 0x158a8
jge 0x9e57
testl %ebx, %ebx
jle 0x9e43
movq 0xb1c8(%rip), %r14      # 0x14ff8
movl %ebx, %ebp
movq (%r14), %rsi
movl $0x3e, %edi
callq 0x10e0
decl %ebp
jne 0x9e32
movq 0xb1ae(%rip), %rax      # 0x14ff8
movq (%rax), %rsi
movl $0xd, %edi
callq 0x10e0
movl %ebx, 0xba4b(%rip)      # 0x158a8
popq %rbx
popq %r14
popq %rbp
retq
callq 0x33b7
jmp 0x9e5d
callq 0x339b
jmp 0x9e5d
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/linearc.c
// Function: init_integration_matrices
void init_integration_matrices(void)
{ int i;
  temp = (matrix)newmatrix(3,3);
  /* matrices for intermediate gauss integration values: */
  tf=(matrix *)mymalloc(8*sizeof(matrix));
  if (tf==(matrix *)NULL) evaluate_level(RED,108);
  uf=(matrix *)mymalloc(8*sizeof(matrix));
  if (uf==(matrix *)NULL) evaluate_level(RED,108);
  for (i=0; i<=7; i++) 
  { tf[i]=(matrix)newmatrix(3,3);
    uf[i]=(matrix)newmatrix(3,3);
  }
}

// Assembly:
pushq %rbx
movl $0x3, %edi
movl $0x3, %esi
callq 0xb9e0
movq %rax, 0xba29(%rip)      # 0x158b0
movl $0x40, %edi
callq 0xcb90
movq %rax, 0xba20(%rip)      # 0x158b8
testq %rax, %rax
jne 0x9eac
movl $0x2, %edi
movl $0x6c, %esi
callq 0xb980
movl $0x40, %edi
callq 0xcb90
movq %rax, 0xba03(%rip)      # 0x158c0
testq %rax, %rax
jne 0x9ed1
movl $0x2, %edi
movl $0x6c, %esi
callq 0xb980
xorl %ebx, %ebx
movl $0x3, %edi
movl $0x3, %esi
callq 0xb9e0
movq 0xb9cf(%rip), %rcx      # 0x158b8
movq %rax, (%rcx,%rbx,8)
movl $0x3, %edi
movl $0x3, %esi
callq 0xb9e0
movq 0xb9bd(%rip), %rcx      # 0x158c0
movq %rax, (%rcx,%rbx,8)
incq %rbx
cmpq $0x8, %rbx
jne 0x9ed3
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/linearc.c
// Function: init_linear
void init_linear(void)
{ 
  evaluate_level(GREEN,100);
  if (READ_SOLUTION==NO)
  { main_E=(matrix)newmatrix(3*n_nodes,3*n_nodes);
  }
  else main_E=(matrix)newmatrix(3,3);
  fillmatrix(main_E,ZEROFILL); 
  main_f=(vector)newvector(3*n_nodes);
  main_u=(vector)newvector(3*n_nodes);
  init_integration_matrices();
}

// Assembly:
pushq %rax
xorl %edi, %edi
movl $0x64, %esi
callq 0xb980
leaq 0xb50e(%rip), %rax      # 0x15434
cmpl $0x0, (%rax)
je 0x9f37
movl $0x3, %edi
movl $0x3, %esi
jmp 0x9f42
movl 0xb95b(%rip), %eax      # 0x15898
leal (%rax,%rax,2), %edi
movl %edi, %esi
callq 0xb9e0
leaq 0xb4f2(%rip), %rcx      # 0x15440
movq %rax, (%rcx)
movq %rax, %rdi
xorl %esi, %esi
callq 0xbc43
movl 0xb937(%rip), %eax      # 0x15898
leal (%rax,%rax,2), %edi
callq 0xbb17
leaq 0xb4d8(%rip), %rcx      # 0x15448
movq %rax, (%rcx)
movl 0xb91f(%rip), %eax      # 0x15898
leal (%rax,%rax,2), %edi
callq 0xbb17
leaq 0xb4c8(%rip), %rcx      # 0x15450
movq %rax, (%rcx)
popq %rax
jmp 0x9e70
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/linearc.c
// Function: close_linear
void close_linear(void)
{ int i;
  evaluate_level(GREEN,101); 
  delmatrix(temp);

  for (i=0; i<=7; i++) 
  { delmatrix(tf[i]);
	delmatrix(uf[i]);
  }
  myfree(tf);
  myfree(uf);
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
xorl %edi, %edi
movl $0x65, %esi
callq 0xb980
movq 0xb909(%rip), %rdi      # 0x158b0
callq 0xbb7b
movq 0xb905(%rip), %rax      # 0x158b8
movq (%rax,%rbx,8), %rdi
callq 0xbb7b
movq 0xb8fd(%rip), %rax      # 0x158c0
movq (%rax,%rbx,8), %rdi
callq 0xbb7b
incq %rbx
cmpq $0x8, %rbx
jne 0x9fac
movq 0xb8dc(%rip), %rdi      # 0x158b8
callq 0xcbb0
movq 0xb8d8(%rip), %rdi      # 0x158c0
popq %rbx
jmp 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/linearc.c
// Function: init_normal_integration
void init_normal_integration( point sn, element e )
{ /* IN:          sourcenode 'sn', element e;
   * OUT:         nothing
   * MODIFIES:    the matrix arrays tf[] and uf[]
   * USES:        fsol3d module
   * DESCRIPTION: This function fills the matrix arrays uf[] and tf[] with
   *              the fundamental solutions in the gauss points. This is 
   *              done once for each element.
   */
int i;            /* counter */
double cx, cy, cz;  /* fieldpoint coordinates */

   for (i=1; i<=7; i++)
   { cx = xi1[i]*e->p1x + xi2[i]*e->p2x + xi3[i]*e->p3x;
     cy = xi1[i]*e->p1y + xi2[i]*e->p2y + xi3[i]*e->p3y;
     cz = xi1[i]*e->p1z + xi2[i]*e->p2z + xi3[i]*e->p3z;
     makeUFandTF(uf[i],tf[i],sn->x,sn->y,sn->z,cx,cy,cz,e->nx,e->ny,e->nz);
   }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0xb224(%rip), %r12      # 0x15300
leaq 0xb25d(%rip), %r13      # 0x15340
leaq 0xb296(%rip), %rbp      # 0x15380
movsd 0x8(%r15,%r12), %xmm0
movsd 0x8(%r15,%r13), %xmm1
movsd 0x40(%rbx), %xmm2
mulsd %xmm1, %xmm2
movsd 0x28(%rbx), %xmm4
mulsd %xmm0, %xmm4
addsd %xmm2, %xmm4
movsd 0x8(%r15,%rbp), %xmm5
movsd 0x58(%rbx), %xmm3
mulsd %xmm5, %xmm3
addsd %xmm4, %xmm3
movsd 0x48(%rbx), %xmm2
mulsd %xmm1, %xmm2
movsd 0x30(%rbx), %xmm6
mulsd %xmm0, %xmm6
addsd %xmm2, %xmm6
movsd 0x60(%rbx), %xmm4
mulsd %xmm5, %xmm4
addsd %xmm6, %xmm4
mulsd 0x50(%rbx), %xmm1
mulsd 0x38(%rbx), %xmm0
mulsd 0x68(%rbx), %xmm5
addsd %xmm1, %xmm0
addsd %xmm0, %xmm5
movq 0xb75d(%rip), %rax      # 0x158c0
movq 0x8(%rax,%r15), %rdi
movq 0xb749(%rip), %rax      # 0x158b8
movq 0x8(%rax,%r15), %rsi
movsd 0x20(%r14), %xmm0
movsd 0x28(%r14), %xmm1
movsd 0x30(%r14), %xmm2
movsd 0xa0(%rbx), %xmm6
movsd 0xa8(%rbx), %xmm7
movsd 0xb0(%rbx), %xmm8
movsd %xmm8, (%rsp)
callq 0xb2c4
addq $0x8, %r15
cmpq $0x38, %r15
jne 0xa0ea
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/linearc.c
// Function: make_row
void make_row(point sourcenode, hypermatrix crow, hypermatrix erow,
                                hypermatrix c,    hypermatrix e, mesh theMesh)
{ element fieldelement;
  int i;

  fillhypermatrix(crow,ZEROFILL);
  fillhypermatrix(erow,ZEROFILL);

  fieldelement=(element)element_dll(theMesh->mesh_e,START,0);
  while (fieldelement!=(element)NULL)
  { collocate(sourcenode,fieldelement,c,e);
    
    matsum3x3(crow->data[fieldelement->p1],c->data[1]);
    matsum3x3(erow->data[fieldelement->p1],e->data[1]);

    matsum3x3(crow->data[fieldelement->p2],c->data[2]);
    matsum3x3(erow->data[fieldelement->p2],e->data[2]);

    matsum3x3(crow->data[fieldelement->p3],c->data[3]);
    matsum3x3(erow->data[fieldelement->p3],e->data[3]);

    fieldelement=fieldelement->NEXT;
  }

  /* complete the diagonal term: */
  fillmatrix(erow->data[sourcenode->label],ZEROFILL);
  for (i=1; i<=n_nodes; i++)
  { if (i!=sourcenode->label)
    { matsum3x3(erow->data[sourcenode->label],erow->data[i]);
    }  
  }
  scalemat3x3(erow->data[sourcenode->label],-1.0);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
xorl %esi, %esi
callq 0xbe66
movq %rbx, %rdi
xorl %esi, %esi
callq 0xbe66
movq 0x8(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb570
testq %rax, %rax
je 0xa567
movq %rax, %rbp
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0xa40a
movq 0x8(%r13), %rax
movslq 0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r12), %rax
movq 0x8(%rax), %rsi
callq 0xc355
movq 0x8(%rbx), %rax
movslq 0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r15), %rax
movq 0x8(%rax), %rsi
callq 0xc355
movq 0x8(%r13), %rax
movslq 0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r12), %rax
movq 0x10(%rax), %rsi
callq 0xc355
movq 0x8(%rbx), %rax
movslq 0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r15), %rax
movq 0x10(%rax), %rsi
callq 0xc355
movq 0x8(%r13), %rax
movslq 0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r12), %rax
movq 0x18(%rax), %rsi
callq 0xc355
movq 0x8(%rbx), %rax
movslq 0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r15), %rax
movq 0x18(%rax), %rsi
callq 0xc355
movq 0x8(%rbp), %rbp
testq %rbp, %rbp
jne 0xa4b0
movq 0x8(%rbx), %rax
movslq 0x10(%r14), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0xbc43
movl 0xb318(%rip), %eax      # 0x15898
testl %eax, %eax
jle 0xa5bc
movl $0x1, %r15d
movl 0x10(%r14), %ecx
cmpq %rcx, %r15
je 0xa5ad
movslq %ecx, %rax
movq 0x8(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rcx,%r15,8), %rsi
callq 0xc355
movl 0xb2eb(%rip), %eax      # 0x15898
leaq 0x1(%r15), %rcx
movslq %eax, %rdx
cmpq %rdx, %r15
movq %rcx, %r15
jl 0xa58a
movq 0x8(%rbx), %rax
movslq 0x10(%r14), %rcx
movq (%rax,%rcx,8), %rdi
movsd 0x4a30(%rip), %xmm0     # 0xf000
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc288
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/linearc.c
// Function: make_rhs_vector
void make_rhs_vector(mesh theMesh)
{ restraint r;

  fillvector(main_u,ZEROFILL);
  fillvector(main_f,ZEROFILL);

  r=(restraint)restraint_dll(theMesh->mesh_t,START,0);
  while (r!=(restraint)NULL)
  { V(main_u,r->label*3-2)=r->f1;
    V(main_u,r->label*3-1)=r->f2;
    V(main_u,r->label*3  )=r->f3;
    r=r->NEXT;
  }
  r=(restraint)restraint_dll(theMesh->mesh_d,START,0);
  while (r!=(restraint)NULL)
  { V(main_u,r->label*3-2)=r->u1;
    V(main_u,r->label*3-1)=r->u2;
    V(main_u,r->label*3  )=r->u3;
    r=r->NEXT;
  }

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xac9f(%rip), %r14      # 0x15450
movq (%r14), %rdi
xorl %esi, %esi
callq 0xc023
leaq 0xac86(%rip), %rax      # 0x15448
movq (%rax), %rdi
xorl %esi, %esi
callq 0xc023
movq 0x18(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcee9
testq %rax, %rax
je 0xa817
movq (%r14), %rcx
movq 0x8(%rcx), %rcx
movsd 0x18(%rax), %xmm0
movslq 0x14(%rax), %rdx
leaq (%rdx,%rdx,2), %rdx
movsd %xmm0, -0x18(%rcx,%rdx,8)
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x10(%rcx,%rdx,8)
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x8(%rcx,%rdx,8)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0xa7e5
movq 0x10(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcee9
testq %rax, %rax
je 0xa862
movq (%r14), %rcx
movq 0x8(%rcx), %rcx
movsd 0x30(%rax), %xmm0
movslq 0x14(%rax), %rdx
leaq (%rdx,%rdx,2), %rdx
movsd %xmm0, -0x18(%rcx,%rdx,8)
movsd 0x38(%rax), %xmm0
movsd %xmm0, -0x10(%rcx,%rdx,8)
movsd 0x40(%rax), %xmm0
movsd %xmm0, -0x8(%rcx,%rdx,8)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0xa830
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/mcheck.c
// Function: make_restraints
void make_restraints(mesh theMesh)
{ point p;
  restraint r;

  /* search through all points and create a new displacement restraint for each point: */
  p=(point)point_dll(theMesh->mesh_p,START,0); 
  while (p!=(point)NULL)
  { r=(restraint)restraint_dll(theMesh->mesh_d,APPEND,0);
    r->label=p->label; 
    r->type =DISPLACEMENT;
    
    r->u1=10.0/EMOD*( 0.5*p->x*p->x - NU*p->x*p->y + 0.5*(2.0+3.0*NU)*p->y*p->y
                    -0.5*(4.0+3.0*NU)*p->z*p->z );
    r->u2=10.0/EMOD*( 0.5*NU*p->x*p->x - NU*p->x*p->y + 0.5*p->y*p->y
                    -0.5*(2.0+NU)*p->z*p->z );
    r->u3=-10.0/EMOD*( NU*(p->x+p->y)*p->z );

    p=p->NEXT;
  } 
  

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcc2f
testq %rax, %rax
je 0xaa9e
movq %rax, %r14
leaq 0xaaa2(%rip), %r15      # 0x15408
leaq 0xaaa3(%rip), %r12      # 0x15410
movq 0x10(%rbx), %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0xcee9
movl 0x10(%r14), %ecx
movl %ecx, 0x14(%rax)
movl $0x1, 0x10(%rax)
movsd (%r12), %xmm3
movsd 0x20(%r14), %xmm0
movsd 0x28(%r14), %xmm1
movapd %xmm3, %xmm2
xorpd 0x3677(%rip), %xmm2     # 0xe020
mulsd %xmm0, %xmm2
movapd %xmm3, %xmm4
movapd %xmm3, %xmm5
movapd %xmm0, %xmm6
addsd %xmm1, %xmm0
mulsd %xmm3, %xmm0
mulsd 0x3a8f(%rip), %xmm3     # 0xe458
movsd 0x3a8e(%rip), %xmm9     # 0xe460
mulsd %xmm9, %xmm4
movapd 0x48f1(%rip), %xmm7     # 0xf2d0
unpcklpd %xmm4, %xmm7            # xmm7 = xmm7[0],xmm4[0]
movapd %xmm3, %xmm4
addsd 0x3a89(%rip), %xmm3     # 0xe478
movsd 0x48c8(%rip), %xmm8     # 0xf2c0
addsd %xmm8, %xmm5
unpcklpd %xmm5, %xmm3            # xmm3 = xmm3[0],xmm5[0]
unpcklpd %xmm6, %xmm6            # xmm6 = xmm6[0,0]
mulpd %xmm6, %xmm7
mulpd %xmm6, %xmm7
mulsd %xmm1, %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
addpd %xmm2, %xmm7
addsd %xmm8, %xmm4
mulsd %xmm9, %xmm4
shufpd $0x2, 0x48b4(%rip), %xmm4 # xmm4 = xmm4[0],mem[1]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm1, %xmm4
mulpd %xmm1, %xmm4
addpd %xmm7, %xmm4
movsd 0x30(%r14), %xmm1
mulpd 0x48a6(%rip), %xmm3     # 0xf2f0
mulsd %xmm1, %xmm0
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm1, %xmm3
mulpd %xmm1, %xmm3
movsd (%r15), %xmm1
addpd %xmm4, %xmm3
movsd 0x484d(%rip), %xmm2     # 0xf2b8
divsd %xmm1, %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm3, %xmm2
movupd %xmm2, 0x30(%rax)
movsd 0x4844(%rip), %xmm2     # 0xf2c8
divsd %xmm1, %xmm2
mulsd %xmm2, %xmm0
movsd %xmm0, 0x40(%rax)
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xa96d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/elements.c
// Function: newelement
element newelement( void )
{ element e;
  if ( (e=(element)mymalloc(sizeof(elementtype))) == (element)NULL )
    evaluate_level(RED,70);
  e->PREV=(element)NULL; e->NEXT=(element)NULL; e->label=0;
  e->type=NONE;
  e->p1= -1; e->p2= -1; e->p3= -1;
  return e;
}

// Assembly:
pushq %rbx
movl $0xc0, %edi
callq 0xcb90
movq %rax, %rbx
testq %rax, %rax
jne 0xb54e
movl $0x2, %edi
movl $0x46, %esi
callq 0xb980
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movaps 0x4015(%rip), %xmm0     # 0xf570
movups %xmm0, 0x10(%rbx)
movl $0xffffffff, 0x20(%rbx) # imm = 0xFFFFFFFF
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/imatrices.c
// Function: newimatrix
intmatrix newimatrix(int rows,int cols)
{   intmatrix m;
	static int i;

	if ( (m=(intmatrix)mymalloc(sizeof(intmatrixtype))) == (intmatrix)NULL )
	  evaluate_level(RED,21);

	m->rows = rows;
	m->cols = cols;

	if ( (m->matrix = (int **)mymalloc((unsigned int)(m->rows) * (int)sizeof(int *))) 
		== (int **)NULL)
	   evaluate_level(RED,22);
	else { for (i = 0; i < m->rows; i++)
			{ if((m->matrix[i] = (int *)mymalloc((unsigned int)(m->cols) * (int)sizeof(int))) == (int *)NULL)
				{ evaluate_level(RED,22);
				 break;
				}
			}
		 }
	m->allocated=ALLOCATED;
	allocated_matrices++;
	return m;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movl %edi, %r14d
movl $0x18, %edi
callq 0xcb90
movq %rax, %rbx
testq %rax, %rax
jne 0xb6ea
movl $0x2, %edi
movl $0x15, %esi
callq 0xb980
movl %r14d, (%rbx)
movl %ebp, 0x4(%rbx)
shll $0x3, %r14d
movq %r14, %rdi
callq 0xcb90
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xb741
movl $0x0, 0xa1b9(%rip)      # 0x158c8
cmpl $0x0, (%rbx)
jle 0xb750
movl 0x4(%rbx), %edi
shll $0x2, %edi
callq 0xcb90
movq 0x8(%rbx), %rdx
movslq 0xa19e(%rip), %rcx      # 0x158c8
movq %rax, (%rdx,%rcx,8)
testq %rax, %rax
je 0xb741
incl %ecx
movl %ecx, 0xa18d(%rip)      # 0x158c8
cmpl (%rbx), %ecx
jl 0xb714
jmp 0xb750
movl $0x2, %edi
movl $0x16, %esi
callq 0xb980
movl $0x1, 0x10(%rbx)
leaq 0x9cba(%rip), %rax      # 0x15418
incl (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/imatrices.c
// Function: newlimatrix
lintmatrix newlimatrix(int rows,int cols)
{   lintmatrix m;
        static int i;

        if ( (m=(lintmatrix)mymalloc(sizeof(lintmatrixtype))) == (lintmatrix)NULL )
          evaluate_level(RED,21);

        m->rows = rows;
        m->cols = cols;

        if ( (m->matrix = (long int **)mymalloc((unsigned int)(m->rows) * (int)sizeof(long int *)))
                == (long int **)NULL)
           evaluate_level(RED,22);
        else { for (i = 0; i < m->rows; i++)
                        { if((m->matrix[i] = (long int *)mymalloc((unsigned int)(m->cols) * (int)sizeof(long int))) == (long int *)NULL)
                                { evaluate_level(RED,22);
                                 break;
                                }
                        }
                 }
        m->allocated=ALLOCATED;
        allocated_matrices++;
        return m;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movl %edi, %r14d
movl $0x18, %edi
callq 0xcb90
movq %rax, %rbx
testq %rax, %rax
jne 0xb792
movl $0x2, %edi
movl $0x15, %esi
callq 0xb980
movl %r14d, (%rbx)
movl %ebp, 0x4(%rbx)
shll $0x3, %r14d
movq %r14, %rdi
callq 0xcb90
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xb7e9
movl $0x0, 0xa115(%rip)      # 0x158cc
cmpl $0x0, (%rbx)
jle 0xb7f8
movl 0x4(%rbx), %edi
shll $0x3, %edi
callq 0xcb90
movq 0x8(%rbx), %rdx
movslq 0xa0fa(%rip), %rcx      # 0x158cc
movq %rax, (%rdx,%rcx,8)
testq %rax, %rax
je 0xb7e9
incl %ecx
movl %ecx, 0xa0e9(%rip)      # 0x158cc
cmpl (%rbx), %ecx
jl 0xb7bc
jmp 0xb7f8
movl $0x2, %edi
movl $0x16, %esi
callq 0xb980
movl $0x1, 0x10(%rbx)
leaq 0x9c12(%rip), %rax      # 0x15418
incl (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/imatrices.c
// Function: newivector
intvector newivector(int rows )
{ intvector v;
  if ( (v=(intvector)mymalloc(sizeof(intvectortype))) == (intvector)NULL )
	evaluate_level(RED,23);
  v->rows = rows;
  if ( (v->data=(int *)mymalloc((unsigned int)((int)sizeof(int)*(rows+1)))) == (int *)NULL )
	evaluate_level(RED,24);
  allocated_vectors++;
  return v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
movl $0x10, %edi
callq 0xcb90
movq %rax, %rbx
testq %rax, %rax
jne 0xb838
movl $0x2, %edi
movl $0x17, %esi
callq 0xb980
movl %r14d, (%rbx)
leal 0x4(,%r14,4), %edi
callq 0xcb90
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0xb860
movl $0x2, %edi
movl $0x18, %esi
callq 0xb980
leaq 0x9bb9(%rip), %rax      # 0x15420
incl (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/imatrices.c
// Function: delimatrix
void delimatrix(intmatrix m)
{	static int rowcnt;

	if (m->allocated!=ALLOCATED) printf("delmatrix(): matrix not allocated.\n");
	for (rowcnt = 0; rowcnt<(m->rows); rowcnt++)
	{ myfree(m->matrix[rowcnt]);
	}
	myfree(m->matrix);
	myfree(m);
	freed_matrices++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, 0x10(%rdi)
je 0xb88a
leaq 0x3d17(%rip), %rdi      # 0xf59c
callq 0x1060
movl $0x0, 0xa03c(%rip)      # 0x158d0
cmpl $0x0, (%rbx)
jle 0xb8bc
xorl %eax, %eax
movq 0x8(%rbx), %rcx
cltq
movq (%rcx,%rax,8), %rdi
callq 0xcbb0
movl 0xa020(%rip), %eax      # 0x158d0
incl %eax
movl %eax, 0xa018(%rip)      # 0x158d0
cmpl (%rbx), %eax
jl 0xb89b
movq 0x8(%rbx), %rdi
callq 0xcbb0
movq %rbx, %rdi
callq 0xcbb0
leaq 0x9b48(%rip), %rax      # 0x1541c
incl (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/imatrices.c
// Function: dellimatrix
void dellimatrix(lintmatrix m)
{       static int rowcnt;

        if (m->allocated!=ALLOCATED) printf("delmatrix(): matrix not allocated.\n");
        for (rowcnt = 0; rowcnt<(m->rows); rowcnt++)
        { myfree(m->matrix[rowcnt]);
        }
        myfree(m->matrix);
        myfree(m);
        freed_matrices++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, 0x10(%rdi)
je 0xb8ee
leaq 0x3cb3(%rip), %rdi      # 0xf59c
callq 0x1060
movl $0x0, 0x9fdc(%rip)      # 0x158d4
cmpl $0x0, (%rbx)
jle 0xb920
xorl %eax, %eax
movq 0x8(%rbx), %rcx
cltq
movq (%rcx,%rax,8), %rdi
callq 0xcbb0
movl 0x9fc0(%rip), %eax      # 0x158d4
incl %eax
movl %eax, 0x9fb8(%rip)      # 0x158d4
cmpl (%rbx), %eax
jl 0xb8ff
movq 0x8(%rbx), %rdi
callq 0xcbb0
movq %rbx, %rdi
callq 0xcbb0
leaq 0x9ae4(%rip), %rax      # 0x1541c
incl (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: newmatrix
matrix newmatrix(int rows,int cols)
{   matrix m;
	static int i;

	if ( (m=(matrix)mymalloc(sizeof(matrixtype))) == (matrix)NULL )
	  evaluate_level(RED,21);

	m->rows = rows;
	m->cols = cols;

	if ( (m->matrix = (double **)mymalloc((unsigned int)(m->rows) * (int)sizeof(double *))) 
		== (double **)NULL)
	   evaluate_level(RED,22);
	else { for (i = 0; i < m->rows; i++)
			{ if((m->matrix[i] = (double *)mymalloc((unsigned int)(m->cols) * (int)sizeof(double))) == (double *)NULL)
				{ evaluate_level(RED,22);
				 break;
				}
			}
		 }
	/* fillmatrix(m,ZEROFILL); */
	m->allocated=ALLOCATED;
	allocated_matrices++;
	return m;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movl %edi, %r14d
movl $0x18, %edi
callq 0xcb90
movq %rax, %rbx
testq %rax, %rax
jne 0xba0a
movl $0x2, %edi
movl $0x15, %esi
callq 0xb980
movl %r14d, (%rbx)
movl %ebp, 0x4(%rbx)
shll $0x3, %r14d
movq %r14, %rdi
callq 0xcb90
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xba61
movl $0x0, 0x9eb9(%rip)      # 0x158e8
cmpl $0x0, (%rbx)
jle 0xba70
movl 0x4(%rbx), %edi
shll $0x3, %edi
callq 0xcb90
movq 0x8(%rbx), %rdx
movslq 0x9e9e(%rip), %rcx      # 0x158e8
movq %rax, (%rdx,%rcx,8)
testq %rax, %rax
je 0xba61
incl %ecx
movl %ecx, 0x9e8d(%rip)      # 0x158e8
cmpl (%rbx), %ecx
jl 0xba34
jmp 0xba70
movl $0x2, %edi
movl $0x16, %esi
callq 0xb980
movl $0x1, 0x10(%rbx)
leaq 0x999a(%rip), %rax      # 0x15418
incl (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: newhypermatrix
hypermatrix newhypermatrix(int rows, int cols, int dimension )
{ hypermatrix hm;
  int i;
  if ( ( hm=(hypermatrix)mymalloc(sizeof(hypermatrixtype)) )==NULL )
	evaluate_level(RED,25);
  hm->dimension=dimension;
  if ( ( hm->data=(matrix *)mymalloc((unsigned int)((int)sizeof(matrix)*(dimension+1))) )==NULL )
	evaluate_level(RED,26);
  for (i=0; i<=(hm->dimension); i++) 
	  hm->data[i]=(matrix)newmatrix(rows,cols);
	return hm;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %ebx
movl %edi, %ebp
movl $0x10, %edi
callq 0xcb90
movq %rax, %r14
testq %rax, %rax
jne 0xbab7
movl $0x2, %edi
movl $0x19, %esi
callq 0xb980
movl %r15d, (%r14)
leal 0x8(,%r15,8), %edi
callq 0xcb90
movq %rax, 0x8(%r14)
testq %rax, %rax
jne 0xbadf
movl $0x2, %edi
movl $0x1a, %esi
callq 0xb980
cmpl $0x0, (%r14)
js 0xbb09
movq $-0x1, %r15
movl %ebp, %edi
movl %ebx, %esi
callq 0xb9e0
movq 0x8(%r14), %rcx
movq %rax, 0x8(%rcx,%r15,8)
movslq (%r14), %rax
incq %r15
cmpq %rax, %r15
jl 0xbaec
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: newvector
vector newvector(int rows )
{ vector v;
  if ( (v=(vector)mymalloc(sizeof(vectortype))) == (vector)NULL )
	evaluate_level(RED,23);
  v->rows = rows;
  if ( (v->data=(double *)mymalloc((unsigned int)((int)sizeof(double)*(rows+1)))) == (double *)NULL )
	evaluate_level(RED,24);
  allocated_vectors++;
  return v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
movl $0x10, %edi
callq 0xcb90
movq %rax, %rbx
testq %rax, %rax
jne 0xbb3f
movl $0x2, %edi
movl $0x17, %esi
callq 0xb980
movl %r14d, (%rbx)
leal 0x8(,%r14,8), %edi
callq 0xcb90
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0xbb67
movl $0x2, %edi
movl $0x18, %esi
callq 0xb980
leaq 0x98b2(%rip), %rax      # 0x15420
incl (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: delhypermatrix
void delhypermatrix(hypermatrix hm )
{ int i;
  /* printf("deleting hypermatrix...\n"); */
  for (i=0; i<=(hm->dimension); i++) 
	  delmatrix(hm->data[i]);
  myfree( hm->data ); 
  myfree( hm );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
js 0xbc0b
movq $-0x1, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r14,8), %rdi
callq 0xbb7b
movslq (%rbx), %rax
incq %r14
cmpq %rax, %r14
jl 0xbbf2
movq 0x8(%rbx), %rdi
callq 0xcbb0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: fillhypermatrix
void fillhypermatrix( hypermatrix hm, int method )
{ int i;
  switch(method)
  { case ZEROFILL: for (i=1; i<=hm->dimension; i++)
					   fillmatrix(hm->data[i],ZEROFILL); break;
    case ONEFILL:  for (i=1; i<=hm->dimension; i++)
					 fillmatrix(hm->data[i],ONEFILL); break;
    case DELTAFILL:for (i=1; i<=hm->dimension; i++)
					 fillmatrix(hm->data[i],DELTAFILL); break;
	default: break;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0xbfae
cmpl $0x1, %esi
je 0xbebc
cmpl $0x2, %esi
jne 0xc014
cmpl $0x0, (%rbx)
jle 0xc014
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r14,8), %rdi
movl $0x2, %esi
callq 0xbc43
movslq (%rbx), %rax
incq %r14
cmpq %rax, %r14
jl 0xbe99
jmp 0xc014
movl (%rbx), %eax
testl %eax, %eax
jle 0xc014
movq 0x8(%rbx), %rcx
incq %rax
movl $0x1, %edx
movdqa 0x4546(%rip), %xmm0     # 0x10420
movdqa 0x454e(%rip), %xmm1     # 0x10430
movabsq $0x3ff0000000000000, %rsi # imm = 0x3FF0000000000000
pcmpeqd %xmm2, %xmm2
movq (%rcx,%rdx,8), %rdi
movl (%rdi), %r8d
testl %r8d, %r8d
jle 0xbfa0
movl 0x4(%rdi), %r9d
leal 0x1(%r9), %r11d
incq %r8
movl %r11d, %r10d
andl $-0x2, %r10d
addq $-0x2, %r11
movq %r11, %xmm3
pshufd $0x44, %xmm3, %xmm3     # xmm3 = xmm3[0,1,0,1]
movl $0x1, %r11d
pxor %xmm1, %xmm3
testl %r9d, %r9d
jle 0xbf98
movq 0x8(%rdi), %rbx
movq -0x8(%rbx,%r11,8), %rbx
xorl %r14d, %r14d
movq %r14, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm0, %xmm4
pxor %xmm1, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm3, %xmm5
pcmpeqd %xmm3, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %ebp
notl %ebp
testb $0x1, %bpl
je 0xbf7b
movq %rsi, (%rbx,%r14,8)
pxor %xmm2, %xmm4
pextrw $0x4, %xmm4, %ebp
testb $0x1, %bpl
je 0xbf8f
movq %rsi, 0x8(%rbx,%r14,8)
addq $0x2, %r14
cmpq %r14, %r10
jne 0xbf3b
incq %r11
cmpq %r8, %r11
jne 0xbf2a
incq %rdx
cmpq %rax, %rdx
jne 0xbef0
jmp 0xc014
movl (%rbx), %eax
movq %rax, 0x8(%rsp)
testl %eax, %eax
jle 0xc014
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rsp)
incq 0x8(%rsp)
movl $0x1, %r12d
movq 0x10(%rsp), %rax
movq (%rax,%r12,8), %r13
movl (%r13), %ebp
testl %ebp, %ebp
jle 0xc00a
movl 0x4(%r13), %ebx
movq %rbx, %r15
shlq $0x3, %r15
xorl %r14d, %r14d
testl %ebx, %ebx
jle 0xc002
movq 0x8(%r13), %rax
movq (%rax,%r14,8), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x10a0
incq %r14
cmpq %r14, %rbp
jne 0xbfec
incq %r12
cmpq 0x8(%rsp), %r12
jne 0xbfcd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: fillvector
void fillvector( vector v, int method )
{ int i;
  switch(method)
  { case ZEROFILL:  for (i=1; i<=v->rows; i++)
		    V(v,i)=0.0;
		    break;
	case ONEFILL:   for (i=1; i<=v->rows; i++)
		    V(v,i)=1.0;
		            break;
    default:        break;
  }
}

// Assembly:
testl %esi, %esi
je 0xc0da
cmpl $0x1, %esi
jne 0xc0f1
movslq (%rdi), %rdx
testq %rdx, %rdx
jle 0xc0f1
movq 0x8(%rdi), %rax
leal 0x1(%rdx), %ecx
andl $-0x2, %ecx
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
xorl %edx, %edx
movdqa 0x43bf(%rip), %xmm1     # 0x10420
movdqa 0x43c7(%rip), %xmm2     # 0x10430
pxor %xmm2, %xmm0
movabsq $0x3ff0000000000000, %rsi # imm = 0x3FF0000000000000
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %edi
notl %edi
testb $0x1, %dil
je 0xc0bb
movq %rsi, (%rax,%rdx,8)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0xc0cf
movq %rsi, 0x8(%rax,%rdx,8)
addq $0x2, %rdx
cmpq %rdx, %rcx
jne 0xc07b
jmp 0xc0f1
movslq (%rdi), %rdx
testq %rdx, %rdx
jle 0xc0f1
movq 0x8(%rdi), %rdi
shlq $0x3, %rdx
xorl %esi, %esi
jmp 0x10a0
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: matmul
matrix matmul( matrix a, matrix b, matrix c )
/* matmul multiplies: A = B . C, returning A */
{ int c_count, b_count; int runner;
  fillmatrix(a,ZEROFILL);
  for (c_count=1; c_count<=c->cols; c_count++)
	for (b_count=1; b_count<=b->rows; b_count++)
      for (runner=1; runner<=b->cols; runner++)
	M(a,b_count,c_count) = M(a,b_count,c_count) +
	M(b,b_count,runner)*M(c,runner,c_count);
  return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %r13d
testl %r13d, %r13d
jle 0xc19e
movl 0x4(%r14), %ebp
movq %rbp, %rax
shlq $0x3, %rax
movq %rax, (%rsp)
xorl %r12d, %r12d
testl %ebp, %ebp
jle 0xc196
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rdi
xorl %esi, %esi
movq (%rsp), %rdx
callq 0x10a0
incq %r12
cmpq %r12, %r13
jne 0xc17f
movl 0x4(%rbx), %eax
testl %eax, %eax
jle 0xc21f
movl (%r15), %ecx
leal 0x1(%rcx), %edx
incq %rax
movl $0x1, %esi
testl %ecx, %ecx
jle 0xc217
movl 0x4(%r15), %edi
leal 0x1(%rdi), %r8d
decq %r8
movl $0x1, %r9d
testl %edi, %edi
jle 0xc20f
movq 0x8(%r14), %r10
movq -0x8(%r10,%r9,8), %r10
movq 0x8(%r15), %r11
movq -0x8(%r11,%r9,8), %r11
movq 0x8(%rbx), %r12
movsd -0x8(%r10,%rsi,8), %xmm0
xorl %r13d, %r13d
movsd (%r11,%r13,8), %xmm1
movq (%r12,%r13,8), %rbp
mulsd -0x8(%rbp,%rsi,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%r10,%rsi,8)
incq %r13
cmpq %r13, %r8
jne 0xc1ec
incq %r9
cmpq %rdx, %r9
jne 0xc1c8
incq %rsi
cmpq %rax, %rsi
jne 0xc1b3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: scalematgeneral
matrix  scalematgeneral( matrix a, double b, matrix c )
/* scalematgeneral scales: A = b . C, returning A */
{ int c_count, r_count;
  for (c_count=1; c_count<=c->cols; c_count++)
	for (r_count=1; r_count<=c->rows; r_count++)
	  M(a,r_count,c_count)=b * M(c,r_count,c_count);
  return a;
}

// Assembly:
movq %rdi, %rax
movl 0x4(%rsi), %ecx
testl %ecx, %ecx
jle 0xc287
pushq %rbx
movl (%rsi), %edx
leal 0x1(%rdx), %edi
incq %rcx
decq %rdi
movl $0x1, %r8d
testl %edx, %edx
jle 0xc27e
movq 0x8(%rsi), %r9
movq 0x8(%rax), %r10
xorl %r11d, %r11d
movq (%r9,%r11,8), %rbx
movsd -0x8(%rbx,%r8,8), %xmm1
mulsd %xmm0, %xmm1
movq (%r10,%r11,8), %rbx
movsd %xmm1, -0x8(%rbx,%r8,8)
incq %r11
cmpq %r11, %rdi
jne 0xc25c
incq %r8
cmpq %rcx, %r8
jne 0xc24d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: matsumgeneral
matrix matsumgeneral( matrix a, matrix b, matrix c )
/* matsum sums: A = B + C, returning A */
{ int c_count, b_count;
  for (c_count=1; c_count<=c->cols; c_count++)
	for (b_count=1; b_count<=b->rows; b_count++)
	  M(a,b_count,c_count)=M(b,b_count,c_count)+M(c,b_count,c_count);
  return a;
}

// Assembly:
movq %rdi, %rax
movl 0x4(%rdx), %ecx
testl %ecx, %ecx
jle 0xc354
pushq %r15
pushq %r14
pushq %rbx
movl (%rsi), %edi
leal 0x1(%rdi), %r8d
incq %rcx
decq %r8
movl $0x1, %r9d
testl %edi, %edi
jle 0xc347
movq 0x8(%rsi), %r10
movq 0x8(%rdx), %r11
movq 0x8(%rax), %rbx
xorl %r14d, %r14d
movq (%r10,%r14,8), %r15
movsd -0x8(%r15,%r9,8), %xmm0
movq (%r11,%r14,8), %r15
addsd -0x8(%r15,%r9,8), %xmm0
movq (%rbx,%r14,8), %r15
movsd %xmm0, -0x8(%r15,%r9,8)
incq %r14
cmpq %r14, %r8
jne 0xc31e
incq %r9
cmpq %rcx, %r9
jne 0xc30b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: matvecmul
void matvecmul(matrix A, vector F)
/* matvecmul multiplies matrix A with vector F, the result is put in F */
{ int rowrunner, colrunner;
  double tmpval;
  double tmp;
  vector tmpv;
  int rows;
  int cols;
  rows=F->rows;
  cols=A->cols;
  tmpv=(vector)newvector(F->rows);
  for (rowrunner=1; rowrunner<=rows; rowrunner++)
  { tmpval = (double)0.0;
	for (colrunner=1; colrunner<=cols; colrunner++)
	  { tmp=(double)M(A,rowrunner,colrunner)*(double)V(F,colrunner);
		tmpval=tmpval+tmp;
	  }
	V(tmpv,rowrunner)=tmpval;
  }    
  for (rows=1; rows<=F->rows; rows++)
  { V(F,rows) = V(tmpv,rows);
  }
  delvector(tmpv);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %r12d
movl 0x4(%rdi), %r13d
movl %r12d, %edi
callq 0xbb17
movq %rax, %rbx
testl %r12d, %r12d
jle 0xc4b8
movq 0x8(%rbx), %rax
leal 0x1(%r13), %ecx
incq %r12
decq %rcx
movl $0x1, %edx
testl %r13d, %r13d
jle 0xc4a6
movq 0x8(%r15), %rsi
movq -0x8(%rsi,%rdx,8), %rsi
movq 0x8(%r14), %rdi
xorpd %xmm0, %xmm0
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm1
mulsd (%rdi,%r8,8), %xmm1
addsd %xmm1, %xmm0
incq %r8
cmpq %r8, %rcx
jne 0xc48c
jmp 0xc4aa
xorpd %xmm0, %xmm0
movsd %xmm0, -0x8(%rax,%rdx,8)
incq %rdx
cmpq %r12, %rdx
jne 0xc473
movl (%r14), %eax
movq 0x8(%rbx), %rdi
testl %eax, %eax
jle 0xc4db
movq 0x8(%r14), %rcx
xorl %edx, %edx
movsd (%rdi,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xc4c9
callq 0xcbb0
movq %rbx, %rdi
callq 0xcbb0
leaq 0x8f35(%rip), %rax      # 0x15424
incl (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: printmatrix
void printmatrix(matrix m, char *text)
{  int i,j;
   printf("  Printmatrix: %s\n",text);
   for (i=1; i<=m->rows; i+=1)
   {
	 { for (j=1; j<=m->cols; j+=1)
	    printf(" % 8.8E",M(m,i,j)); 
	     /*if ( (fabs(M(m,i  ,j  ))>1.0E-20) ||
			  (fabs(M(m,i  ,j+1))>1.0E-20) ||
			  (fabs(M(m,i  ,j+2))>1.0E-20) ||
	          (fabs(M(m,i+1,j  ))>1.0E-20) ||
			  (fabs(M(m,i+1,j+1))>1.0E-20) ||
			  (fabs(M(m,i+1,j+2))>1.0E-20) ||
	          (fabs(M(m,i+2,j  ))>1.0E-20) ||
			  (fabs(M(m,i+2,j+1))>1.0E-20) ||
			  (fabs(M(m,i+2,j+2))>1.0E-20) 
		    ) printf("#"); else printf("0");  */
	 }
	 printf("\n");
   }
   text=text;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3f26(%rip), %rdi      # 0x10460
xorl %eax, %eax
callq 0x1090
cmpl $0x0, (%rbx)
jle 0xc59a
movl $0x1, %r15d
leaq 0x3f20(%rip), %r14      # 0x10473
cmpl $0x0, 0x4(%rbx)
jle 0xc581
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1090
movslq 0x4(%rbx), %rax
incq %r12
cmpq %rax, %r12
jl 0xc55c
movl $0xa, %edi
callq 0x1040
leaq 0x1(%r15), %rax
movslq (%rbx), %rcx
cmpq %rcx, %r15
movq %rax, %r15
jl 0xc553
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: printhypermatrix
void printhypermatrix(hypermatrix hm, char *text)
{ int i;
  printf("  printhypermatrix: %s\n",text);
  for (i=1; i<=hm->dimension; i++)
	{ printf("   dim: %d\n",i);
	  printmatrix(hm->data[i],"matrix");
    }
  text=text;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3ec3(%rip), %rdi      # 0x1047b
xorl %eax, %eax
callq 0x1090
cmpl $0x0, (%rbx)
jle 0xc604
movl $0x1, %r15d
leaq 0x3ec2(%rip), %r14      # 0x10493
leaq 0x1ae7(%rip), %r12      # 0xe0bf
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x1090
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r12, %rsi
callq 0xc528
leaq 0x1(%r15), %rax
movslq (%rbx), %rcx
cmpq %rcx, %r15
movq %rax, %r15
jl 0xc5d8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: printvector
void printvector(vector v, char *text)
{ int i;
  printf("  Printvector: %s\n",text);
  for (i=1; i<=v->rows; i++)
	printf(" %+8.8E\n",V(v,i));
  text=text;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3e80(%rip), %rdi      # 0x1049f
xorl %eax, %eax
callq 0x1090
cmpl $0x0, (%rbx)
jle 0xc654
xorl %r15d, %r15d
leaq 0x3e7d(%rip), %r14      # 0x104b2
movq 0x8(%rbx), %rax
movsd (%rax,%r15,8), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1090
movslq (%rbx), %rax
incq %r15
cmpq %rax, %r15
jl 0xc635
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/matrix.c
// Function: nn
void nn(int m, intvector nietnul,point po)
/* Zoekt de niet-nul kolommen op en slaat de index van deze kolommen
   op in de vector nietnul en een nul in het andere geval */
{
  int teller1,teller2;
  point thep;
  
  teller1=0; teller2=0;
  thep=(point)point_dll(po,START,0);
  
  while (thep!=(point)NULL)
    { 
      if (thep->type==CNODE)
	{ 
	  if (thep->label*3-3<m) 
	    { 
	      teller1++;	
	      V(nietnul,thep->label*3-3)=teller1;
	      teller1++;	
	      V(nietnul,thep->label*3-2)=teller1;
	      teller1++;	
	      V(nietnul,thep->label*3-1)=teller1;
	    }
	  else 
	    { 
	      teller2++;	
	      V(nietnul,thep->label*3-3)=teller2;  
	      teller2++;	
	      V(nietnul,thep->label*3-2)=teller2;  
	      teller2++;	
	      V(nietnul,thep->label*3-1)=teller2;  
	    }
	}  
      else
	{
	  V(nietnul,thep->label*3-3)=0;
	  V(nietnul,thep->label*3-2)=0;
	  V(nietnul,thep->label*3-1)=0;
	}
      thep=thep->NEXT;
    }
  
  p=teller1; /* aantal niet-nul kolommen in het linkergedeelte */
  q=teller2; /* aantal niet-nul kolommen in het rechtergedeelte */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
xorl %r14d, %r14d
movq %rdx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcc2f
movl $0x0, %ecx
testq %rax, %rax
je 0xc9d1
xorl %ecx, %ecx
xorl %r14d, %r14d
cmpl $0xf, 0x14(%rax)
jne 0xc97d
movslq 0x10(%rax), %rdx
leaq (%rdx,%rdx,2), %rsi
leal -0x3(%rsi), %edi
movq 0x8(%rbx), %rdx
cmpl %ebp, %edi
jge 0xc99d
leal 0x1(%r14), %edi
movl %edi, -0xc(%rdx,%rsi,4)
leal 0x2(%r14), %esi
movslq 0x10(%rax), %rdi
leaq (%rdi,%rdi,2), %rdi
movl %esi, -0x8(%rdx,%rdi,4)
addl $0x3, %r14d
movl %r14d, %esi
jmp 0xc9b8
movq 0x8(%rbx), %rdx
movslq 0x10(%rax), %rsi
leaq (%rsi,%rsi,2), %rdi
xorl %esi, %esi
movl %esi, -0xc(%rdx,%rdi,4)
movslq 0x10(%rax), %rdi
leaq (%rdi,%rdi,2), %rdi
movl %esi, -0x8(%rdx,%rdi,4)
jmp 0xc9b8
leal 0x1(%rcx), %edi
movl %edi, -0xc(%rdx,%rsi,4)
leal 0x2(%rcx), %esi
movslq 0x10(%rax), %rdi
leaq (%rdi,%rdi,2), %rdi
movl %esi, -0x8(%rdx,%rdi,4)
addl $0x3, %ecx
movl %ecx, %esi
movslq 0x10(%rax), %rdi
leaq (%rdi,%rdi,2), %rdi
movl %esi, -0x4(%rdx,%rdi,4)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0xc943
movl %r14d, 0x8f18(%rip)     # 0x158f0
movl %ecx, 0x8f16(%rip)      # 0x158f4
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/matrix.c
// Function: verwijdernullen
void verwijdernullen(int m,int n,matrix Ma, intvector nietnul,point po )
/* Transformeert de matrix M in een tweetal matrices N1 en N2 die ontstaan
   uit M door uit respectievelijk de bovenste helft en de onderste helft
   de nul-kolommen weg te halen */
{ 
  int i,j,k;
  
  nn(m, nietnul, po);
  
  /* We schuiven in het bovenste gedeelte de niet-nul kolommen naar 
     links */

  k=0;
  for (j=m;j<m+n;j++)
    {
      if (V(nietnul,j)!=0)
	{	
	  for (i=0;i<m;i++)	   
	    M(Ma,i,m+k)=M(Ma,i,j);	   	  
	  k++;
	}	
    }
  
  k=1;
  for (j=m-1;j>=0;j--)
    {
      if (V(nietnul,j)!=0)
	{	
	  for (i=0;i<n;i++)
	    M(Ma,m+i,m-k)=M(Ma,m+i,j); 
	  k++;
	}		
    } 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, %r14d
movl %edi, %r15d
movq %rcx, %rsi
movq %r8, %rdx
callq 0xc918
movl %r15d, %eax
testl %r14d, %r14d
jle 0xca56
leal (%r14,%r15), %esi
movq 0x8(%r12), %rcx
movslq %r15d, %rdx
movslq %esi, %rsi
xorl %edi, %edi
cmpl $0x0, (%rcx,%rdx,4)
je 0xca4e
testl %r15d, %r15d
jle 0xca4c
movq 0x8(%rbx), %r8
leal (%rdi,%r15), %r9d
movslq %r9d, %r9
xorl %r10d, %r10d
movq (%r8,%r10,8), %r11
movsd (%r11,%rdx,8), %xmm0
movsd %xmm0, (%r11,%r9,8)
incq %r10
cmpq %r10, %rax
jne 0xca34
incl %edi
incq %rdx
cmpq %rsi, %rdx
jl 0xca1b
testl %r15d, %r15d
jle 0xcab6
movq 0x8(%r12), %rcx
movl %r14d, %edx
movl $0x1, %esi
leaq (,%rax,8), %rdi
leaq -0x1(%rax), %r8
cmpl $0x0, -0x4(%rcx,%rax,4)
je 0xcaad
testl %r14d, %r14d
jle 0xcaab
movl %r15d, %r9d
subl %esi, %r9d
movslq %r9d, %r9
movq 0x8(%rbx), %r10
addq %rdi, %r10
xorl %r11d, %r11d
movq (%r10,%r11,8), %r12
movsd (%r12,%r8,8), %xmm0
movsd %xmm0, (%r12,%r9,8)
incq %r11
cmpq %r11, %rdx
jne 0xca93
incl %esi
cmpq $0x1, %rax
movq %r8, %rax
jg 0xca70
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/matrix.c
// Function: hetelement
double hetelement(int m, int i, int j, intvector nietnul, matrix Ma)
/* Bepaalt het hetelement (i,j) van de oorspronkelijke matrix M uit de nieuwe
   matrix Ma */
{  
  if (i<m)
    {	
      if (j<m) 
	return M(Ma,i,j);
      else	
	{
	  if (V(nietnul,j)!=0)
	    return M(Ma,i,m+V(nietnul,j)-1);
	  else	return 0;
	}	
    }
  else	
    {
      if (j>=m)
	{	
	  return M(Ma,i,j);
	}	
      else	
	{
	  if (V(nietnul,j)!=0)
	    return M(Ma,i,m-p+V(nietnul,j)-1);
	  else return 0;
	}	
    }
}

// Assembly:
cmpl %edi, %esi
jge 0xcae7
cmpl %edi, %edx
jl 0xcb18
movq 0x8(%rcx), %rax
movslq %edx, %rcx
movl (%rax,%rcx,4), %eax
testl %eax, %eax
je 0xcb2f
movq 0x8(%r8), %rcx
movslq %esi, %rdx
movq (%rcx,%rdx,8), %rcx
addl %edi, %eax
jmp 0xcb0c
cmpl %edi, %edx
jge 0xcb18
movq 0x8(%rcx), %rax
movslq %edx, %rcx
movl (%rax,%rcx,4), %eax
testl %eax, %eax
je 0xcb2f
movq 0x8(%r8), %rcx
movslq %esi, %rdx
movq (%rcx,%rdx,8), %rcx
addl %edi, %eax
subl 0x8de4(%rip), %eax      # 0x158f0
cltq
leaq (%rcx,%rax,8), %rax
addq $-0x8, %rax
jmp 0xcb2a
movq 0x8(%r8), %rcx
movslq %esi, %rsi
movslq %edx, %rax
shlq $0x3, %rax
addq (%rcx,%rsi,8), %rax
movsd (%rax), %xmm0
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/memstat.c
// Function: mymalloc
const void *mymalloc(const size_t size)
{ const void *p; 
  if (size==0) fprintf(stderr,"MYMALLOC CALLED WITH 0 LENGTH!\n");
  p = (void *)malloc(size);
  current_allocated++;
  return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0xcba9
movq %rbx, %rdi
callq 0x1130
incl 0x8d51(%rip)            # 0x158f8
popq %rbx
retq
callq 0x3561
jmp 0xcb99
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/memstat.c
// Function: myfree
void myfree(void *p)
{ if (p==NULL) {
	fprintf(stderr,"MYFREE CALLED FOR SOMETHING THAT IS NOT ALLOCATED!\n"); 
	p=p;
  }
  free(p);
  current_allocated--;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0xcbc9
movq %rbx, %rdi
callq 0x1030
decl 0x8d31(%rip)            # 0x158f8
popq %rbx
retq
callq 0x357d
jmp 0xcbb9
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/general/points.c
// Function: newpoint
point newpoint( void )
{ point p;
  if ( (p=(point)mymalloc(sizeof(pointtype))) == (point)NULL )
    evaluate_level(RED,10);
  p->PREV=(point)NULL; p->NEXT=(point)NULL; p->label = -1;
  p->type=NODE; p->conn=0;
  return p;
}

// Assembly:
pushq %rbx
movl $0x88, %edi
callq 0xcb90
movq %rax, %rbx
testq %rax, %rax
jne 0xcc0a
movl $0x2, %edi
movl $0xa, %esi
callq 0xb980
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movabsq $0xbffffffff, %rax      # imm = 0xBFFFFFFFF
movq %rax, 0x10(%rbx)
movl $0x0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq