LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/emath/singular.c
// Function: make_S
void make_S( const matrix S, const double beta )
{ /* IN:          Matrix S, beta
   * OUT:         nothing
   * MODIFIES:    matrix S
   * USES:        data from theElement, beta as calculated in make_D()
   * DESCRIPTION: Fills matrix S
   */

int  i;    /* counter */
double i312, /* :temporary storage: */
	 i321;

   for (i=1; i<=3; i++)
   { i312 = (n3[i]-n1[i])/theElement->z2;
	 i321 = (n3[i]-n2[i])/theElement->z1;

	/* first component: */
	 M(S,i,1) = i312 * (cosA2 + cosA3)
			  - i321 * (1.0 - cosA1);
     M(S,i,1) = M(S,i,1) / sinA3;

	/* second component: */
     M(S,i,2) = cos(theElement->alpha3-theElement->alpha1);
	 M(S,i,2) = cosA3 - M(S,i,2) + beta*sinA3*sinA3;
	 M(S,i,2) = i321 * M(S,i,2);
	 M(S,i,2) = -i312 * (1.0-cosA1) + M(S,i,2);
	 M(S,i,2) = M(S,i,2) * theElement->z2 / theElement->z1 / sinA3;

	/* third component: */
	 M(S,i,3) = cosA3 + cosA2 - beta*sinA2*sinA3;
	 M(S,i,3) = M(S,i,3) * i321;
	 M(S,i,3) = -i312 * (1.0-cosA1) + M(S,i,3);
	 M(S,i,3) = M(S,i,3) * theElement->z2 / theElement->z1 / sinA2;

   } /* for i */

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0xc289(%rip), %r15      # 0x14830
leaq 0xc242(%rip), %r12      # 0x147f0
leaq 0xc25b(%rip), %r13      # 0x14810
cmpq $0x18, %r14
je 0x872e
movsd 0x8(%r14,%r15), %xmm2
movapd %xmm2, %xmm0
subsd 0x8(%r14,%r12), %xmm0
movq 0xc1d8(%rip), %rax      # 0x147b0
divsd 0x90(%rax), %xmm0
movapd %xmm0, %xmm3
movapd %xmm0, 0x10(%rsp)
subsd 0x8(%r14,%r13), %xmm2
divsd 0x88(%rax), %xmm2
movsd %xmm2, 0x8(%rsp)
movsd 0xc1c9(%rip), %xmm0     # 0x147d0
addsd 0xc1d1(%rip), %xmm0     # 0x147e0
movsd 0x49f1(%rip), %xmm1     # 0xd008
subsd 0xc1a1(%rip), %xmm1     # 0x147c0
mulsd %xmm2, %xmm1
mulsd %xmm3, %xmm0
subsd %xmm1, %xmm0
movq 0x8(%rbx), %rcx
movq (%rcx,%r14), %rcx
movsd %xmm0, (%rcx)
divsd 0xc199(%rip), %xmm0     # 0x147d8
movsd %xmm0, (%rcx)
movsd 0x80(%rax), %xmm0
subsd 0x70(%rax), %xmm0
callq 0x10c0
movq 0x8(%rbx), %rax
movq (%rax,%r14), %rax
movsd 0xc17b(%rip), %xmm1     # 0x147e0
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd 0xc163(%rip), %xmm0     # 0x147d8
movapd %xmm0, %xmm3
movsd (%rsp), %xmm5
mulsd %xmm5, %xmm3
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
movsd 0x8(%rsp), %xmm6
mulsd %xmm6, %xmm3
movapd 0x10(%rsp), %xmm4
xorpd 0x497e(%rip), %xmm4     # 0xd020
movsd 0x495e(%rip), %xmm2     # 0xd008
subsd 0xc10e(%rip), %xmm2     # 0x147c0
mulsd %xmm4, %xmm2
addsd %xmm2, %xmm3
movsd %xmm3, 0x8(%rax)
movq 0xc0ea(%rip), %rcx      # 0x147b0
mulsd 0x90(%rcx), %xmm3
divsd 0x88(%rcx), %xmm3
divsd %xmm0, %xmm3
movsd %xmm3, 0x8(%rax)
addsd 0xc0e9(%rip), %xmm1     # 0x147d0
movsd 0xc0d9(%rip), %xmm3     # 0x147c8
movapd %xmm3, %xmm4
mulsd %xmm5, %xmm4
mulsd %xmm0, %xmm4
subsd %xmm4, %xmm1
mulsd %xmm6, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x10(%rax)
mulsd 0x90(%rcx), %xmm1
divsd 0x88(%rcx), %xmm1
divsd %xmm3, %xmm1
movsd %xmm1, 0x10(%rax)
addq $0x8, %r14
jmp 0x85b5
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/emath/singular.c
// Function: make_E
void make_E( const matrix D, const matrix S, const hypermatrix E )
{ /* IN:          matrices D, S, hypermatrix E
   * OUT:         nothing
   * MODIFIES:    hypermatrix E
   * USES:        D, E, normal vector of theElement
   * DESCRIPTION:
   * This function calculates the Ekij hypermatrix.
   */

double scalefactor;  
int k, i, j; /* :counters */

scalefactor = 1.0-2.0*NU;

 for (j=1; j<=3; j++)
 { for (k=1; k<=3; k++)
   { for(i=1; i<=3; i++)
     { H(E,k,i,j) = normal[k] * M(S,i,j) - normal[i] * M(S,k,j);
	   if (j==1)
	   { /* add the delta term to E: */
		  H(E,k,i,j) = H(E,k,i,j) + M(D,k,i);
	   } /* if */
	   H(E,k,i,j) = H(E,k,i,j) * scalefactor;
     } /* for i */
   } /* for k */
 } /* for j */

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xbcb8(%rip), %rax      # 0x14400
movsd (%rax), %xmm1
addsd %xmm1, %xmm1
movsd 0x48b0(%rip), %xmm0     # 0xd008
subsd %xmm1, %xmm0
movq 0x8(%rsi), %rax
movq 0x8(%rdx), %rcx
movabsq $0x1, %rdx
leaq 0xc0db(%rip), %rsi      # 0x14850
movq %rdx, %r8
cmpq $0x4, %r8
je 0x8804
movq (%rcx,%r8,8), %r9
movq 0x8(%r9), %r9
movq %rdx, %r10
cmpq $0x4, %r10
je 0x87fc
movsd (%rsi,%r10,8), %xmm1
movq -0x8(%rax,%r10,8), %r11
movq -0x8(%r9,%r10,8), %rbx
xorl %r14d, %r14d
cmpq $0x3, %r14
je 0x87f7
movq (%rax,%r14,8), %r15
movsd -0x8(%r11,%r8,8), %xmm3
mulsd 0x8(%rsi,%r14,8), %xmm3
movsd -0x8(%r15,%r8,8), %xmm2
mulsd %xmm1, %xmm2
subsd %xmm3, %xmm2
movsd %xmm2, (%rbx,%r14,8)
cmpq $0x1, %r8
jne 0x87e8
movq 0x8(%rdi), %r15
movq -0x8(%r15,%r10,8), %r15
addsd (%r15,%r14,8), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, (%rbx,%r14,8)
incq %r14
jmp 0x87a6
incq %r10
jmp 0x878d
incq %r8
jmp 0x8778
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: scalemesh
void scalemesh(mesh theMesh)
{ element elm;
  /* scale the system to a dimensionless monster... */
  scalesystem(theMesh); 

  /* complete the element data with the values for z1, z2, z3, alpha1,
   * alpha2 and alpha3: */
   elm=(element)element_dll(theMesh->mesh_e,START,0);
   while (elm!=(element)NULL)
   { TRILcompletion(elm,theMesh->mesh_p);
     elm=(element)elm->NEXT;
   }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8c8a
movq 0x8(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xad45
movq %rax, %r14
testq %r14, %r14
je 0x8c82
movq (%rbx), %rsi
movq %r14, %rdi
callq 0xc6f0
movq 0x8(%r14), %r14
jmp 0x8c6c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: scalesystem
void scalesystem(mesh theMesh)
{ init_scale(theMesh);
  determineGscale(theMesh); scalegeometry(theMesh);
  determineTscale(theMesh); scaletractions(theMesh);
  determineDscale(theMesh); scaledisplacements(theMesh);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x8cc9
movsd 0xbbd5(%rip), %xmm0     # 0x14870
movsd %xmm0, 0x30(%rbx)
movq %rbx, %rdi
callq 0x8eee
movq %rbx, %rdi
callq 0x903e
movq %rbx, %rdi
callq 0x907c
movq %rbx, %rdi
callq 0x8f76
movq %rbx, %rdi
popq %rbx
jmp 0x8fb5
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: scalegeometry
void scalegeometry(mesh theMesh)
{ point q;
  q = (point)point_dll(theMesh->mesh_p,START,0);
  while (q!=(point)NULL)
  { q->x=q->x/theMesh->G_SCALE;
    q->y=q->y/theMesh->G_SCALE;
    q->z=q->z/theMesh->G_SCALE;
    q=q->NEXT;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc14c
testq %rax, %rax
je 0x8f32
movsd 0x30(%rbx), %xmm0
movupd 0x20(%rax), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
divpd %xmm2, %xmm1
movupd %xmm1, 0x20(%rax)
movsd 0x30(%rax), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x30(%rax)
movq 0x8(%rax), %rax
jmp 0x8efe
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: determineDscale
void determineDscale(mesh theMesh)
{ /* The D_SCALE is defined as T_SCALE*G_SCALE/EMOD... */
  if (fabs(tmax)>1.0E-13) {
    theMesh->D_SCALE=theMesh->T_SCALE*theMesh->G_SCALE/EMOD;
  }
  else {
    theMesh->D_SCALE=dmax;
  }
}

// Assembly:
movsd 0xb902(%rip), %xmm0     # 0x14880
andpd 0x408a(%rip), %xmm0     # 0xd010
ucomisd 0x52f2(%rip), %xmm0     # 0xe280
jbe 0x8fa7
movsd 0x40(%rdi), %xmm0
mulsd 0x30(%rdi), %xmm0
leaq 0xb457(%rip), %rax      # 0x143f8
divsd (%rax), %xmm0
jmp 0x8faf
movsd 0xb8c9(%rip), %xmm0     # 0x14878
movsd %xmm0, 0x38(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: scaledisplacements
void scaledisplacements(mesh theMesh)
{ restraint di; 
  di = (restraint)restraint_dll(theMesh->mesh_d,START,0);
  while (di!=(restraint)NULL)
  { di->u1=di->u1/theMesh->D_SCALE;
    di->u2=di->u2/theMesh->D_SCALE;
    di->u3=di->u3/theMesh->D_SCALE;
    di=di->NEXT;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc3a0
testq %rax, %rax
je 0x8ffa
movsd 0x38(%rbx), %xmm0
movupd 0x30(%rax), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
divpd %xmm2, %xmm1
movupd %xmm1, 0x30(%rax)
movsd 0x40(%rax), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x40(%rax)
movq 0x8(%rax), %rax
jmp 0x8fc6
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: scaledisplacementsback
void scaledisplacementsback(mesh theMesh)
{ point q;
  q = (point)point_dll(theMesh->mesh_p,START,0);
  while (q!=(point)NULL)
  { q->dx=q->dx*theMesh->D_SCALE;
    q->dy=q->dy*theMesh->D_SCALE;
    q->dz=q->dz*theMesh->D_SCALE;
    q=q->NEXT;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc14c
testq %rax, %rax
je 0x903c
movsd 0x38(%rbx), %xmm0
movupd 0x50(%rax), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm1, %xmm2
movupd %xmm2, 0x50(%rax)
mulsd 0x60(%rax), %xmm0
movsd %xmm0, 0x60(%rax)
movq 0x8(%rax), %rax
jmp 0x900c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: determineTscale
void determineTscale(mesh theMesh)
{ /* The T_SCALE is defined as the maximum applied displacement component times EMOD.  */
   if (fabs(dmax)>1.0E-13) {
     theMesh->T_SCALE=dmax*EMOD/theMesh->G_SCALE;
   }
   else {
     theMesh->T_SCALE=tmax;
   }
}

// Assembly:
movsd 0xb832(%rip), %xmm0     # 0x14878
movapd 0x3fc2(%rip), %xmm1     # 0xd010
andpd %xmm0, %xmm1
ucomisd 0x5226(%rip), %xmm1     # 0xe280
jbe 0x906e
leaq 0xb395(%rip), %rax      # 0x143f8
mulsd (%rax), %xmm0
divsd 0x30(%rdi), %xmm0
jmp 0x9076
movsd 0xb80a(%rip), %xmm0     # 0x14880
movsd %xmm0, 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc3a0
testq %rax, %rax
je 0x90c1
movsd 0x40(%rbx), %xmm0
movupd 0x18(%rax), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
divpd %xmm2, %xmm1
movupd %xmm1, 0x18(%rax)
movsd 0x28(%rax), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x28(%rax)
movq 0x8(%rax), %rax
jmp 0x908d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc14c
testq %rax, %rax
je 0x9103
movsd 0x40(%rbx), %xmm0
movupd 0x38(%rax), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm1, %xmm2
movupd %xmm2, 0x38(%rax)
mulsd 0x48(%rax), %xmm0
movsd %xmm0, 0x48(%rax)
movq 0x8(%rax), %rax
jmp 0x90d3
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xad45
movsd 0x4d32(%rip), %xmm0     # 0xde50
testq %rax, %rax
je 0x914d
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 0x911e
movsd %xmm0, 0x48(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $-0x1, %edi
je 0x951b
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
je 0x94de
cvtsi2ss %edi, %xmm0
cvtsi2ssl 0xb400(%rip), %xmm1 # 0x14888
divss %xmm1, %xmm0
mulss 0x3b70(%rip), %xmm0     # 0xd004
cvttss2si %xmm0, %ebp
cmpl %ebp, 0xb3fa(%rip)      # 0x14898
jge 0x94cd
xorl %r14d, %r14d
testl %ebp, %ebp
cmovgl %ebp, %r14d
movq 0xab48(%rip), %r15      # 0x13ff8
pushq $0x3e
popq %rbx
movq (%r15), %rsi
subl $0x1, %r14d
jb 0x94c5
movl %ebx, %edi
callq 0x10d0
jmp 0x94b3
pushq $0xd
popq %rdi
callq 0x10d0
movl %ebp, 0xb3c5(%rip)      # 0x14898
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xab13(%rip), %r14      # 0x13ff8
movq (%r14), %rcx
leaq 0x4cf1(%rip), %rdi      # 0xe1e0
pushq $0x23
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x1190
movq (%r14), %rcx
leaq 0x4ad2(%rip), %rdi      # 0xdfd9
pushq $0x42
popq %rsi
movq %rbx, %rdx
callq 0x1190
andl $0x0, 0xb37f(%rip)      # 0x14898
jmp 0x94d3
movq 0xaad6(%rip), %rax      # 0x13ff8
movq (%rax), %rcx
leaq 0x3b1e(%rip), %rdi      # 0xd04a
pushq $0x44
popq %rsi
pushq $0x1
popq %rdx
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
pushq $0x3
popq %rdi
movl %edi, %esi
callq 0xb24c
movq %rax, 0xb354(%rip)      # 0x148a0
pushq $0x40
popq %rdi
callq 0xc068
movq %rax, 0xb34d(%rip)      # 0x148a8
testq %rax, %rax
jne 0x956b
pushq $0x2
popq %rdi
pushq $0x6c
popq %rsi
callq 0xb0f8
pushq $0x40
popq %rdi
callq 0xc068
movq %rax, 0xb336(%rip)      # 0x148b0
testq %rax, %rax
jne 0x958a
pushq $0x2
popq %rdi
pushq $0x6c
popq %rsi
callq 0xb0f8
xorl %r14d, %r14d
pushq $0x3
popq %rbx
cmpq $0x8, %r14
je 0x95c3
movl %ebx, %edi
movl %ebx, %esi
callq 0xb24c
movq 0xb302(%rip), %rcx      # 0x148a8
movq %rax, (%rcx,%r14,8)
movl %ebx, %edi
movl %ebx, %esi
callq 0xb24c
movq 0xb2f6(%rip), %rcx      # 0x148b0
movq %rax, (%rcx,%r14,8)
incq %r14
jmp 0x9590
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x64
popq %rsi
xorl %edi, %edi
callq 0xb0f8
leaq 0xae47(%rip), %rax      # 0x14424
cmpl $0x0, (%rax)
je 0x95e7
pushq $0x3
popq %rdi
jmp 0x95ee
imull $0x3, 0xb29a(%rip), %edi # 0x14888
movl %edi, %esi
callq 0xb24c
leaq 0xae34(%rip), %rcx      # 0x14430
movq %rax, (%rcx)
movq %rax, %rdi
xorl %esi, %esi
callq 0xb45d
imull $0x3, 0xb278(%rip), %edi # 0x14888
callq 0xb358
leaq 0xae1c(%rip), %rcx      # 0x14438
movq %rax, (%rcx)
imull $0x3, 0xb262(%rip), %edi # 0x14888
callq 0xb358
leaq 0xae0e(%rip), %rcx      # 0x14440
movq %rax, (%rcx)
popq %rax
jmp 0x9537
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x65
popq %rsi
xorl %edi, %edi
callq 0xb0f8
movq 0xb251(%rip), %rdi      # 0x148a0
callq 0xb3b2
movq 0xb24d(%rip), %rdi      # 0x148a8
cmpq $0x8, %rbx
je 0x967f
movq (%rdi,%rbx,8), %rdi
callq 0xb3b2
movq 0xb23f(%rip), %rax      # 0x148b0
movq (%rax,%rbx,8), %rdi
callq 0xb3b2
incq %rbx
jmp 0x9654
callq 0xc09f
movq 0xb225(%rip), %rdi      # 0x148b0
popq %rbx
jmp 0xc09f
// File: /workspace/github_c_makefile_star2_O2/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 0xab71(%rip), %r12      # 0x142f0
leaq 0xabaa(%rip), %r13      # 0x14330
leaq 0xabe3(%rip), %rbp      # 0x14370
cmpq $0x38, %r15
je 0x9860
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 0xb0a0(%rip), %rax      # 0x148b0
movq 0x8(%rax,%r15), %rdi
movq 0xb08c(%rip), %rax      # 0x148a8
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 0xaaa0
addq $0x8, %r15
jmp 0x978d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb551
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb551
movq 0x8(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xad45
movq %rax, %rbp
testq %rbp, %rbp
je 0x9c10
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x9ab7
movq 0x8(%r13), %rax
movslq 0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r12), %rax
movq 0x8(%rax), %rsi
callq 0xb83f
movq 0x8(%rbx), %rax
movslq 0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r15), %rax
movq 0x8(%rax), %rsi
callq 0xb83f
movq 0x8(%r13), %rax
movslq 0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r12), %rax
movq 0x10(%rax), %rsi
callq 0xb83f
movq 0x8(%rbx), %rax
movslq 0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r15), %rax
movq 0x10(%rax), %rsi
callq 0xb83f
movq 0x8(%r13), %rax
movslq 0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r12), %rax
movq 0x18(%rax), %rsi
callq 0xb83f
movq 0x8(%rbx), %rax
movslq 0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r15), %rax
movq 0x18(%rax), %rsi
callq 0xb83f
movq 0x8(%rbp), %rbp
jmp 0x9b54
movq 0x8(%rbx), %rax
movslq 0x10(%r14), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0xb45d
pushq $0x1
popq %r15
movl 0xac5b(%rip), %eax      # 0x14888
movslq %eax, %rcx
cmpq %rcx, %r15
jg 0x9c5d
movl 0x10(%r14), %ecx
cmpq %rcx, %r15
je 0x9c58
movslq %ecx, %rax
movq 0x8(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rcx,%r15,8), %rsi
callq 0xb83f
movl 0xac30(%rip), %eax      # 0x14888
incq %r15
jmp 0x9c2d
movq 0x8(%rbx), %rax
movslq 0x10(%r14), %rcx
movq (%rax,%rcx,8), %rdi
movsd 0x435f(%rip), %xmm0     # 0xdfd0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb77b
// File: /workspace/github_c_makefile_star2_O2/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 0xa5e4(%rip), %r14      # 0x14440
movq (%r14), %rdi
xorl %esi, %esi
callq 0xb5d1
leaq 0xa5cb(%rip), %rax      # 0x14438
movq (%rax), %rdi
xorl %esi, %esi
callq 0xb5d1
movq 0x18(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc3a0
movq (%r14), %rcx
testq %rax, %rax
je 0x9ebf
movsd 0x18(%rax), %xmm0
movq 0x8(%rcx), %rdx
movslq 0x14(%rax), %rsi
imulq $0x18, %rsi, %rsi
movsd %xmm0, -0x18(%rdx,%rsi)
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x10(%rdx,%rsi)
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x8(%rdx,%rsi)
movq 0x8(%rax), %rax
jmp 0x9e87
movq 0x10(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc3a0
movq (%r14), %rcx
testq %rax, %rax
je 0x9f07
movsd 0x30(%rax), %xmm0
movq 0x8(%rcx), %rdx
movslq 0x14(%rax), %rsi
imulq $0x18, %rsi, %rsi
movsd %xmm0, -0x18(%rdx,%rsi)
movsd 0x38(%rax), %xmm0
movsd %xmm0, -0x10(%rdx,%rsi)
movsd 0x40(%rax), %xmm0
movsd %xmm0, -0x8(%rdx,%rsi)
movq 0x8(%rax), %rax
jmp 0x9ecf
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/emath/linearc.c
// Function: linear3
void linear3(mesh theMesh)
{ point       sourcenode;
  hypermatrix c;
  hypermatrix e;
  hypermatrix crow;
  hypermatrix erow;

  printstatus(theMesh);
  init_linear();

if (READ_SOLUTION==NO)
{
  c=(hypermatrix)newhypermatrix(3,3,3);
  e=(hypermatrix)newhypermatrix(3,3,3);
  crow=(hypermatrix)newhypermatrix(3,3,n_nodes);
  erow=(hypermatrix)newhypermatrix(3,3,n_nodes);

  make_rhs_vector(theMesh);

  tijdbalkje(0);
  sourcenode=(point)point_dll(theMesh->mesh_p,START,0);
  while (sourcenode!=(point)NULL)
  { tijdbalkje(sourcenode->label); 
    make_row(sourcenode,crow,erow,c,e,theMesh);
    remap(crow,erow,sourcenode,theMesh); 
    plug_in(sourcenode->label,erow);
    sourcenode=sourcenode->NEXT;
  }

  tijdbalkje(-1);
  delhypermatrix(c);
  delhypermatrix(e);
  delhypermatrix(crow);
  delhypermatrix(erow);
} /* if READ_SOLUTION == NO */

  close_linear();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x9170
callq 0x95cb
leaq 0xa41a(%rip), %rax      # 0x14424
cmpl $0x0, (%rax)
jne 0xa0e2
pushq $0x3
popq %rbp
movl %ebp, %edi
movl %ebp, %esi
movl %ebp, %edx
callq 0xb2dc
movq %rax, %r14
movl %ebp, %edi
movl %ebp, %esi
movl %ebp, %edx
callq 0xb2dc
movq %rax, %r15
movl 0xa850(%rip), %edx      # 0x14888
movl %ebp, %edi
movl %ebp, %esi
callq 0xb2dc
movq %rax, %r12
movl 0xa83e(%rip), %edx      # 0x14888
movl %ebp, %edi
movl %ebp, %esi
callq 0xb2dc
movq %rax, %r13
movq %rbx, %rdi
callq 0x9e4e
xorl %edi, %edi
callq 0x9468
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc14c
movq %rax, %rbp
testq %rbp, %rbp
je 0xa0ba
movl 0x10(%rbp), %edi
callq 0x9468
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0x9b13
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x9c84
movl 0x10(%rbp), %edi
movq %r13, %rsi
callq 0x9f0f
movq 0x8(%rbp), %rbp
jmp 0xa074
pushq $-0x1
popq %rdi
callq 0x9468
movq %r14, %rdi
callq 0xb405
movq %r15, %rdi
callq 0xb405
movq %r12, %rdi
callq 0xb405
movq %r13, %rdi
callq 0xb405
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x963b
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc14c
movq %rax, %r14
pushq $0x3
popq %rbp
leaq 0xa2dc(%rip), %r15      # 0x143f8
leaq 0xa2dd(%rip), %r12      # 0x14400
testq %r14, %r14
je 0xa256
movq 0x10(%rbx), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xc3a0
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 0x2ebb(%rip), %xmm2     # 0xd020
mulsd %xmm0, %xmm2
movapd %xmm3, %xmm4
movapd %xmm3, %xmm5
movapd %xmm0, %xmm6
addsd %xmm1, %xmm0
mulsd %xmm3, %xmm0
mulsd 0x32d3(%rip), %xmm3     # 0xd458
movsd 0x32d2(%rip), %xmm9     # 0xd460
mulsd %xmm9, %xmm4
movapd 0x4105(%rip), %xmm7     # 0xe2a0
unpcklpd %xmm4, %xmm7            # xmm7 = xmm7[0],xmm4[0]
movapd %xmm3, %xmm4
addsd 0x32cd(%rip), %xmm3     # 0xd478
movsd 0x40dc(%rip), %xmm8     # 0xe290
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, 0x40c8(%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 0x40ba(%rip), %xmm3     # 0xe2c0
mulsd %xmm1, %xmm0
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm1, %xmm3
mulpd %xmm1, %xmm3
movsd (%r15), %xmm1
addpd %xmm4, %xmm3
movsd 0x4061(%rip), %xmm2     # 0xe288
divsd %xmm1, %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm3, %xmm2
movupd %xmm2, 0x30(%rax)
movsd 0x4058(%rip), %xmm2     # 0xe298
divsd %xmm1, %xmm2
mulsd %xmm2, %xmm0
movsd %xmm0, 0x40(%rax)
movq 0x8(%r14), %r14
jmp 0xa123
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc068
movq %rax, %rbx
testq %rax, %rax
jne 0xad26
pushq $0x2
popq %rdi
pushq $0x46
popq %rsi
callq 0xb0f8
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movaps 0x380d(%rip), %xmm0     # 0xe540
movups %xmm0, 0x10(%rbx)
orl $-0x1, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0xc068
movq %rax, %rbx
testq %rax, %rax
jne 0xaeb8
pushq $0x2
popq %rdi
pushq $0x15
popq %rsi
callq 0xb0f8
movl %r14d, (%rbx)
movl %ebp, 0x4(%rbx)
shll $0x3, %r14d
movq %r14, %rdi
callq 0xc068
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xaf01
xorl %ecx, %ecx
movl %ecx, 0x99dd(%rip)      # 0x148b8
cmpl (%rbx), %ecx
jge 0xaf0c
movl 0x4(%rbx), %edi
shll $0x2, %edi
callq 0xc068
movq 0x8(%rbx), %rcx
movslq 0x99c3(%rip), %rdx      # 0x148b8
movq %rax, (%rcx,%rdx,8)
leal 0x1(%rdx), %ecx
testq %rax, %rax
jne 0xaed5
pushq $0x2
popq %rdi
pushq $0x16
popq %rsi
callq 0xb0f8
movl $0x1, 0x10(%rbx)
leaq 0x94ee(%rip), %rax      # 0x14408
incl (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0xc068
movq %rax, %rbx
testq %rax, %rax
jne 0xaf48
pushq $0x2
popq %rdi
pushq $0x15
popq %rsi
callq 0xb0f8
movl %r14d, (%rbx)
movl %ebp, 0x4(%rbx)
shll $0x3, %r14d
movq %r14, %rdi
callq 0xc068
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xaf91
xorl %ecx, %ecx
movl %ecx, 0x9951(%rip)      # 0x148bc
cmpl (%rbx), %ecx
jge 0xaf9c
movl 0x4(%rbx), %edi
shll $0x3, %edi
callq 0xc068
movq 0x8(%rbx), %rcx
movslq 0x9937(%rip), %rdx      # 0x148bc
movq %rax, (%rcx,%rdx,8)
leal 0x1(%rdx), %ecx
testq %rax, %rax
jne 0xaf65
pushq $0x2
popq %rdi
pushq $0x16
popq %rsi
callq 0xb0f8
movl $0x1, 0x10(%rbx)
leaq 0x945e(%rip), %rax      # 0x14408
incl (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rdi
callq 0xc068
movq %rax, %rbx
testq %rax, %rax
jne 0xafd6
pushq $0x2
popq %rdi
pushq $0x17
popq %rsi
callq 0xb0f8
movl %r14d, (%rbx)
leal 0x4(,%r14,4), %edi
callq 0xc068
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0xaffa
pushq $0x2
popq %rdi
pushq $0x18
popq %rsi
callq 0xb0f8
leaq 0x940f(%rip), %rax      # 0x14410
incl (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb024
leaq 0x354d(%rip), %rdi      # 0xe56c
callq 0x1060
xorl %eax, %eax
movl %eax, 0x9894(%rip)      # 0x148c0
movq 0x8(%rbx), %rdi
cmpl (%rbx), %eax
jge 0xb049
cltq
movq (%rdi,%rax,8), %rdi
callq 0xc09f
movl 0x987b(%rip), %eax      # 0x148c0
incl %eax
jmp 0xb026
callq 0xc09f
movq %rbx, %rdi
callq 0xc09f
leaq 0x93af(%rip), %rax      # 0x1440c
incl (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb077
leaq 0x34fa(%rip), %rdi      # 0xe56c
callq 0x1060
xorl %eax, %eax
movl %eax, 0x9845(%rip)      # 0x148c4
movq 0x8(%rbx), %rdi
cmpl (%rbx), %eax
jge 0xb09c
cltq
movq (%rdi,%rax,8), %rdi
callq 0xc09f
movl 0x982c(%rip), %eax      # 0x148c4
incl %eax
jmp 0xb079
callq 0xc09f
movq %rbx, %rdi
callq 0xc09f
leaq 0x935c(%rip), %rax      # 0x1440c
incl (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0xc068
movq %rax, %rbx
testq %rax, %rax
jne 0xb270
pushq $0x2
popq %rdi
pushq $0x15
popq %rsi
callq 0xb0f8
movl %r14d, (%rbx)
movl %ebp, 0x4(%rbx)
shll $0x3, %r14d
movq %r14, %rdi
callq 0xc068
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xb2b9
xorl %ecx, %ecx
movl %ecx, 0x9645(%rip)      # 0x148d8
cmpl (%rbx), %ecx
jge 0xb2c4
movl 0x4(%rbx), %edi
shll $0x3, %edi
callq 0xc068
movq 0x8(%rbx), %rcx
movslq 0x962b(%rip), %rdx      # 0x148d8
movq %rax, (%rcx,%rdx,8)
leal 0x1(%rdx), %ecx
testq %rax, %rax
jne 0xb28d
pushq $0x2
popq %rdi
pushq $0x16
popq %rsi
callq 0xb0f8
movl $0x1, 0x10(%rbx)
leaq 0x9136(%rip), %rax      # 0x14408
incl (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rdi
callq 0xc068
movq %rax, %r14
testq %rax, %rax
jne 0xb305
pushq $0x2
popq %rdi
pushq $0x19
popq %rsi
callq 0xb0f8
movl %r15d, (%r14)
leal 0x8(,%r15,8), %edi
callq 0xc068
movq %rax, 0x8(%r14)
testq %rax, %rax
jne 0xb329
pushq $0x2
popq %rdi
pushq $0x1a
popq %rsi
callq 0xb0f8
xorl %r15d, %r15d
movslq (%r14), %rax
cmpq %rax, %r15
jg 0xb34a
movl %ebp, %edi
movl %ebx, %esi
callq 0xb24c
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0xb32c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rdi
callq 0xc068
movq %rax, %rbx
testq %rax, %rax
jne 0xb37a
pushq $0x2
popq %rdi
pushq $0x17
popq %rsi
callq 0xb0f8
movl %r14d, (%rbx)
leal 0x8(,%r14,8), %edi
callq 0xc068
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0xb39e
pushq $0x2
popq %rdi
pushq $0x18
popq %rsi
callq 0xb0f8
leaq 0x906b(%rip), %rax      # 0x14410
incl (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r14d, %r14d
movslq (%rbx), %rax
movq 0x8(%rbx), %rdi
cmpq %rax, %r14
jg 0xb429
movq (%rdi,%r14,8), %rdi
callq 0xb3b2
incq %r14
jmp 0xb40f
callq 0xc09f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc09f
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: fillmatrix
void fillmatrix(matrix m, int method )
{ int i, j;
  switch(method)
  { case ZEROFILL:  for (i=1; i<=m->rows; i++) 
					  for(j=1; j<=m->cols; j++) M(m,i,j)=0.0; break;
	case ONEFILL:   for (i=1; i<=m->rows; i++) 
					  for(j=1; j<=m->cols; j++) M(m,i,j)=1.0; break;
	case DELTAFILL: for (i=1; i<=m->rows; i++) 
					  for(j=1; j<=m->cols; j++) 
						M(m,i,j)=(i==j)?1.0:0.0; break;
    default:        break;
  }
}

// Assembly:
testl %esi, %esi
je 0xb515
cmpl $0x1, %esi
je 0xb4ce
cmpl $0x2, %esi
jne 0xb550
movl (%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
incl %eax
pushq $0x1
popq %rdx
movsd 0x1b7f(%rip), %xmm0     # 0xd008
xorl %esi, %esi
cmpq %rax, %rdx
je 0xb550
movl 0x4(%rdi), %r8d
testl %r8d, %r8d
cmovlel %ecx, %r8d
xorl %r9d, %r9d
cmpq %r9, %r8
je 0xb4c6
movaps %xmm0, %xmm1
cmpq %r9, %rsi
je 0xb4b2
xorps %xmm1, %xmm1
movq 0x8(%rdi), %r10
movq -0x8(%r10,%rdx,8), %r10
movsd %xmm1, (%r10,%r9,8)
incq %r9
jmp 0xb4a2
incq %rdx
incq %rsi
jmp 0xb48b
movl (%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
incl %eax
pushq $0x1
popq %rdx
movabsq $0x3ff0000000000000, %rsi # imm = 0x3FF0000000000000
cmpq %rax, %rdx
je 0xb550
movl 0x4(%rdi), %r8d
testl %r8d, %r8d
cmovlel %ecx, %r8d
xorl %r9d, %r9d
cmpq %r9, %r8
je 0xb510
movq 0x8(%rdi), %r10
movq -0x8(%r10,%rdx,8), %r10
movq %rsi, (%r10,%r9,8)
incq %r9
jmp 0xb4f9
incq %rdx
jmp 0xb4e6
movl (%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
incl %eax
pushq $0x1
popq %rdx
cmpq %rax, %rdx
je 0xb550
movl 0x4(%rdi), %esi
testl %esi, %esi
cmovlel %ecx, %esi
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0xb54b
movq 0x8(%rdi), %r9
movq -0x8(%r9,%rdx,8), %r9
andq $0x0, (%r9,%r8,8)
incq %r8
jmp 0xb533
incq %rdx
jmp 0xb523
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0xb5ac
cmpl $0x1, %esi
je 0xb589
cmpl $0x2, %esi
jne 0xb5cc
pushq $0x1
popq %r14
pushq $0x2
popq %rbp
movslq (%rbx), %rax
cmpq %rax, %r14
jg 0xb5cc
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
movl %ebp, %esi
callq 0xb45d
incq %r14
jmp 0xb56d
pushq $0x1
popq %r14
pushq $0x1
popq %rbp
movslq (%rbx), %rax
cmpq %rax, %r14
jg 0xb5cc
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
movl %ebp, %esi
callq 0xb45d
incq %r14
jmp 0xb590
pushq $0x1
popq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jg 0xb5cc
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
xorl %esi, %esi
callq 0xb45d
incq %r14
jmp 0xb5b0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb5ff
cmpl $0x1, %esi
jne 0xb61b
movl (%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
cmpq %rcx, %rax
je 0xb61b
movq 0x8(%rdi), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
jmp 0xb5ed
movl (%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0xb61b
movq 0x8(%rdi), %rdx
andq $0x0, (%rdx,%rcx,8)
incq %rcx
jmp 0xb608
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
xorl %esi, %esi
callq 0xb45d
movl 0x4(%rbx), %eax
testl %eax, %eax
cmovlel %r12d, %eax
incl %eax
pushq $0x1
popq %rcx
movq %rcx, %rdx
cmpq %rax, %rdx
je 0xb716
movl (%r15), %esi
testl %esi, %esi
cmovlel %r12d, %esi
incl %esi
movq %rcx, %rdi
cmpq %rsi, %rdi
je 0xb711
movl 0x4(%r15), %r8d
testl %r8d, %r8d
cmovlel %r12d, %r8d
xorl %r9d, %r9d
cmpq %r9, %r8
je 0xb70c
movq 0x8(%r14), %r10
movq -0x8(%r10,%rdi,8), %r10
movq 0x8(%r15), %r11
movq -0x8(%r11,%rdi,8), %r11
movsd (%r11,%r9,8), %xmm0
movq 0x8(%rbx), %r11
movq (%r11,%r9,8), %r11
mulsd -0x8(%r11,%rdx,8), %xmm0
addsd -0x8(%r10,%rdx,8), %xmm0
movsd %xmm0, -0x8(%r10,%rdx,8)
incq %r9
jmp 0xb6cd
incq %rdi
jmp 0xb6ba
incq %rdx
jmp 0xb6a7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
incl %ecx
pushq $0x1
popq %rdi
cmpq %rcx, %rdi
je 0xb77a
movl (%rsi), %r8d
testl %r8d, %r8d
cmovlel %edx, %r8d
xorl %r9d, %r9d
cmpq %r9, %r8
je 0xb775
movq 0x8(%rsi), %r10
movq (%r10,%r9,8), %r10
movsd -0x8(%r10,%rdi,8), %xmm1
mulsd %xmm0, %xmm1
movq 0x8(%rax), %r10
movq (%r10,%r9,8), %r10
movsd %xmm1, -0x8(%r10,%rdi,8)
incq %r9
jmp 0xb749
incq %rdi
jmp 0xb737
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %edi, %edi
testl %ecx, %ecx
cmovlel %edi, %ecx
incl %ecx
pushq $0x1
popq %r8
cmpq %rcx, %r8
je 0xb83e
movl (%rsi), %r9d
testl %r9d, %r9d
cmovlel %edi, %r9d
xorl %r10d, %r10d
cmpq %r10, %r9
je 0xb839
movq 0x8(%rsi), %r11
movq (%r11,%r10,8), %r11
movsd -0x8(%r11,%r8,8), %xmm0
movq 0x8(%rdx), %r11
movq (%r11,%r10,8), %r11
addsd -0x8(%r11,%r8,8), %xmm0
movq 0x8(%rax), %r11
movq (%r11,%r10,8), %r11
movsd %xmm0, -0x8(%r11,%r8,8)
incq %r10
jmp 0xb802
incq %r8
jmp 0xb7f0
retq