LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/hyc[P]trek73c/trekx.c
// Function: main
int main(argc, argv)
int argc;
Char *argv[];
{
  int I;

  SysInit();
again:
  TrekInit();
  Radius = 5000;
  TCount = (-1);
  Win = 0;
  Win2 = 0;
  LKnt = 0;
  DrawScr();
  Stop = false;
  Redo = false;
  do {
    TCount++;
    if (TCount > Enemies)
      Execute();
    else if (Objects[TCount] != NULL) {
      I = Objects[TCount]->ObTyp;
      if (I < 10 && Ships[TCount] != NULL) {
	if (Ships[TCount]->Crew != 0) {
	  if (!I)
	    Command();
	  else
	    EStrat();
	}
      }
    }
  } while (!Stop);

  waddstr(Cmdwin,"Computer:  Do you desire another battle");
  if (Yes())
  {
    delwin(Prbwin);
    delwin(Scnwin);
    delwin(Diswin);
    delwin(Cmdwin);
    delwin(Repwin);
    delwin(Radwin);
    for (I = ObjCount; I >= 0; I--)
    {
      if (Objects[I])
      {
	free(Objects[I]);
	Objects[I] = NULL;
      }
    }
    for (I = 0; I<10; I++)
    {
      if (Ships[I])
      {
      	free(Ships[I]);
	Ships[I] = NULL;
      }
    }
    goto again;
  }
  endwin();
  exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x258e
xorl %r14d, %r14d
leaq 0x7b2b(%rip), %r15      # 0x135f0
leaq 0x7ec4(%rip), %r12      # 0x13990
leaq 0x4615(%rip), %rbx      # 0x100e8
callq 0x265f
movl $0x1388, 0x7f46(%rip)   # imm = 0x1388
movl $0xffffffff, 0x7f4c(%rip) # imm = 0xFFFFFFFF
movb %r14b, 0x7af5(%rip)     # 0x135e8
movl %r14d, 0x7f36(%rip)     # 0x13a30
movl %r14d, 0x7f23(%rip)     # 0x13a24
callq 0x38d8
movb %r14b, 0x7f27(%rip)     # 0x13a34
movb %r14b, 0x7f18(%rip)     # 0x13a2c
movslq 0x7f1d(%rip), %rax      # 0x13a38
leal 0x1(%rax), %ecx
movl %ecx, 0x7f14(%rip)      # 0x13a38
movzbl 0x7ab5(%rip), %ecx      # 0x135e0
cmpl %ecx, %eax
jge 0xbb60
movq 0x8(%r15,%rax,8), %rcx
testq %rcx, %rcx
je 0xbb65
movzwl 0x4a(%rcx), %ecx
cmpw $0x9, %cx
jg 0xbb65
movq 0x8(%r12,%rax,8), %rax
testq %rax, %rax
je 0xbb65
cmpw $0x0, 0x1a(%rax)
je 0xbb65
testw %cx, %cx
je 0xbb70
callq 0x6b79
jmp 0xbb65
callq 0x6566
cmpb $0x1, 0x7ec8(%rip)      # 0x13a34
jne 0xbb14
jmp 0xbb77
callq 0xb7d0
jmp 0xbb65
movq 0x7e7a(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x7ad7
testb %al, %al
je 0xbc38
movq 0x7e79(%rip), %rdi      # 0x13a18
callq 0x21c0
movq 0x7e65(%rip), %rdi      # 0x13a10
callq 0x21c0
movq 0x7e51(%rip), %rdi      # 0x13a08
callq 0x21c0
movq 0x7e35(%rip), %rdi      # 0x139f8
callq 0x21c0
movq 0x7e19(%rip), %rdi      # 0x139e8
callq 0x21c0
movq 0x7e15(%rip), %rdi      # 0x139f0
callq 0x21c0
movzbl 0x79fa(%rip), %r13d     # 0x135e2
leaq (%r15,%r13,8), %rbp
incq %r13
movq (%rbp), %rdi
testq %rdi, %rdi
je 0xbc05
callq 0x2130
movq $0x0, (%rbp)
addq $-0x8, %rbp
decq %r13
jg 0xbbef
xorl %r13d, %r13d
movq (%r13,%r12), %rdi
testq %rdi, %rdi
je 0xbc29
callq 0x2130
movq $0x0, (%r13,%r12)
addq $0x8, %r13
cmpq $0x50, %r13
jne 0xbc11
jmp 0xbad3
callq 0x2200
xorl %edi, %edi
callq 0x20d0
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: runtime_error
void runtime_error(const char *name, const char *msg, int ex)
{
	fprintf(stderr,"\n\n*** runtime error spacelib/%s\n",name);
	fprintf(stderr,"%s\n\n",msg);
	if (ex){
		exit(ex);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %rdx
movq 0xb8fa(%rip), %r15      # 0xdff8
movq (%r15), %rdi
leaq 0x7f45(%rip), %rsi      # 0xa64d
xorl %eax, %eax
callq 0x21c0
movq (%r15), %rdi
leaq 0x7f55(%rip), %rsi      # 0xa66e
movq %r14, %rdx
xorl %eax, %eax
callq 0x21c0
testl %ebx, %ebx
jne 0x272d
popq %rbx
popq %r14
popq %r15
retq
movl %ebx, %edi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/LINEAR2.c
// Function: solve
int solve(MAT A, real *b, real *x, int dim)
{
	int solution=1;
	real *H;
	int *ivet;
	int vpr=-1;
	int irank;
	real arm;
	int i,j;

	H = (real *) calloc(dim*(dim+solution),sizeof(real));
	ivet = (int *)  calloc(dim,sizeof(int));

	for(i=0;i<dim;i++)          /* copies matrix A into matrix H */
		for(j=0;j<dim;j++)
			*(H+i*(dim+solution)+j) = *(A+i*dim+j);

	for(i=0;i<dim;i++)	    /* copies right hand vector b into H */
		H[i*(dim+solution)+dim] = b[i];

	linear(H,dim,dim+solution,dim,dim,solution,ivet,&irank,&arm,&vpr);

	for(i=0;i<dim;i++)          /* finds solution x reordering matrix H */
		x[ivet[i]] = H[i*(dim+solution)+dim];

	free(H); free(ivet);

	return irank;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, 0x30(%rsp)
movq %rdi, %r15
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
leal 0x1(%rbp), %eax
movl %eax, 0x4(%rsp)
imull %ecx, %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x2180
movq %rax, %rbx
movslq %ebp, %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x2180
movq %rax, %r12
testl %r14d, %r14d
jle 0x3645
movq %r13, 0x20(%rsp)
movq %r12, 0x28(%rsp)
movl %ebp, %r13d
leaq (,%r13,8), %rax
movq %rax, 0x38(%rsp)
movq %rbx, 0x10(%rsp)
xorl %ebx, %ebx
movq %r13, 0x18(%rsp)
movq %r15, %r12
movq %rbp, %r15
xorl %ebp, %ebp
movl 0x4(%rsp), %r14d
movl %ebp, %eax
leaq (%r12,%rax,8), %rsi
movl %ebx, %eax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,8), %rdi
movq 0x38(%rsp), %rdx
callq 0x2200
addl %r15d, %ebp
addl %r14d, %ebx
decq %r13
jne 0x3578
testl %r15d, %r15d
movq 0x10(%rsp), %rbx
movq 0x28(%rsp), %r12
movq 0x20(%rsp), %r13
movq %r15, %rbp
jle 0x3645
movl 0x4(%rsp), %edx
movl %edx, %r14d
movq 0x18(%rsp), %r15
leaq (%rbx,%r15,8), %rax
leaq (,%r14,8), %rcx
xorl %esi, %esi
movq 0x30(%rsp), %rdi
movsd (%rdi,%rsi,8), %xmm0
movsd %xmm0, (%rax)
incq %rsi
addq %rcx, %rax
cmpq %rsi, %r15
jne 0x35d8
leaq 0xc(%rsp), %rax
leaq 0x40(%rsp), %r10
leaq 0x8(%rsp), %r11
movq %rbx, %rdi
movl %ebp, %esi
movl %ebp, %ecx
movl %ebp, %r8d
movl $0x1, %r9d
pushq %rax
pushq %r10
pushq %r11
pushq %r12
callq 0x21f0
addq $0x20, %rsp
testl %ebp, %ebp
jle 0x3678
leaq (%rbx,%r15,8), %rax
shlq $0x3, %r14
xorl %ecx, %ecx
movsd (%rax), %xmm0
movslq (%r12,%rcx,4), %rdx
movsd %xmm0, (%r13,%rdx,8)
incq %rcx
addq %r14, %rax
cmpq %rcx, %r15
jne 0x3629
jmp 0x3678
leaq 0xc(%rsp), %rax
leaq 0x40(%rsp), %r10
leaq 0x8(%rsp), %r11
movq %rbx, %rdi
movl %ebp, %esi
movl 0x4(%rsp), %edx
movl %ebp, %ecx
movl %ebp, %r8d
movl $0x1, %r9d
pushq %rax
pushq %r10
pushq %r11
pushq %r12
callq 0x21f0
addq $0x20, %rsp
movq %rbx, %rdi
callq 0x2040
movq %r12, %rdi
callq 0x2040
movl 0x8(%rsp), %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI3.c
// Function: rotat24
int rotat24(int a, real q, POINT O, MAT4 m)
{
	if (a<X || a>U)
	{
		fprintf(stderr,"Error (rotat24) : illegal axis\n");
		return(NOTOK);
	}
	if (O[U] != 1)
	{
		fprintf(stderr,"Error (rotat24) : illegal point");
		return(NOTOK);
	}
	rotat2(a, q, M m, 4);

	/* translation and constant parts */
	m[X][U] = O[X]; m[Y][U] = O[Y]; m[Z][U] = O[Z];
	m[U][X] = m[U][Y] = m[U][Z] = 0 ; m[U][U] =  1 ;

	return (OK);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x4, %edi
jae 0x3aa4
movq %rsi, %r14
movsd 0x18(%rsi), %xmm1
ucomisd 0x6682(%rip), %xmm1     # 0xa0c8
jne 0x3aab
jp 0x3aab
movq %rdx, %rbx
movq %rdx, %rsi
movl $0x4, %edx
callq 0x2340
movsd (%r14), %xmm0
movsd %xmm0, 0x18(%rbx)
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x38(%rbx)
movsd 0x10(%r14), %xmm0
movsd %xmm0, 0x58(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x24b4
jmp 0x3ab0
callq 0x2498
xorl %eax, %eax
jmp 0x3a9c
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI3.c
// Function: makeL
int makeL(int jtype, AXIS u, real pitch, POINT P, MAT4 L)
{
	VECTOR v;

	clear4(L);

	if (jtype==Pri)      /* translation only */
	{
		L[X][U]=u[X]; L[Y][U]=u[Y]; /*L[Y][U]=u[X]; bug fixed */
		L[Z][U]=u[Z];
	}
	else if (jtype==Rev) /* revolute or screw */
	{
		L[Y][Z]=-(L[Z][Y]=u[X]);
		L[Z][X]=-(L[X][Z]=u[Y]);
		L[X][Y]=-(L[Y][X]=u[Z]);
		cross(u,P,v);
		L[X][U]=-v[X]+pitch*u[X];
		L[Y][U]=-v[Y]+pitch*u[Y];;
		L[Z][U]=-v[Z]+pitch*u[Z];;
	}
	else
	{
		fprintf(stderr,"Error (makeL) : illegal joint type\n");
		return(NOTOK);
	}

	return(OK);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rsi, %r14
xorpd %xmm1, %xmm1
movupd %xmm1, 0x70(%rcx)
movupd %xmm1, 0x60(%rcx)
movupd %xmm1, 0x50(%rcx)
movupd %xmm1, 0x40(%rcx)
movupd %xmm1, 0x30(%rcx)
movupd %xmm1, 0x20(%rcx)
movupd %xmm1, 0x10(%rcx)
movupd %xmm1, (%rcx)
testl %edi, %edi
je 0x3b20
cmpl $0x1, %edi
jne 0x3bc3
movsd (%r14), %xmm0
movsd %xmm0, 0x18(%rbx)
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x38(%rbx)
movsd 0x10(%r14), %xmm0
movsd %xmm0, 0x58(%rbx)
jmp 0x3bb4
movsd (%r14), %xmm2
movsd %xmm2, 0x48(%rbx)
movsd %xmm0, 0x8(%rsp)
movaps 0x64e9(%rip), %xmm1     # 0xa020
xorps %xmm1, %xmm2
movlps %xmm2, 0x30(%rbx)
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x10(%rbx)
xorps %xmm1, %xmm0
movlps %xmm0, 0x40(%rbx)
movsd 0x10(%r14), %xmm0
movsd %xmm0, 0x20(%rbx)
xorps %xmm1, %xmm0
movlps %xmm0, 0x8(%rbx)
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq 0x2390
movsd (%r14), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
subsd (%r15), %xmm0
movsd %xmm0, 0x18(%rbx)
movsd 0x8(%r14), %xmm0
mulsd %xmm1, %xmm0
subsd 0x8(%r15), %xmm0
movsd %xmm0, 0x38(%rbx)
mulsd 0x10(%r14), %xmm1
subsd 0x10(%r15), %xmm1
movsd %xmm1, 0x58(%rbx)
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x24d0
xorl %eax, %eax
jmp 0x3bb9
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI3.c
// Function: makeL2
int makeL2(int jtype, int a, real pitch, POINT P, MAT4 L)
{
	int x,y,z;

	if (a<X || a>Z)
	{
		fprintf(stderr,"Error (makeL2) : illegal axis\n");
		return(NOTOK);
	}

	clear4(L);

	if (jtype==Pri)      /* translation only */
	{
		L[a][U]=1;
	}
	else if (jtype==Rev) /* revolute or screw */
	{
		x=(a+1) % 3; y=(a+2) % 3; z=a;

		L[y][x]=1; L[x][y]=-1;
		L[x][U] =  P[y];
		L[y][U] = -P[x];
		L[z][U] = pitch;
	}
	else
	{
		fprintf(stderr,"Error (makeL2) : illegal joint type\n");
		return(NOTOK);
	}

	return(OK);
}

// Assembly:
pushq %rax
cmpl $0x2, %esi
ja 0x3cda
xorps %xmm1, %xmm1
movups %xmm1, 0x70(%rcx)
movups %xmm1, 0x60(%rcx)
movups %xmm1, 0x50(%rcx)
movups %xmm1, 0x40(%rcx)
movups %xmm1, 0x30(%rcx)
movups %xmm1, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm1, (%rcx)
testl %edi, %edi
je 0x3c5d
cmpl $0x1, %edi
jne 0x3ce1
movl %esi, %eax
shlq $0x5, %rax
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
movq %rdx, 0x18(%rcx,%rax)
jmp 0x3cd3
leal 0x1(%rsi), %eax
xorl %edi, %edi
cmpl $0x2, %esi
cmovnel %eax, %edi
movl %esi, %eax
subl $0x1, %eax
movl $0x2, %r8d
cmovael %eax, %r8d
movq %r8, %rax
shlq $0x5, %rax
leaq (%rcx,%rax), %r9
movabsq $0x3ff0000000000000, %r10 # imm = 0x3FF0000000000000
movq %r10, (%r9,%rdi,8)
movq %rdi, %r9
shlq $0x5, %r9
leaq (%rcx,%r9), %r10
movabsq $-0x4010000000000000, %r11 # imm = 0xBFF0000000000000
movq %r11, (%r10,%r8,8)
movsd (%rdx,%r8,8), %xmm1
movsd %xmm1, 0x18(%rcx,%r9)
movsd (%rdx,%rdi,8), %xmm1
xorps 0x635e(%rip), %xmm1     # 0xa020
movlps %xmm1, 0x18(%rcx,%rax)
movl %esi, %eax
shlq $0x5, %rax
movsd %xmm0, 0x18(%rcx,%rax)
movl $0x1, %eax
popq %rcx
retq
callq 0x2508
jmp 0x3ce6
callq 0x24ec
xorl %eax, %eax
jmp 0x3cd8
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI3.c
// Function: cardantoH
void cardantoH(real *q,real *qp,real *qpp, int i, int j, int k, POINT O,
	       MAT4 H)
{
	int l,m;

	cardanto_G4(q,qp,qpp,i,j,k,H);
	for(l=X;l<=Z;l++)
	{
		H[l][U]=0;
		/* H[i][U]=0; bug fixed 13/05/97 AmGhiPu */
		for(m=X;m<=Z;m++)
			H[l][U] -= H[l][m]*O[m];
	}
	H[U][X]=H[U][Y]=H[U][Z]=H[U][U]=0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rsp), %rbx
movq 0x20(%rsp), %r14
pushq $0x4
pushq %rbx
callq 0x20f0
addq $0x10, %rsp
xorl %eax, %eax
movq %rbx, %rcx
movq %rax, %rdx
shlq $0x5, %rdx
addq %rbx, %rdx
addq $0x18, %rdx
movq $0x0, (%rdx)
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm1
mulsd (%r14,%rsi,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%rdx)
incq %rsi
cmpq $0x3, %rsi
jne 0x4796
incq %rax
addq $0x20, %rcx
cmpq $0x3, %rax
jne 0x477b
xorpd %xmm0, %xmm0
movupd %xmm0, 0x70(%rbx)
movupd %xmm0, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI3.c
// Function: cardanto_OMEGAPTO
void cardanto_OMEGAPTO(real *q, real *qp, real *qpp, int i, int j, int k,
		       real *omegapto)
{
	real mat[9],mat1[9];
	real wprod[3];
	real buffer[3],buffer1[3];

	cardantol(q,i,j,k,mat,3);
	cardantoWPROD(q,i,j,k,mat1,3);
	wprod[X] = qp[Y]*qp[Z];
	wprod[Y] = qp[X]*qp[Z];
	wprod[Z] = qp[X]*qp[Y];
	molt(mat,qpp,buffer,3,3,1);
	molt(mat1,wprod,buffer1,3,3,1);
	sum(buffer,buffer1,omegapto,3,1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %r9d, %ebp
movl %r8d, %r13d
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x60(%rsp), %r8
movl %ecx, %esi
movl %r13d, %edx
movl %r9d, %ecx
movl $0x3, %r9d
callq 0x2230
leaq 0xb0(%rsp), %r8
movq %r12, %rdi
movl %ebx, %esi
movl %r13d, %edx
movl %ebp, %ecx
movq %r8, %r12
movl $0x3, %r9d
callq 0x2070
movsd (%r15), %xmm0
movupd 0x8(%r15), %xmm1
movapd %xmm1, %xmm2
shufpd $0x1, %xmm0, %xmm2      # xmm2 = xmm2[1],xmm0[0]
mulpd %xmm1, %xmm2
leaq 0x40(%rsp), %rbx
movapd %xmm2, (%rbx)
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rbx)
leaq 0x20(%rsp), %r15
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x3, %ecx
movl $0x3, %r8d
movl $0x1, %r9d
callq 0x20c0
movq %rsp, %r14
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x3, %ecx
movl $0x3, %r8d
movl $0x1, %r9d
callq 0x20c0
movq %r15, %rdi
movq %r14, %rsi
movq 0x130(%rsp), %rdx
movl $0x3, %ecx
movl $0x1, %r8d
callq 0x2210
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI3.c
// Function: frameP
int frameP(POINT P1, POINT P2, POINT P3, int a1, int a2, MAT A, int dim)
{
	AXIS a,b;

	if((a1==a2) || (min(a1,a2)<X) || (max(a1,a2)>Z))
	{
		fprintf(stderr,"Error (frameP) : illegal axis\n");
		return(NOTOK);
	}

	a[X]=P2[X]-P1[X];  a[Y]=P2[Y]-P1[Y]; a[Z]=P2[Z]-P1[Z];
	b[X]=P3[X]-P1[X];  b[Y]=P3[Y]-P1[Y]; b[Z]=P3[Z]-P1[Z];
	frameV(a, b, a1, a2, M A, dim);

/* #undef RR 	Bug fixed 03.04.97 AmGhiPu */

	return(OK);
}

// Assembly:
subq $0x38, %rsp
cmpl %r8d, %ecx
movl %r8d, %eax
cmovll %ecx, %eax
movl %r8d, %r10d
cmovgl %ecx, %r10d
cmpl $0x2, %r10d
jg 0x4d68
cmpl %r8d, %ecx
je 0x4d68
testl %eax, %eax
js 0x4d68
movl 0x40(%rsp), %eax
movupd (%rsi), %xmm0
movupd (%rdi), %xmm1
subpd %xmm1, %xmm0
leaq 0x20(%rsp), %r10
movapd %xmm0, (%r10)
movsd 0x10(%rsi), %xmm0
movsd 0x10(%rdi), %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, 0x10(%r10)
movupd (%rdx), %xmm0
subpd %xmm1, %xmm0
movq %rsp, %rsi
movapd %xmm0, (%rsi)
movsd 0x10(%rdx), %xmm0
subsd %xmm2, %xmm0
movsd %xmm0, 0x10(%rsi)
movq %r10, %rdi
movl %ecx, %edx
movl %r8d, %ecx
movq %r9, %r8
movl %eax, %r9d
callq 0x2260
movl $0x1, %eax
addq $0x38, %rsp
retq
callq 0x2594
xorl %eax, %eax
jmp 0x4d63
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI3.c
// Function: frame4P
void frame4P(POINT P1, POINT P2, POINT P3, int a1, int a2, MAT4 m)
{
	int i;

	frameP(P1,P2,P3, a1,a2, M m,4);
	for(i=X;i<=U;i++)
		m[i][U]=P1[i];
	m[U][X]=m[U][Y]=m[U][Z]=0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rdi, %r14
movl $0x4, (%rsp)
callq 0x2250
xorl %eax, %eax
movsd (%r14,%rax), %xmm0
movsd %xmm0, 0x18(%rbx,%rax,4)
addq $0x8, %rax
cmpq $0x20, %rax
jne 0x4ed7
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI3.c
// Function: dist
real dist(POINT P1, POINT P2)
{
	real d;

	d= (real) sqrt((P1[X]-P2[X])*(P1[X]-P2[X])
	  +(P1[Y]-P2[Y])*(P1[Y]-P2[Y])
	  +(P1[Z]-P2[Z])*(P1[Z]-P2[Z]));

	return d;
}

// Assembly:
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
subsd (%rsi), %xmm0
subsd 0x8(%rsi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%rdi), %xmm1
subsd 0x10(%rsi), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI3.c
// Function: middle
void middle(POINT P1, POINT P2, POINT P)
{
	P[X]=(real) 0.5 * (P1[X]+P2[X]);
	P[Y]=(real) 0.5 * (P1[Y]+P2[Y]);
	P[Z]=(real) 0.5 * (P1[Z]+P2[Z]);
	P[U]=1;
}

// Assembly:
movsd (%rdi), %xmm0
addsd (%rsi), %xmm0
movsd 0x508e(%rip), %xmm1     # 0xa0e8
mulsd %xmm1, %xmm0
movsd %xmm0, (%rdx)
movsd 0x8(%rdi), %xmm0
addsd 0x8(%rsi), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rdx)
movsd 0x10(%rdi), %xmm0
addsd 0x10(%rsi), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rdx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x18(%rdx)
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI3.c
// Function: prmat
void prmat(FILE *grpout, char str[], MAT4 m)
{
	int i,j;
	real rr;

	fprintf(grpout,"\n%s\n",str);

	for(j=0;j<4;j++)
	{
		if (j!=2)
		{
			for(i=0;i<3;i++)
			{
				rr = m[i][j];
				/*if(j==3) rr = rr*100/1.8;*/ /* debug only */
				fprintf(grpout,"%8.3f ",rr);
			}
		}
		fprintf(grpout,"\n");
	}
	fprintf(grpout,"\n\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x5137(%rip), %rsi      # 0xa280
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x21c0
leaq 0x512b(%rip), %r15      # 0xa285
cmpq $0x2, %r12
je 0x5181
movq $-0x60, %r13
movsd 0x60(%r14,%r13), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x21c0
addq $0x20, %r13
jne 0x5167
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2150
incq %r12
addq $0x8, %r14
cmpq $0x4, %r12
jne 0x515a
leaq 0x54ce(%rip), %rdi      # 0xa670
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x23c0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI4.c
// Function: rotat34
void rotat34(int a, real q, POINT P, MAT4 m)
{
	MAT3 R;
	POINT O;

	rotat24(a,q,P,m);
	mmcopy(M m,M R,4,3,3,3);
	moltmv3(M R,P,O);
	vmcopy(M O,3,4,Col,M m,4,4);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %rbx
movq %rsi, %r14
callq 0x22f0
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl $0x4, %edx
movl $0x3, %ecx
movl $0x3, %r8d
movl $0x3, %r9d
callq 0x21a0
movq %rsp, %rdx
movq %r15, %rdi
movq %r14, %rsi
movl $0x3, %ecx
movl $0x3, %r8d
movl $0x1, %r9d
callq 0x20c0
xorl %eax, %eax
movsd (%rsp,%rax), %xmm0
movsd %xmm0, 0x18(%rbx,%rax,4)
addq $0x8, %rax
cmpq $0x18, %rax
jne 0x521b
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI4.c
// Function: Mtocardan
int Mtocardan(MAT4 m, int i, int j, int k, real q1[3], real q2[3])
{
	MAT3 R;

	if (i<X || i>Z || j<X || j>Z || k<X || k>Z || i==j || j==k)
	{
		fprintf(stderr,"Error (Mtocardan) : illegal axis\n");
		return(NOTOK);
	}
	mcopy43(m,R);
	rtocardan3(R,i,j,k,q1,q2);
					/* sing. config. */
	if ( ((i!=k) && ((cos(q1[1])==0) || (cos(q2[1])==0))) ||
	     ((i==k) && ((sin(q1[1])==0) || (sin(q2[1])==0))) )
	{
		fprintf(stderr,"Error (Mtocardan) : there is a singularity\n");
		return(NOTOK);
	}
	else
		return(OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpl %ecx, %edx
je 0x5653
movl %edx, %r12d
movl %esi, %r15d
cmpl %edx, %esi
je 0x5653
cmpl $0x2, %r15d
ja 0x5653
cmpl $0x2, %r12d
ja 0x5653
movl %ecx, %ebp
cmpl $0x3, %ecx
jae 0x5653
movq %r9, %rbx
movq %r8, %r14
leaq 0x10(%rsp), %r13
movq %r13, %rsi
movl $0x4, %edx
movl $0x3, %ecx
movl $0x3, %r8d
movl $0x3, %r9d
callq 0x21a0
movq %rbx, (%rsp)
movq %r13, %rdi
movl $0x3, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
movq %r14, %r9
callq 0x22d0
movsd 0x8(%r14), %xmm0
cmpl %ebp, %r15d
jne 0x5611
callq 0x2370
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5605
jnp 0x564c
movsd 0x8(%rbx), %xmm0
callq 0x2370
jmp 0x562c
callq 0x2140
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5622
jnp 0x564c
movsd 0x8(%rbx), %xmm0
callq 0x2140
movl $0x1, %eax
ucomisd 0x4c57(%rip), %xmm0     # 0xa290
jne 0x563d
jnp 0x564c
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x25e8
jmp 0x5658
callq 0x260a
xorl %eax, %eax
jmp 0x563d
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI4.c
// Function: WPRODtocardan
void WPRODtocardan(real alpha, real beta, int sig, int i, int j, int k,
		   MAT3 Atil)
{
	int l;
	real sa,ca,sb,cb;     /* sine and cosine of two Euler/Cardan angles */

	sa = (real) sin(alpha); ca = (real) cos(alpha);
	sb = (real) sin(beta);  cb = (real) cos(beta);

	if (i!=k)	      /* Cardan convention */
	{
		Atil[X][i]=sig*cb;    Atil[X][j]=0.;
		Atil[Y][i]=sig*sa*sb; Atil[Y][j]=(-sig)*ca*cb;
		Atil[Z][i]=-ca*sb;    Atil[Z][j]=-sa*cb;

		Atil[X][k]=0.;
		Atil[Y][k]=-sa;
		Atil[Z][k]=sig*ca;
	}
	else		      /* Euler convention */
	{
		l=3-i-j;
		Atil[X][i]=-sb;          Atil[X][j]=0.;
		Atil[Y][i]=sa*cb;        Atil[Y][j]=ca*sb;
		Atil[Z][i]=(-sig)*ca*cb; Atil[Z][j]=sig*sa*sb;

		Atil[X][l]=0.;
		Atil[Y][l]=-sa;
		Atil[Z][l]=sig*ca;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movl %edi, %ebp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
callq 0x2370
movaps %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2140
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2370
movaps %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2140
cmpl %r14d, %r12d
jne 0x5e42
movl $0x3, %eax
subl %r12d, %eax
subl %r15d, %eax
movapd 0x426b(%rip), %xmm1     # 0xa020
movapd 0x20(%rsp), %xmm6
movapd %xmm6, %xmm2
xorpd %xmm1, %xmm2
movslq %r12d, %rcx
movlpd %xmm2, (%rbx,%rcx,8)
movslq %r15d, %rdx
xorl %esi, %esi
movq %rsi, (%rbx,%rdx,8)
movapd 0x30(%rsp), %xmm5
movapd %xmm5, %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, 0x18(%rbx,%rcx,8)
movapd 0x10(%rsp), %xmm4
movapd %xmm4, %xmm2
mulsd %xmm6, %xmm2
movsd %xmm2, 0x18(%rbx,%rdx,8)
xorps %xmm2, %xmm2
cvtsi2sd %ebp, %xmm2
negl %ebp
cvtsi2sd %ebp, %xmm3
mulsd %xmm4, %xmm3
mulsd %xmm0, %xmm3
movsd %xmm3, 0x30(%rbx,%rcx,8)
movapd %xmm5, %xmm0
mulsd %xmm2, %xmm0
mulsd %xmm6, %xmm0
movsd %xmm0, 0x30(%rbx,%rdx,8)
cltq
movq %rsi, (%rbx,%rax,8)
xorpd %xmm5, %xmm1
movlpd %xmm1, 0x18(%rbx,%rax,8)
mulsd %xmm2, %xmm4
jmp 0x5ed6
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
movapd %xmm0, %xmm2
mulsd %xmm1, %xmm2
movslq %r12d, %rax
movsd %xmm2, (%rbx,%rax,8)
movslq %r15d, %rcx
xorl %edx, %edx
movq %rdx, (%rbx,%rcx,8)
movapd 0x30(%rsp), %xmm5
movapd %xmm5, %xmm2
mulsd %xmm1, %xmm2
movapd 0x20(%rsp), %xmm6
mulsd %xmm6, %xmm2
movsd %xmm2, 0x18(%rbx,%rax,8)
negl %ebp
xorps %xmm2, %xmm2
cvtsi2sd %ebp, %xmm2
movapd 0x10(%rsp), %xmm4
mulsd %xmm4, %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, 0x18(%rbx,%rcx,8)
movapd 0x417b(%rip), %xmm2     # 0xa020
movapd %xmm4, %xmm3
xorpd %xmm2, %xmm3
mulsd %xmm6, %xmm3
movsd %xmm3, 0x30(%rbx,%rax,8)
xorpd %xmm5, %xmm2
mulsd %xmm2, %xmm0
movsd %xmm0, 0x30(%rbx,%rcx,8)
movslq %r14d, %rax
movq %rdx, (%rbx,%rax,8)
movlpd %xmm2, 0x18(%rbx,%rax,8)
mulsd %xmm1, %xmm4
movsd %xmm4, 0x30(%rbx,%rax,8)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI4.c
// Function: intermediate
void intermediate(POINT P1, real a, POINT P2, real b, POINT P3)
{
	int i;
	real c;

	c=a+b;
	if (c==0)
	{
		fprintf(stderr,"Error (intermediate) : c==0\n");
		/*c=sqrt(a*a+b*b);
		if (c==0)*/                                         /* by dino 2005 */
			c=1.;             /* if c==0 it is assumed c = 1 */
	}
	for (i=X;i<=Z;i++)
		P3[i]=(P1[i]*a+P2[i]*b)/c;
	P3[U]=1.;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movapd %xmm0, %xmm4
addsd %xmm1, %xmm4
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm4
jne 0x5f0f
jnp 0x5f53
xorl %eax, %eax
movsd (%r14,%rax,8), %xmm3
mulsd %xmm1, %xmm3
movsd (%r15,%rax,8), %xmm2
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
divsd %xmm4, %xmm2
movsd %xmm2, (%rbx,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x5f11
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
callq 0x2696
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x4152(%rip), %xmm4     # 0xa0c8
jmp 0x5f0f
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI4.c
// Function: projponl
real projponl(POINT P1, LINE l, POINT I)
{
	real r;
	PLANE pl;            /* plane trough P1 and orthogonal to line l */

	plane2(P1,l.dir,pl); /* builds plane pl */
	r=project(l.P,pl,I); /* finds I */
	r=dist( P1, I);      /* this line was added by Br1 */
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x60(%rsp), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x2110
movq %r14, %rdi
movq %r15, %rsi
callq 0x2030
xorps 0x4003(%rip), %xmm0     # 0xa020
movlps %xmm0, 0x18(%r15)
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2190
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2280
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI4.c
// Function: dot2
real dot2(real *v1, real *v2, int dim)
{
	int i;
	real aux;

	for (i=0,aux=0;i<dim;i++)
		aux += v1[i]*v2[i];
	return(aux);
}

// Assembly:
testl %edx, %edx
jle 0x6131
movl %edx, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm1
mulsd (%rsi,%rcx,8), %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x611a
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI4.c
// Function: plane
void plane(POINT P1, POINT P2, POINT P3, PLANE pl)
{
	VECTOR v12,v32;

	vect(P1,P2,v12); vect(P3,P2,v32);
	cross(v12,v32,pl); unitv(pl,pl);
	pl[U]=-dot(P2,pl);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x20(%rsp), %r12
movq %r12, %rdx
callq 0x2430
movq %rsp, %r13
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2430
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2390
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x2110
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2030
xorps 0x3e8c(%rip), %xmm0     # 0xa020
movlps %xmm0, 0x18(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI4.c
// Function: inters2pl
int inters2pl(PLANE pl1, PLANE pl2, LINEP l)
{
	real zero,d;
	real alpha,beta;
	VECTOR par;
	int i;

	zero=zerom();        /* machine precision */
	cross(pl1,pl2,par);
			     /* planes are not parallel */
	if (aabs(par[X]) > zero || aabs(par[Y]) > zero || aabs(par[Z]) > zero)
	{
		l->dir[X]=par[X]; l->dir[Y]=par[Y]; l->dir[Z]=par[Z];
		d=dot(pl1,pl2);
		alpha=(-pl1[U]+d*pl2[U])/(1-pow(d,2));
		beta=(d*pl1[U]-pl2[U])/(1-pow(d,2));
		for (i=X;i<U;i++)
			l->P[i]=alpha*pl1[i]+beta*pl2[i];
		l->P[U]=1;
		return (OK);
	}
	else                 /* planes are parallel */
		return(NOTOK);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2360
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2390
movsd 0x8(%rsp), %xmm3
movapd (%r12), %xmm0
movapd 0x3e34(%rip), %xmm1     # 0xa020
xorpd %xmm0, %xmm1
movapd %xmm0, %xmm2
maxsd %xmm1, %xmm2
ucomisd %xmm3, %xmm2
ja 0x623e
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
movapd 0x3e12(%rip), %xmm2     # 0xa020
xorpd %xmm1, %xmm2
maxsd %xmm2, %xmm1
ucomisd %xmm3, %xmm1
ja 0x623e
movsd 0x20(%rsp), %xmm1
movapd 0x3df6(%rip), %xmm2     # 0xa020
xorpd %xmm1, %xmm2
maxsd %xmm2, %xmm1
xorl %eax, %eax
ucomisd %xmm3, %xmm1
jbe 0x62d0
movupd %xmm0, 0x20(%rbx)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2030
movsd 0x18(%r15), %xmm2
movsd 0x18(%r14), %xmm3
movapd %xmm0, %xmm1
mulsd %xmm3, %xmm1
subsd %xmm2, %xmm1
movapd %xmm0, %xmm4
mulsd %xmm0, %xmm4
movsd 0x3e47(%rip), %xmm5     # 0xa0c8
subsd %xmm4, %xmm5
divsd %xmm5, %xmm1
mulsd %xmm2, %xmm0
subsd %xmm3, %xmm0
divsd %xmm5, %xmm0
xorl %eax, %eax
movsd (%r14,%rax,8), %xmm2
mulsd %xmm0, %xmm2
movsd (%r15,%rax,8), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, (%rbx,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x6297
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x18(%rbx)
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI4.c
// Function: interslpl
void interslpl(LINE l, PLANE pl, POINT I, int *inttype)
{
	real par,lie,zero,alpha;
	VECTOR v;

	zero=zerom();
	par=dot(pl,l.dir);
	lie=dot2(pl,l.P,4);
	if(fabs(par)<zero)	             /* l is parallel to pl */ /* fabs() bug fixed Jan 2003 */
	{
		if(lie<zero)         /* pl passes through l.P */
			*inttype=1;  /* the intersection is the line itself */
		else		     /* pl does not pass through point l.P  */
			*inttype=-1; /* no intersection */
	}
	else			     /* line and plane are incident */
	{
		*inttype=0;	     /* there is only one intersection */
		alpha=(-lie) / par;
		vector(l.dir,alpha,v);
		sumv(v,l.P,I);       /* I=alpha*l.dir+l.P */
		I[U]=1.;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x60(%rsp), %r14
callq 0x2360
movsd %xmm0, 0x8(%rsp)
leaq 0x80(%rsp), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x2030
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd (%r13,%rax,8), %xmm2
mulsd (%r14,%rax,8), %xmm2
addsd %xmm2, %xmm0
incq %rax
cmpq $0x4, %rax
jne 0x631f
movapd 0x3f6f(%rip), %xmm2     # 0xa2b0
andpd %xmm1, %xmm2
movsd 0x8(%rsp), %xmm3
ucomisd %xmm2, %xmm3
jbe 0x6360
ucomisd %xmm0, %xmm3
jbe 0x63ac
movl $0x1, (%r15)
jmp 0x63b3
movl $0x0, (%r15)
xorpd 0x3cb1(%rip), %xmm0     # 0xa020
divsd %xmm1, %xmm0
leaq 0x10(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x2220
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x3, %ecx
movl $0x1, %r8d
callq 0x2210
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x18(%rbx)
jmp 0x63b3
movl $0xffffffff, (%r15)     # imm = 0xFFFFFFFF
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI5.c
// Function: axis
void axis(int a, AXIS A)

{
	switch(a)
	  {
      case X:
		   A[X]=1.;
		   A[Y]=0.;
		   A[Z]=0.;
		  break;
      case Y:
		   A[X]=0.;
		   A[Y]=1.;
		   A[Z]=0.;
		  break;
	  case Z:
		   A[X]=0.;
		   A[Y]=0.;
		   A[Z]=1.;
		  break;
	  default:
	       A[X]=0.;
		   A[Y]=0.;
		   A[Z]=0.;
		   fprintf(stderr,"Error (axis): (%d) illegal axis number.\n",a);
		  break;

	  }

}

// Assembly:
cmpl $0x2, %edi
je 0x6fc2
movl %edi, %edx
cmpl $0x1, %edi
je 0x6fd7
testl %edx, %edx
jne 0x6fed
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsi)
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x10(%rsi)
retq
xorps %xmm0, %xmm0
movhps 0x30e7(%rip), %xmm0     # xmm0 = xmm0[0,1],mem[0,1]
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq 0x6ff6(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x341c(%rip), %rsi      # 0xa428
xorl %eax, %eax
jmp 0x21c0
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELI5.c
// Function: traslat
void traslat(AXIS u, real h, MAT4 m)

{
	  unitv(u,u);

      m[X][X]=1.;m[Y][Y]=1.;m[Z][Z]=1.;m[U][U]=1.;
	  m[X][Y]=0.;m[X][Z]=0.;m[Y][X]=0.;m[Y][Z]=0.;
	  m[Z][X]=0.;m[Z][Y]=0.;m[U][X]=0.;m[U][Y]=0.;
	  m[U][Z]=0.;
      m[X][U]=u[X]*h;
	  m[Y][U]=u[Y]*h;
	  m[Z][U]=u[Z]*h;

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movsd %xmm0, (%rsp)
movq %rdi, %r14
movq %rdi, %rsi
callq 0x2110
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rbx)
movq %rax, 0x50(%rbx)
movq %rax, 0x78(%rbx)
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movhps 0x307c(%rip), %xmm1     # xmm1 = xmm1[0,1],mem[0,1]
movups %xmm1, 0x20(%rbx)
xorl %eax, %eax
movq %rax, 0x30(%rbx)
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x60(%rbx)
movq %rax, 0x70(%rbx)
movsd (%r14), %xmm0
movsd (%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rbx)
movsd 0x8(%r14), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rbx)
mulsd 0x10(%r14), %xmm1
movsd %xmm1, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: dhtom
int dhtom(int jtype, real theta, real d, real b, real a, real alpha, real q,
	  MAT4 m)
{
	real ca,sa,ct,st;

	if (jtype==Pri)                        /* Prismatic joint */
		d+=q;
	else                                   /* Revolute joint */
	{
		if (jtype!=Rev)
		{
			fprintf(stderr,"Error (dhtom) : illegal joint type\n");
			return (NOTOK);
		}
		theta += q;
	}

	ca=(real) cos(alpha);  sa=(real)sin(alpha);
	ct=(real) cos(theta); st=(real)sin(theta);

	m[X][X] = ct;      m[X][Y] = -st*ca;  m[X][Z] = st*sa;
	m[Y][X] = st;      m[Y][Y] = ct*ca;   m[Y][Z] = -ct*sa;
	m[Z][X] =(real)0.; m[Z][Y] = sa;      m[Z][Z] = ca;
	m[U][X] =(real)0.; m[U][Y] =(real)0.; m[U][Z] = (real)0.;

	m[X][U] = a*ct-b*st;
	m[Y][U] = a*st+b*ct;
	m[Z][U] = d;
	m[U][U] =(real)1.;

	return (OK);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
testl %edi, %edi
movsd %xmm3, 0x28(%rsp)
movsd %xmm2, 0x20(%rsp)
je 0x71b2
cmpl $0x1, %edi
jne 0x72c5
addsd %xmm5, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
jmp 0x71c1
addsd %xmm5, %xmm0
movsd %xmm0, (%rsp)
movsd %xmm1, 0x8(%rsp)
movaps %xmm4, %xmm0
movsd %xmm4, 0x10(%rsp)
callq 0x2140
movaps %xmm0, 0x40(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2370
movaps %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
callq 0x2140
movaps %xmm0, 0x30(%rsp)
movsd (%rsp), %xmm0
callq 0x2370
movapd 0x30(%rsp), %xmm4
movsd %xmm4, (%rbx)
movapd 0x2e11(%rip), %xmm1     # 0xa020
movapd %xmm0, %xmm2
xorpd %xmm1, %xmm2
movapd 0x40(%rsp), %xmm5
movapd %xmm5, %xmm3
movapd 0x10(%rsp), %xmm6
unpcklpd %xmm6, %xmm3            # xmm3 = xmm3[0],xmm6[0]
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm3, %xmm2
movupd %xmm2, 0x8(%rbx)
movsd %xmm0, 0x20(%rbx)
xorpd %xmm4, %xmm1
movapd %xmm4, %xmm2
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
mulpd %xmm3, %xmm2
movupd %xmm2, 0x28(%rbx)
xorl %eax, %eax
movq %rax, 0x40(%rbx)
movsd %xmm6, 0x48(%rbx)
movsd %xmm5, 0x50(%rbx)
movsd 0x28(%rsp), %xmm2
movapd %xmm2, %xmm1
mulsd %xmm0, %xmm2
movsd 0x20(%rsp), %xmm3
mulsd %xmm3, %xmm0
mulsd %xmm4, %xmm1
subsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
movupd %xmm0, 0x60(%rbx)
movq %rax, 0x70(%rbx)
movsd %xmm1, 0x18(%rbx)
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm2
movsd %xmm2, 0x38(%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x58(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rbx)
movl $0x1, %eax
addq $0x50, %rsp
popq %rbx
retq
callq 0x2734
xorl %eax, %eax
jmp 0x72bf
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: WtoL
void WtoL(MAT4 W, MAT4 L)
{
	VECTOR u;
	real m,tol;

	tol=zerom();
	mtov(M W, 4, u);
	m=mod(u);
	if (m<tol)
		m = (real) sqrt(W[X][U]*W[X][U] +W[Y][U]*W[Y][U] +
				W[Z][U]*W[Z][U]);
	if (m<tol)
		clear4(L);
	else
		rmolt4(W,(real)1./m,L);
}

// Assembly:
movsd 0x60be(%rip), %xmm0     # 0xe230
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
ja 0x81b0
movsd 0x1f44(%rip), %xmm1     # 0xa0c8
movsd 0x1f5c(%rip), %xmm2     # 0xa0e8
movapd %xmm1, %xmm0
mulsd %xmm2, %xmm0
movapd %xmm0, %xmm3
addsd %xmm1, %xmm3
ucomisd %xmm1, %xmm3
jne 0x8190
jp 0x8190
addsd %xmm0, %xmm0
movsd %xmm0, 0x6080(%rip)     # 0xe230
movsd 0x48(%rdi), %xmm1
subsd 0x30(%rdi), %xmm1
movsd 0x1f26(%rip), %xmm2     # 0xa0e8
mulsd %xmm2, %xmm1
movsd 0x10(%rdi), %xmm3
movsd 0x20(%rdi), %xmm4
subsd 0x40(%rdi), %xmm3
mulsd %xmm2, %xmm3
subsd 0x8(%rdi), %xmm4
mulsd %xmm2, %xmm4
mulsd %xmm3, %xmm3
mulsd %xmm1, %xmm1
addsd %xmm3, %xmm1
mulsd %xmm4, %xmm4
addsd %xmm1, %xmm4
xorps %xmm1, %xmm1
sqrtsd %xmm4, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x822d
movsd 0x18(%rdi), %xmm1
movsd 0x38(%rdi), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
movsd 0x58(%rdi), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
xorps %xmm1, %xmm1
sqrtsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x8245
movq %rsi, %rdi
movl $0x4, %esi
movl $0x4, %edx
jmp 0x2400
movsd 0x1e7b(%rip), %xmm0     # 0xa0c8
divsd %xmm1, %xmm0
xorl %eax, %eax
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%rcx,8)
incq %rcx
cmpq $0x4, %rcx
jne 0x8255
incq %rax
addq $0x20, %rsi
addq $0x20, %rdi
cmpq $0x4, %rax
jne 0x8253
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: velacctoWH
int velacctoWH(int jtype, real qp, real qpp, MAT4 W, MAT4 H)
{
	clear4(W); clear4(H);
	if (jtype==Pri)                        /* Prismatic joint */
	{
		W[Z][U]=qp;
		H[Z][U]=qpp;
	}
	else                                   /* Revolute joint */
	{
		if (jtype!=Rev)
		{
			fprintf(stderr,"Error (velacctoWH) : illegal joint type\n");
			return (NOTOK);
		}
		W[X][Y]= -(W[Y][X]=qp);
		H[X][X]=H[Y][Y]= -qp*qp;
		H[X][Y]= -(H[Y][X]=qpp);
	}
	return(OK);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl %edi, %ebp
movq %rsi, %rdi
movl $0x4, %esi
movl $0x4, %edx
callq 0x2400
movq %rbx, %rdi
movl $0x4, %esi
movl $0x4, %edx
callq 0x2400
testl %ebp, %ebp
je 0x83d9
movapd (%rsp), %xmm1
movapd 0x10(%rsp), %xmm0
cmpl $0x1, %ebp
jne 0x8429
movsd %xmm1, 0x58(%r14)
movsd %xmm0, 0x58(%rbx)
jmp 0x841b
movapd (%rsp), %xmm2
movsd %xmm2, 0x20(%r14)
movapd 0x1c34(%rip), %xmm0     # 0xa020
movapd %xmm2, %xmm1
xorpd %xmm0, %xmm1
movlpd %xmm1, 0x8(%r14)
mulsd %xmm2, %xmm1
movsd %xmm1, 0x28(%rbx)
movsd %xmm1, (%rbx)
movapd 0x10(%rsp), %xmm1
movsd %xmm1, 0x20(%rbx)
xorpd %xmm0, %xmm1
movlpd %xmm1, 0x8(%rbx)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2750
xorl %eax, %eax
jmp 0x8420
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: velacctoWH2
int velacctoWH2(int jtype, int a, real qp, real qpp, MAT4 W, MAT4 H)
{
	int x, y, z;

	if (a<X || a>Z)
	{
		fprintf(stderr,"Error (velacctoWH2) : illegal axis");
		return (NOTOK);
	}
	if (jtype != Rev && jtype != Pri)
	{
		fprintf(stderr,"Error (velacctoWH2) : illegal joint type");
		return (NOTOK);
	}

	x=(a+1) % 3; y=(a+2) % 3; z=a;

	clear4(W);  clear4(H);

	if (jtype == Pri)                      /* Prismatic joint */
	{
		W[z][U] = qp;                  /* W[a][U] = qp;  ric 4.11.93*/
		H[z][U] = qpp;                 /* H[a][U] = qpp; ric 4.11.93*/
	}
	else                                   /* Revolute joint */
	{
		W[x][y] = -(W[y][x] = qp);
		H[x][y] = -(H[y][x] = qpp); H[x][x] = H[y][y] = -qp*qp;
	}
	return(OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x3, %esi
jae 0x8534
movl %edi, %ebp
cmpl $0x2, %edi
jae 0x853b
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movapd %xmm1, (%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rdx, %rdi
movl $0x4, %esi
movl $0x4, %edx
callq 0x2400
movq %rbx, %rdi
movl $0x4, %esi
movl $0x4, %edx
callq 0x2400
cmpl $0x1, %ebp
jne 0x84ac
movl %r15d, %eax
shlq $0x5, %rax
movaps 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%r14,%rax)
movapd (%rsp), %xmm0
movsd %xmm0, 0x18(%rbx,%rax)
jmp 0x8524
movl %r15d, %ecx
subl $0x1, %ecx
movl $0x2, %eax
cmovael %ecx, %eax
leal 0x1(%r15), %ecx
xorl %edx, %edx
cmpl $0x2, %r15d
cmovnel %ecx, %edx
movq %rax, %rcx
shlq $0x5, %rcx
leaq (%r14,%rcx), %rsi
movapd 0x10(%rsp), %xmm2
movsd %xmm2, (%rsi,%rdx,8)
movapd 0x1b3b(%rip), %xmm0     # 0xa020
movapd %xmm2, %xmm1
xorpd %xmm0, %xmm1
movq %rdx, %rsi
shlq $0x5, %rsi
addq %rsi, %r14
movlpd %xmm1, (%r14,%rax,8)
addq %rbx, %rcx
movapd (%rsp), %xmm3
movsd %xmm3, (%rcx,%rdx,8)
xorpd %xmm0, %xmm3
addq %rbx, %rsi
movlpd %xmm3, (%rsi,%rax,8)
mulsd %xmm2, %xmm1
movsd %xmm1, (%rcx,%rax,8)
movsd %xmm1, (%rsi,%rdx,8)
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2788
jmp 0x8540
callq 0x276c
xorl %eax, %eax
jmp 0x8529
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: jtoJ
void jtoJ(real mass, real jxx, real jyy, real jzz, real jxy, real jyz,
	  real jxz, real xg, real yg, real zg, MAT4 J)
{
	J[X][X]=(-jxx+jyy+jzz)/2+mass*xg*xg;
	J[Y][Y]=( jxx-jyy+jzz)/2+mass*yg*yg;
	J[Z][Z]=( jxx+jyy-jzz)/2+mass*zg*zg;

	J[X][Y]=J[Y][X]= -jxy+mass*xg*yg;
	J[X][Z]=J[Z][X]= -jxz+mass*xg*zg;
	J[Y][Z]=J[Z][Y]= -jyz+mass*yg*zg;

	J[U][U]=mass;
	J[U][X]=J[X][U]=mass*xg;
	J[U][Y]=J[Y][U]=mass*yg;
	J[U][Z]=J[Z][U]=mass*zg;
}

// Assembly:
movsd 0x10(%rsp), %xmm10
movsd 0x8(%rsp), %xmm13
movapd %xmm2, %xmm12
subsd %xmm1, %xmm12
addsd %xmm3, %xmm12
movsd 0x1b18(%rip), %xmm14    # 0xa0e8
mulsd %xmm14, %xmm12
movapd %xmm0, %xmm8
mulsd %xmm7, %xmm8
movapd %xmm1, %xmm11
subsd %xmm2, %xmm11
addsd %xmm3, %xmm11
mulsd %xmm14, %xmm11
movapd %xmm0, %xmm9
mulsd %xmm13, %xmm9
addsd %xmm2, %xmm1
subsd %xmm3, %xmm1
mulsd %xmm14, %xmm1
movapd %xmm0, %xmm2
mulsd %xmm10, %xmm2
movapd %xmm2, %xmm3
mulsd %xmm10, %xmm3
addsd %xmm1, %xmm3
movsd %xmm3, 0x50(%rdi)
movapd 0x19f3(%rip), %xmm1     # 0xa020
xorpd %xmm1, %xmm4
unpcklpd %xmm4, %xmm12           # xmm12 = xmm12[0],xmm4[0]
movapd %xmm8, %xmm3
unpcklpd %xmm8, %xmm3            # xmm3 = xmm3[0],xmm8[0]
unpcklpd %xmm13, %xmm7           # xmm7 = xmm7[0],xmm13[0]
mulpd %xmm3, %xmm7
addpd %xmm12, %xmm7
movhpd %xmm7, 0x20(%rdi)
movupd %xmm7, (%rdi)
mulsd %xmm8, %xmm10
subsd %xmm6, %xmm10
movsd %xmm10, 0x40(%rdi)
movsd %xmm10, 0x10(%rdi)
xorpd %xmm1, %xmm5
unpcklpd %xmm5, %xmm11           # xmm11 = xmm11[0],xmm5[0]
movapd %xmm9, %xmm1
unpcklpd %xmm9, %xmm1            # xmm1 = xmm1[0],xmm9[0]
mulpd 0x8(%rsp), %xmm1
addpd %xmm11, %xmm1
movhpd %xmm1, 0x48(%rdi)
movupd %xmm1, 0x28(%rdi)
movsd %xmm0, 0x78(%rdi)
movsd %xmm8, 0x18(%rdi)
movsd %xmm8, 0x60(%rdi)
movsd %xmm9, 0x38(%rdi)
movsd %xmm9, 0x68(%rdi)
movsd %xmm2, 0x58(%rdi)
movsd %xmm2, 0x70(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: trasf_mami
void trasf_mami(MAT4 A1, MAT4 m, MAT4 A2)
{
	int i,j,h,k;
	real t;

	for (i=0;i<3;i++)             /* 3×3 sub matrix */
		for (j=0;j<3;j++)
		{
			t=0.;
			for (h=0;h<3;h++)
				for (k=0;k<3;k++)
					t += m[i][h]*A1[h][k]*m[j][k];
			A2[i][j]=(real)t;
		}
	for (i=0;i<3;i++)             /* elements 1,2,3 of last column */
	{
		for (t=0.,j=0;j<3;j++)
			t += -A2[i][j]*m[j][U] +m[i][j]*A1[j][U];
		A2[i][U] =(real) t+ m[i][U]*A1[U][U];
	}

	A2[U][X]=A2[U][Y]=A2[U][Z]=(real)0.; A2[U][U]=A1[U][U]; /* last row */
}

// Assembly:
pushq %r14
pushq %rbx
xorl %eax, %eax
movq %rax, %rcx
shlq $0x5, %rcx
leaq (%rsi,%rcx), %r8
addq %rdx, %rcx
movq %rsi, %r9
xorl %r10d, %r10d
xorpd %xmm0, %xmm0
movq %rdi, %r11
xorl %ebx, %ebx
movsd (%r8,%rbx,8), %xmm1
xorl %r14d, %r14d
movsd (%r11,%r14,8), %xmm2
mulsd %xmm1, %xmm2
mulsd (%r9,%r14,8), %xmm2
addsd %xmm2, %xmm0
incq %r14
cmpq $0x3, %r14
jne 0x8b11
incq %rbx
addq $0x20, %r11
cmpq $0x3, %rbx
jne 0x8b08
movsd %xmm0, (%rcx,%r10,8)
incq %r10
addq $0x20, %r9
cmpq $0x3, %r10
jne 0x8aff
incq %rax
cmpq $0x3, %rax
jne 0x8aeb
xorl %eax, %eax
movq %rdx, %rcx
movq %rsi, %r8
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
movsd (%rcx,%r9), %xmm1
movsd (%r8,%r9), %xmm2
mulsd 0x18(%rdi,%r9,4), %xmm2
mulsd 0x18(%rsi,%r9,4), %xmm1
subsd %xmm1, %xmm2
addsd %xmm2, %xmm0
addq $0x8, %r9
cmpq $0x18, %r9
jne 0x8b66
movq %rax, %r9
shlq $0x5, %r9
movsd 0x18(%rsi,%r9), %xmm1
mulsd 0x78(%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rdx,%r9)
incq %rax
addq $0x20, %r8
addq $0x20, %rcx
cmpq $0x3, %rax
jne 0x8b5f
xorpd %xmm0, %xmm0
movupd %xmm0, 0x60(%rdx)
movq $0x0, 0x70(%rdx)
movsd 0x78(%rdi), %xmm0
movsd %xmm0, 0x78(%rdx)
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: trasf_miam
void trasf_miam(MAT4 A1, MAT4 m, MAT4 A2)
{
	int i,j,h,k;
	real t;
	real tmp[3];

	for (i=0;i<3;i++)             /* 3×3 rotational sub-matrix*/
		for (j=0;j<3;j++)
		{
			t=0.;
			for (h=0;h<3;h++)
				for (k=0;k<3;k++)
					t += m[h][i]*A1[h][k]*m[k][j];
			A2[i][j]=(real)t;
		}
	for (i=0;i<3;i++)             /* temporary vector */
	{
		for (t=0.,j=0;j<3;j++)
			t += A1[i][j]*m[j][U];
		tmp[i] =(real) t;
	}
	for (i=0;i<3;i++)             /* 1,2,3 last column elements */
	{
		for (t=0.,j=0;j<3;j++)
			t += m[j][i]*(tmp[j]-A1[U][U]*m[j][U]+A1[j][U]);
		A2[i][U] = (real) t;
	}

	A2[U][X]=A2[U][Y]=A2[U][Z]=(real)0.; A2[U][U]=A1[U][U]; /* last row */
}

// Assembly:
pushq %rbx
xorl %eax, %eax
movq %rax, %rcx
shlq $0x5, %rcx
addq %rdx, %rcx
movq %rsi, %r8
xorl %r9d, %r9d
xorpd %xmm0, %xmm0
movq %rdi, %r10
xorl %r11d, %r11d
movq %r11, %rbx
shlq $0x5, %rbx
addq %rsi, %rbx
movsd (%rbx,%rax,8), %xmm1
xorl %ebx, %ebx
movsd (%r10,%rbx), %xmm2
mulsd %xmm1, %xmm2
mulsd (%r8,%rbx,4), %xmm2
addsd %xmm2, %xmm0
addq $0x8, %rbx
cmpq $0x18, %rbx
jne 0x8c0e
incq %r11
addq $0x20, %r10
cmpq $0x3, %r11
jne 0x8bfd
movsd %xmm0, (%rcx,%r9,8)
incq %r9
addq $0x8, %r8
cmpq $0x3, %r9
jne 0x8bf3
incq %rax
cmpq $0x3, %rax
jne 0x8be3
xorl %eax, %eax
movq %rdi, %rcx
xorpd %xmm0, %xmm0
xorl %r8d, %r8d
movsd (%rcx,%r8), %xmm1
mulsd 0x18(%rsi,%r8,4), %xmm1
addsd %xmm1, %xmm0
addq $0x8, %r8
cmpq $0x18, %r8
jne 0x8c61
movsd %xmm0, -0x20(%rsp,%rax,8)
incq %rax
addq $0x20, %rcx
cmpq $0x3, %rax
jne 0x8c5a
xorl %eax, %eax
movapd 0x1387(%rip), %xmm0     # 0xa020
movq %rsi, %rcx
movsd 0x78(%rdi), %xmm1
xorpd %xmm0, %xmm1
xorpd %xmm2, %xmm2
xorl %r8d, %r8d
movsd 0x18(%rsi,%r8,4), %xmm3
mulsd %xmm1, %xmm3
addsd -0x20(%rsp,%r8), %xmm3
addsd 0x18(%rdi,%r8,4), %xmm3
mulsd (%rcx,%r8,4), %xmm3
addsd %xmm3, %xmm2
addq $0x8, %r8
cmpq $0x18, %r8
jne 0x8cac
movq %rax, %r8
shlq $0x5, %r8
movsd %xmm2, 0x18(%rdx,%r8)
incq %rax
addq $0x8, %rcx
cmpq $0x3, %rax
jne 0x8c9c
xorpd %xmm0, %xmm0
movupd %xmm0, 0x60(%rdx)
movq $0x0, 0x70(%rdx)
movsd 0x78(%rdi), %xmm0
movsd %xmm0, 0x78(%rdx)
popq %rbx
retq