LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
leaq 0xbe24(%rip), %rax      # 0x15410
movsd (%rax), %xmm1
addsd %xmm1, %xmm1
movsd 0x4a0c(%rip), %xmm0     # 0xe008
subsd %xmm1, %xmm0
movq 0x8(%rsi), %rax
movq 0x8(%rdx), %rcx
movl $0x1, %edx
leaq 0xc24c(%rip), %rsi      # 0x15860
movq (%rcx,%rdx,8), %r8
movq 0x8(%r8), %r8
movl $0x1, %r9d
movsd (%rsi,%r9,8), %xmm1
movq -0x8(%rax,%r9,8), %r10
movq -0x8(%r8,%r9,8), %r11
xorl %ebx, %ebx
movq (%rax,%rbx,8), %r14
movsd -0x8(%r10,%rdx,8), %xmm3
mulsd 0x8(%rsi,%rbx,8), %xmm3
movsd -0x8(%r14,%rdx,8), %xmm2
mulsd %xmm1, %xmm2
subsd %xmm3, %xmm2
movsd %xmm2, (%r11,%rbx,8)
cmpq $0x1, %rdx
jne 0x9675
movq 0x8(%rdi), %r14
movq -0x8(%r14,%r9,8), %r14
addsd (%r14,%rbx,8), %xmm2
movsd %xmm2, (%r11,%rbx,8)
movsd (%r11,%rbx,8), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, (%r11,%rbx,8)
incq %rbx
cmpq $0x3, %rbx
jne 0x9634
incq %r9
cmpq $0x4, %r9
jne 0x9622
incq %rdx
cmpq $0x4, %rdx
jne 0x9614
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9935
movq 0x8(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb834
testq %rax, %rax
je 0x992d
movq %rax, %r14
movq (%rbx), %rsi
movq %r14, %rdi
callq 0xd54c
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x9919
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x99df
movsd 0xbf3a(%rip), %xmm0     # 0x15880
movsd %xmm0, 0x30(%rbx)
movq %rbx, %rdi
callq 0x9c85
movsd 0xbf2d(%rip), %xmm0     # 0x15888
movapd 0x46ad(%rip), %xmm1     # 0xe010
andpd %xmm0, %xmm1
ucomisd 0x5939(%rip), %xmm1     # 0xf2a8
jbe 0x9983
leaq 0xba90(%rip), %rax      # 0x15408
mulsd (%rax), %xmm0
divsd 0x30(%rbx), %xmm0
jmp 0x998b
movsd 0xbf05(%rip), %xmm0     # 0x15890
movsd %xmm0, 0x40(%rbx)
movq %rbx, %rdi
callq 0x9e27
movsd 0xbef0(%rip), %xmm0     # 0x15890
andpd 0x4668(%rip), %xmm0     # 0xe010
ucomisd 0x58f8(%rip), %xmm0     # 0xf2a8
jbe 0x99c9
movsd 0x40(%rbx), %xmm0
mulsd 0x30(%rbx), %xmm0
leaq 0xba45(%rip), %rax      # 0x15408
divsd (%rax), %xmm0
jmp 0x99d1
movsd 0xbeb7(%rip), %xmm0     # 0x15888
movsd %xmm0, 0x38(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x9d56
// File: /workspace/github_c_makefile_star2_O1/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 0xcf07
testq %rax, %rax
je 0x9ccc
movsd 0x30(%rbx), %xmm0
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movupd 0x20(%rax), %xmm2
divpd %xmm1, %xmm2
movupd %xmm2, 0x20(%rax)
movsd 0x30(%rax), %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, 0x30(%rax)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x9ca7
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbb71(%rip), %xmm0     # 0x15890
andpd 0x42e9(%rip), %xmm0     # 0xe010
ucomisd 0x5579(%rip), %xmm0     # 0xf2a8
jbe 0x9d48
movsd 0x40(%rdi), %xmm0
mulsd 0x30(%rdi), %xmm0
leaq 0xb6c6(%rip), %rax      # 0x15408
divsd (%rax), %xmm0
jmp 0x9d50
movsd 0xbb38(%rip), %xmm0     # 0x15888
movsd %xmm0, 0x38(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd1d1
testq %rax, %rax
je 0x9d9e
movsd 0x38(%rbx), %xmm0
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movupd 0x30(%rax), %xmm2
divpd %xmm1, %xmm2
movupd %xmm2, 0x30(%rax)
movsd 0x40(%rax), %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, 0x40(%rax)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x9d79
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcf07
testq %rax, %rax
je 0x9de7
movsd 0x38(%rbx), %xmm0
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movupd 0x50(%rax), %xmm2
mulpd %xmm1, %xmm2
movupd %xmm2, 0x50(%rax)
movsd 0x60(%rax), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, 0x60(%rax)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x9dc2
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xba97(%rip), %xmm0     # 0x15888
movapd 0x4217(%rip), %xmm1     # 0xe010
andpd %xmm0, %xmm1
ucomisd 0x54a3(%rip), %xmm1     # 0xf2a8
jbe 0x9e19
leaq 0xb5fa(%rip), %rax      # 0x15408
mulsd (%rax), %xmm0
divsd 0x30(%rdi), %xmm0
jmp 0x9e21
movsd 0xba6f(%rip), %xmm0     # 0x15890
movsd %xmm0, 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd1d1
testq %rax, %rax
je 0x9e6f
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 0x9e4a
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcf07
testq %rax, %rax
je 0x9eb8
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 0x9e93
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb834
movsd 0x4f85(%rip), %xmm0     # 0xee58
testq %rax, %rax
je 0x9f02
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 0x9ed3
movsd %xmm0, 0x48(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9f99
testl %edi, %edi
je 0x9f92
cvtsi2ss %edi, %xmm0
cvtsi2ssl 0xb95b(%rip), %xmm1 # 0x15898
divss %xmm1, %xmm0
mulss 0x40bb(%rip), %xmm0     # 0xe004
cvttss2si %xmm0, %ebx
cmpl %ebx, 0xb955(%rip)      # 0x158a8
jge 0x9f87
testl %ebx, %ebx
jle 0x9f73
movq 0xb098(%rip), %r14      # 0x14ff8
movl %ebx, %ebp
movq (%r14), %rsi
movl $0x3e, %edi
callq 0x10e0
decl %ebp
jne 0x9f62
movq 0xb07e(%rip), %rax      # 0x14ff8
movq (%rax), %rsi
movl $0xd, %edi
callq 0x10e0
movl %ebx, 0xb91b(%rip)      # 0x158a8
popq %rbx
popq %r14
popq %rbp
retq
callq 0x3392
jmp 0x9f8d
callq 0x3376
jmp 0x9f8d
// File: /workspace/github_c_makefile_star2_O1/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 0xbcb0
movq %rax, 0xb8f9(%rip)      # 0x158b0
movl $0x40, %edi
callq 0xce68
movq %rax, 0xb8f0(%rip)      # 0x158b8
testq %rax, %rax
jne 0x9fdc
movl $0x2, %edi
movl $0x6c, %esi
callq 0xbc50
movl $0x40, %edi
callq 0xce68
movq %rax, 0xb8d3(%rip)      # 0x158c0
testq %rax, %rax
jne 0xa001
movl $0x2, %edi
movl $0x6c, %esi
callq 0xbc50
xorl %ebx, %ebx
movl $0x3, %edi
movl $0x3, %esi
callq 0xbcb0
movq 0xb89f(%rip), %rcx      # 0x158b8
movq %rax, (%rcx,%rbx,8)
movl $0x3, %edi
movl $0x3, %esi
callq 0xbcb0
movq 0xb88d(%rip), %rcx      # 0x158c0
movq %rax, (%rcx,%rbx,8)
incq %rbx
cmpq $0x8, %rbx
jne 0xa003
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbc50
leaq 0xb3de(%rip), %rax      # 0x15434
cmpl $0x0, (%rax)
je 0xa067
movl $0x3, %edi
movl $0x3, %esi
jmp 0xa072
movl 0xb82b(%rip), %eax      # 0x15898
leal (%rax,%rax,2), %edi
movl %edi, %esi
callq 0xbcb0
leaq 0xb3c2(%rip), %rcx      # 0x15440
movq %rax, (%rcx)
movq %rax, %rdi
xorl %esi, %esi
callq 0xbf13
movl 0xb807(%rip), %eax      # 0x15898
leal (%rax,%rax,2), %edi
callq 0xbde7
leaq 0xb3a8(%rip), %rcx      # 0x15448
movq %rax, (%rcx)
movl 0xb7ef(%rip), %eax      # 0x15898
leal (%rax,%rax,2), %edi
callq 0xbde7
leaq 0xb398(%rip), %rcx      # 0x15450
movq %rax, (%rcx)
popq %rax
jmp 0x9fa0
// File: /workspace/github_c_makefile_star2_O1/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 0xbc50
movq 0xb7d9(%rip), %rdi      # 0x158b0
callq 0xbe4b
movq 0xb7d5(%rip), %rax      # 0x158b8
movq (%rax,%rbx,8), %rdi
callq 0xbe4b
movq 0xb7cd(%rip), %rax      # 0x158c0
movq (%rax,%rbx,8), %rdi
callq 0xbe4b
incq %rbx
cmpq $0x8, %rbx
jne 0xa0dc
movq 0xb7ac(%rip), %rdi      # 0x158b8
callq 0xce88
movq 0xb7a8(%rip), %rdi      # 0x158c0
popq %rbx
jmp 0xce88
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/linearc.c
// Function: plug_in_and_sum
void plug_in_and_sum(int row, int col, matrix sub, 
					 matrix main)
{ /* IN:          row, col, sub, main
   * OUT:         nothing
   * MODIFIES:    the matrix 'main'
   * USES:        the matrix 'main'
   * DESCRIPTION: 
   * This function plugs the [3x3] matrix called 'sub' in one of the main
   * system matrices identified by 'main'. The parameters 'row' and 'col'
   * define the location of the plugging. The submatrix is summed to the
   * values which are already present in the matrices. The 'row' and 'col'
   * values are the numbers when the main matrices are counted as composited
   * from small [3x3] matrices.
   */
   M(main,row*3-2,col*3-2)+=M(sub,1,1);
   M(main,row*3-2,col*3-1)+=M(sub,1,2);
   M(main,row*3-2,col*3  )+=M(sub,1,3);
   M(main,row*3-1,col*3-2)+=M(sub,2,1);
   M(main,row*3-1,col*3-1)+=M(sub,2,2);
   M(main,row*3-1,col*3  )+=M(sub,2,3);
   M(main,row*3  ,col*3-2)+=M(sub,3,1);
   M(main,row*3  ,col*3-1)+=M(sub,3,2);
   M(main,row*3  ,col*3  )+=M(sub,3,3);
}

// Assembly:
movq 0x8(%rdx), %rdx
movq (%rdx), %r8
movsd (%r8), %xmm0
movq 0x8(%rcx), %rcx
leal (%rdi,%rdi,2), %eax
movslq %eax, %rdi
movq -0x18(%rcx,%rdi,8), %r9
leal (%rsi,%rsi,2), %eax
cltq
addsd -0x18(%r9,%rax,8), %xmm0
movsd %xmm0, -0x18(%r9,%rax,8)
movsd 0x8(%r8), %xmm0
addsd -0x10(%r9,%rax,8), %xmm0
movsd %xmm0, -0x10(%r9,%rax,8)
movsd 0x10(%r8), %xmm0
addsd -0x8(%r9,%rax,8), %xmm0
movsd %xmm0, -0x8(%r9,%rax,8)
movq 0x8(%rdx), %rsi
movsd (%rsi), %xmm0
movq -0x10(%rcx,%rdi,8), %r8
addsd -0x18(%r8,%rax,8), %xmm0
movsd %xmm0, -0x18(%r8,%rax,8)
movsd 0x8(%rsi), %xmm0
addsd -0x10(%r8,%rax,8), %xmm0
movsd %xmm0, -0x10(%r8,%rax,8)
movsd 0x10(%rsi), %xmm0
addsd -0x8(%r8,%rax,8), %xmm0
movsd %xmm0, -0x8(%r8,%rax,8)
movq 0x10(%rdx), %rdx
movsd (%rdx), %xmm0
movq -0x8(%rcx,%rdi,8), %rcx
addsd -0x18(%rcx,%rax,8), %xmm0
movsd %xmm0, -0x18(%rcx,%rax,8)
movsd 0x8(%rdx), %xmm0
addsd -0x10(%rcx,%rax,8), %xmm0
movsd %xmm0, -0x10(%rcx,%rax,8)
movsd 0x10(%rdx), %xmm0
addsd -0x8(%rcx,%rax,8), %xmm0
movsd %xmm0, -0x8(%rcx,%rax,8)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb0f4(%rip), %r12      # 0x15300
leaq 0xb12d(%rip), %r13      # 0x15340
leaq 0xb166(%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 0xb62d(%rip), %rax      # 0x158c0
movq 0x8(%rax,%r15), %rdi
movq 0xb619(%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 0xb524
addq $0x8, %r15
cmpq $0x38, %r15
jne 0xa21a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc136
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc136
movq 0x8(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb834
testq %rax, %rax
je 0xa6a3
movq %rax, %rbp
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0xa53a
movq 0x8(%r13), %rax
movslq 0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r12), %rax
movq 0x8(%rax), %rsi
callq 0xc625
movq 0x8(%rbx), %rax
movslq 0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r15), %rax
movq 0x8(%rax), %rsi
callq 0xc625
movq 0x8(%r13), %rax
movslq 0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r12), %rax
movq 0x10(%rax), %rsi
callq 0xc625
movq 0x8(%rbx), %rax
movslq 0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r15), %rax
movq 0x10(%rax), %rsi
callq 0xc625
movq 0x8(%r13), %rax
movslq 0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r12), %rax
movq 0x18(%rax), %rsi
callq 0xc625
movq 0x8(%rbx), %rax
movslq 0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%r15), %rax
movq 0x18(%rax), %rsi
callq 0xc625
movq 0x8(%rbp), %rbp
testq %rbp, %rbp
jne 0xa5ec
movq 0x8(%rbx), %rax
movslq 0x10(%r14), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0xbf13
cmpl $0x0, 0xb1db(%rip)      # 0x15898
jle 0xa6f4
movl $0x1, %r15d
movl 0x10(%r14), %eax
cmpq %rax, %r15
je 0xa6e1
cltq
movq 0x8(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rcx,%r15,8), %rsi
callq 0xc625
leaq 0x1(%r15), %rax
movslq 0xb1ac(%rip), %rcx      # 0x15898
cmpq %rcx, %r15
movq %rax, %r15
jl 0xa6c5
movq 0x8(%rbx), %rax
movslq 0x10(%r14), %rcx
movq (%rax,%rcx,8), %rdi
movsd 0x48f8(%rip), %xmm0     # 0xf000
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc558
// File: /workspace/github_c_makefile_star2_O1/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 0xab67(%rip), %r14      # 0x15450
movq (%r14), %rdi
xorl %esi, %esi
callq 0xc2f3
leaq 0xab4e(%rip), %rax      # 0x15448
movq (%rax), %rdi
xorl %esi, %esi
callq 0xc2f3
movq 0x18(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd1d1
testq %rax, %rax
je 0xa94f
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 0xa91d
movq 0x10(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd1d1
testq %rax, %rax
je 0xa99a
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 0xa968
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcf07
testq %rax, %rax
je 0xabd6
movq %rax, %r14
leaq 0xa96a(%rip), %r15      # 0x15408
leaq 0xa96b(%rip), %r12      # 0x15410
movq 0x10(%rbx), %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0xd1d1
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 0x353f(%rip), %xmm2     # 0xe020
mulsd %xmm0, %xmm2
movapd %xmm3, %xmm4
movapd %xmm3, %xmm5
movapd %xmm0, %xmm6
addsd %xmm1, %xmm0
mulsd %xmm3, %xmm0
mulsd 0x395f(%rip), %xmm3     # 0xe460
movsd 0x395e(%rip), %xmm9     # 0xe468
mulsd %xmm9, %xmm4
movapd 0x47b9(%rip), %xmm7     # 0xf2d0
unpcklpd %xmm4, %xmm7            # xmm7 = xmm7[0],xmm4[0]
movapd %xmm3, %xmm4
addsd 0x3959(%rip), %xmm3     # 0xe480
movsd 0x4790(%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, 0x477c(%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 0x476e(%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 0x4715(%rip), %xmm2     # 0xf2b8
divsd %xmm1, %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm3, %xmm2
movupd %xmm2, 0x30(%rax)
movsd 0x470c(%rip), %xmm2     # 0xf2c8
divsd %xmm1, %xmm2
mulsd %xmm2, %xmm0
movsd %xmm0, 0x40(%rax)
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xaaa5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xce68
movq %rax, %rbx
testq %rax, %rax
jne 0xb812
movl $0x2, %edi
movl $0x46, %esi
callq 0xbc50
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movaps 0x3d51(%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_O1/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 0xce68
movq %rax, %rbx
testq %rax, %rax
jne 0xb9ba
movl $0x2, %edi
movl $0x15, %esi
callq 0xbc50
movl %r14d, (%rbx)
movl %ebp, 0x4(%rbx)
shll $0x3, %r14d
movq %r14, %rdi
callq 0xce68
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xba11
movl $0x0, 0x9ee9(%rip)      # 0x158c8
cmpl $0x0, (%rbx)
jle 0xba20
movl 0x4(%rbx), %edi
shll $0x2, %edi
callq 0xce68
movq 0x8(%rbx), %rdx
movslq 0x9ece(%rip), %rcx      # 0x158c8
movq %rax, (%rdx,%rcx,8)
testq %rax, %rax
je 0xba11
incl %ecx
movl %ecx, 0x9ebd(%rip)      # 0x158c8
cmpl (%rbx), %ecx
jl 0xb9e4
jmp 0xba20
movl $0x2, %edi
movl $0x16, %esi
callq 0xbc50
movl $0x1, 0x10(%rbx)
leaq 0x99ea(%rip), %rax      # 0x15418
incl (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xce68
movq %rax, %rbx
testq %rax, %rax
jne 0xba62
movl $0x2, %edi
movl $0x15, %esi
callq 0xbc50
movl %r14d, (%rbx)
movl %ebp, 0x4(%rbx)
shll $0x3, %r14d
movq %r14, %rdi
callq 0xce68
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xbab9
movl $0x0, 0x9e45(%rip)      # 0x158cc
cmpl $0x0, (%rbx)
jle 0xbac8
movl 0x4(%rbx), %edi
shll $0x3, %edi
callq 0xce68
movq 0x8(%rbx), %rdx
movslq 0x9e2a(%rip), %rcx      # 0x158cc
movq %rax, (%rdx,%rcx,8)
testq %rax, %rax
je 0xbab9
incl %ecx
movl %ecx, 0x9e19(%rip)      # 0x158cc
cmpl (%rbx), %ecx
jl 0xba8c
jmp 0xbac8
movl $0x2, %edi
movl $0x16, %esi
callq 0xbc50
movl $0x1, 0x10(%rbx)
leaq 0x9942(%rip), %rax      # 0x15418
incl (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xce68
movq %rax, %rbx
testq %rax, %rax
jne 0xbb08
movl $0x2, %edi
movl $0x17, %esi
callq 0xbc50
movl %r14d, (%rbx)
leal 0x4(,%r14,4), %edi
callq 0xce68
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0xbb30
movl $0x2, %edi
movl $0x18, %esi
callq 0xbc50
leaq 0x98e9(%rip), %rax      # 0x15420
incl (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbb5a
leaq 0x3a47(%rip), %rdi      # 0xf59c
callq 0x1060
movl $0x0, 0x9d6c(%rip)      # 0x158d0
cmpl $0x0, (%rbx)
jle 0xbb8c
xorl %eax, %eax
movq 0x8(%rbx), %rcx
cltq
movq (%rcx,%rax,8), %rdi
callq 0xce88
movl 0x9d50(%rip), %eax      # 0x158d0
incl %eax
movl %eax, 0x9d48(%rip)      # 0x158d0
cmpl (%rbx), %eax
jl 0xbb6b
movq 0x8(%rbx), %rdi
callq 0xce88
movq %rbx, %rdi
callq 0xce88
leaq 0x9878(%rip), %rax      # 0x1541c
incl (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbbbe
leaq 0x39e3(%rip), %rdi      # 0xf59c
callq 0x1060
movl $0x0, 0x9d0c(%rip)      # 0x158d4
cmpl $0x0, (%rbx)
jle 0xbbf0
xorl %eax, %eax
movq 0x8(%rbx), %rcx
cltq
movq (%rcx,%rax,8), %rdi
callq 0xce88
movl 0x9cf0(%rip), %eax      # 0x158d4
incl %eax
movl %eax, 0x9ce8(%rip)      # 0x158d4
cmpl (%rbx), %eax
jl 0xbbcf
movq 0x8(%rbx), %rdi
callq 0xce88
movq %rbx, %rdi
callq 0xce88
leaq 0x9814(%rip), %rax      # 0x1541c
incl (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xce68
movq %rax, %rbx
testq %rax, %rax
jne 0xbcda
movl $0x2, %edi
movl $0x15, %esi
callq 0xbc50
movl %r14d, (%rbx)
movl %ebp, 0x4(%rbx)
shll $0x3, %r14d
movq %r14, %rdi
callq 0xce68
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xbd31
movl $0x0, 0x9be9(%rip)      # 0x158e8
cmpl $0x0, (%rbx)
jle 0xbd40
movl 0x4(%rbx), %edi
shll $0x3, %edi
callq 0xce68
movq 0x8(%rbx), %rdx
movslq 0x9bce(%rip), %rcx      # 0x158e8
movq %rax, (%rdx,%rcx,8)
testq %rax, %rax
je 0xbd31
incl %ecx
movl %ecx, 0x9bbd(%rip)      # 0x158e8
cmpl (%rbx), %ecx
jl 0xbd04
jmp 0xbd40
movl $0x2, %edi
movl $0x16, %esi
callq 0xbc50
movl $0x1, 0x10(%rbx)
leaq 0x96ca(%rip), %rax      # 0x15418
incl (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xce68
movq %rax, %r14
testq %rax, %rax
jne 0xbd87
movl $0x2, %edi
movl $0x19, %esi
callq 0xbc50
movl %r15d, (%r14)
leal 0x8(,%r15,8), %edi
callq 0xce68
movq %rax, 0x8(%r14)
testq %rax, %rax
jne 0xbdaf
movl $0x2, %edi
movl $0x1a, %esi
callq 0xbc50
cmpl $0x0, (%r14)
js 0xbdd9
movq $-0x1, %r15
movl %ebp, %edi
movl %ebx, %esi
callq 0xbcb0
movq 0x8(%r14), %rcx
movq %rax, 0x8(%rcx,%r15,8)
movslq (%r14), %rax
incq %r15
cmpq %rax, %r15
jl 0xbdbc
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xce68
movq %rax, %rbx
testq %rax, %rax
jne 0xbe0f
movl $0x2, %edi
movl $0x17, %esi
callq 0xbc50
movl %r14d, (%rbx)
leal 0x8(,%r14,8), %edi
callq 0xce68
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0xbe37
movl $0x2, %edi
movl $0x18, %esi
callq 0xbc50
leaq 0x95e2(%rip), %rax      # 0x15420
incl (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbedb
movq $-0x1, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r14,8), %rdi
callq 0xbe4b
movslq (%rbx), %rax
incq %r14
cmpq %rax, %r14
jl 0xbec2
movq 0x8(%rbx), %rdi
callq 0xce88
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xce88
// File: /workspace/github_c_makefile_star2_O1/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 0xc27e
cmpl $0x1, %esi
je 0xc18c
cmpl $0x2, %esi
jne 0xc2e4
cmpl $0x0, (%rbx)
jle 0xc2e4
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r14,8), %rdi
movl $0x2, %esi
callq 0xbf13
movslq (%rbx), %rax
incq %r14
cmpq %rax, %r14
jl 0xc169
jmp 0xc2e4
movl (%rbx), %eax
testl %eax, %eax
jle 0xc2e4
movq 0x8(%rbx), %rcx
incq %rax
movl $0x1, %edx
movdqa 0x4276(%rip), %xmm0     # 0x10420
movdqa 0x427e(%rip), %xmm1     # 0x10430
movabsq $0x3ff0000000000000, %rsi # imm = 0x3FF0000000000000
pcmpeqd %xmm2, %xmm2
movq (%rcx,%rdx,8), %rdi
movl (%rdi), %r8d
testl %r8d, %r8d
jle 0xc270
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 0xc268
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 0xc24b
movq %rsi, (%rbx,%r14,8)
pxor %xmm2, %xmm4
pextrw $0x4, %xmm4, %ebp
testb $0x1, %bpl
je 0xc25f
movq %rsi, 0x8(%rbx,%r14,8)
addq $0x2, %r14
cmpq %r14, %r10
jne 0xc20b
incq %r11
cmpq %r8, %r11
jne 0xc1fa
incq %rdx
cmpq %rax, %rdx
jne 0xc1c0
jmp 0xc2e4
movl (%rbx), %eax
movq %rax, 0x8(%rsp)
testl %eax, %eax
jle 0xc2e4
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 0xc2da
movl 0x4(%r13), %ebx
movq %rbx, %r15
shlq $0x3, %r15
xorl %r14d, %r14d
testl %ebx, %ebx
jle 0xc2d2
movq 0x8(%r13), %rax
movq (%rax,%r14,8), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x10a0
incq %r14
cmpq %r14, %rbp
jne 0xc2bc
incq %r12
cmpq 0x8(%rsp), %r12
jne 0xc29d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc3aa
cmpl $0x1, %esi
jne 0xc3c1
movslq (%rdi), %rdx
testq %rdx, %rdx
jle 0xc3c1
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 0x40ef(%rip), %xmm1     # 0x10420
movdqa 0x40f7(%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 0xc38b
movq %rsi, (%rax,%rdx,8)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0xc39f
movq %rsi, 0x8(%rax,%rdx,8)
addq $0x2, %rdx
cmpq %rdx, %rcx
jne 0xc34b
jmp 0xc3c1
movslq (%rdi), %rdx
testq %rdx, %rdx
jle 0xc3c1
movq 0x8(%rdi), %rdi
shlq $0x3, %rdx
xorl %esi, %esi
jmp 0x10a0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc46e
movl 0x4(%r14), %ebp
movq %rbp, %rax
shlq $0x3, %rax
movq %rax, (%rsp)
xorl %r12d, %r12d
testl %ebp, %ebp
jle 0xc466
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rdi
xorl %esi, %esi
movq (%rsp), %rdx
callq 0x10a0
incq %r12
cmpq %r12, %r13
jne 0xc44f
movl 0x4(%rbx), %eax
testl %eax, %eax
jle 0xc4ef
movl (%r15), %ecx
leal 0x1(%rcx), %edx
incq %rax
movl $0x1, %esi
testl %ecx, %ecx
jle 0xc4e7
movl 0x4(%r15), %edi
leal 0x1(%rdi), %r8d
decq %r8
movl $0x1, %r9d
testl %edi, %edi
jle 0xc4df
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 0xc4bc
incq %r9
cmpq %rdx, %r9
jne 0xc498
incq %rsi
cmpq %rax, %rsi
jne 0xc483
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_O1/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 0xc557
pushq %rbx
movl (%rsi), %edx
leal 0x1(%rdx), %edi
incq %rcx
decq %rdi
movl $0x1, %r8d
testl %edx, %edx
jle 0xc54e
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 0xc52c
incq %r8
cmpq %rcx, %r8
jne 0xc51d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: scalemat3x3
void scalemat3x3( matrix a, double b )
{ M(a,1,1) *= b;
  M(a,1,2) *= b;
  M(a,1,3) *= b;
  M(a,2,1) *= b;
  M(a,2,2) *= b;
  M(a,2,3) *= b;
  M(a,3,1) *= b;
  M(a,3,2) *= b;
  M(a,3,3) *= b;
}

// Assembly:
movq 0x8(%rdi), %rax
movq (%rax), %rcx
movupd (%rcx), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm2, %xmm1
movupd %xmm1, (%rcx)
movsd 0x10(%rcx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rcx)
movq 0x8(%rax), %rcx
movupd (%rcx), %xmm1
mulpd %xmm2, %xmm1
movupd %xmm1, (%rcx)
movsd 0x10(%rcx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rcx)
movq 0x10(%rax), %rax
movupd (%rax), %xmm1
mulpd %xmm2, %xmm1
movupd %xmm1, (%rax)
mulsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc624
pushq %r15
pushq %r14
pushq %rbx
movl (%rsi), %edi
leal 0x1(%rdi), %r8d
incq %rcx
decq %r8
movl $0x1, %r9d
testl %edi, %edi
jle 0xc617
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 0xc5ee
incq %r9
cmpq %rcx, %r9
jne 0xc5db
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: matsum3x3
void matsum3x3( matrix a, matrix b )
{ M(a,1,1) += M(b,1,1);
  M(a,1,2) += M(b,1,2);
  M(a,1,3) += M(b,1,3);
  M(a,2,1) += M(b,2,1);
  M(a,2,2) += M(b,2,2);
  M(a,2,3) += M(b,2,3);
  M(a,3,1) += M(b,3,1);
  M(a,3,2) += M(b,3,2);
  M(a,3,3) += M(b,3,3);
}

// Assembly:
movq 0x8(%rsi), %rax
movq (%rax), %rcx
movsd (%rcx), %xmm0
movq 0x8(%rdi), %rdx
movq (%rdx), %rsi
addsd (%rsi), %xmm0
movsd %xmm0, (%rsi)
movsd 0x8(%rcx), %xmm0
addsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x8(%rsi)
movsd 0x10(%rcx), %xmm0
addsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rsi)
movq 0x8(%rax), %rcx
movsd (%rcx), %xmm0
movq 0x8(%rdx), %rsi
addsd (%rsi), %xmm0
movsd %xmm0, (%rsi)
movsd 0x8(%rcx), %xmm0
addsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x8(%rsi)
movsd 0x10(%rcx), %xmm0
addsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rsi)
movq 0x10(%rax), %rax
movsd (%rax), %xmm0
movq 0x10(%rdx), %rcx
addsd (%rcx), %xmm0
movsd %xmm0, (%rcx)
movsd 0x8(%rax), %xmm0
addsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rcx)
movsd 0x10(%rax), %xmm0
addsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: transpose3x3
void transpose3x3( matrix m )
{ /* transposes a matrix: */
  double tmp;
  tmp=M(m,1,2); M(m,1,2)=M(m,2,1); M(m,2,1)=tmp;
  tmp=M(m,1,3); M(m,1,3)=M(m,3,1); M(m,3,1)=tmp;
  tmp=M(m,2,3); M(m,2,3)=M(m,3,2); M(m,3,2)=tmp;
}

// Assembly:
movq 0x8(%rdi), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movsd 0x8(%rcx), %xmm0
movsd (%rdx), %xmm1
movsd %xmm1, 0x8(%rcx)
movsd %xmm0, (%rdx)
movsd 0x10(%rcx), %xmm0
movq 0x10(%rax), %rax
movsd (%rax), %xmm1
movsd %xmm1, 0x10(%rcx)
movsd %xmm0, (%rax)
movsd 0x10(%rdx), %xmm0
movsd 0x8(%rax), %xmm1
movsd %xmm1, 0x10(%rdx)
movsd %xmm0, 0x8(%rax)
retq