LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x9512
jmp 0x94fb
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x953f
jmp 0x9505
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x9569
jmp 0x9593
movq -0x10(%rbp), %rax
movsd 0x5b42(%rip), %xmm0     # 0xf060
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
jmp 0x95d1
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd 0x5b0a(%rip), %xmm0     # 0xf060
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
jmp 0x95d1
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movsd 0x5ad4(%rip), %xmm0     # 0xf060
movsd %xmm0, 0x10(%rax)
jmp 0x95d1
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq 0x8a3b(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x5dee(%rip), %rsi      # 0xf3b8
movb $0x0, %al
callq 0x21b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x20f0
movq -0x18(%rbp), %rax
movsd 0x5a52(%rip), %xmm0     # 0xf060
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd 0x5a42(%rip), %xmm0     # 0xf060
movsd %xmm0, 0x28(%rax)
movq -0x18(%rbp), %rax
movsd 0x5a31(%rip), %xmm0     # 0xf060
movsd %xmm0, 0x50(%rax)
movq -0x18(%rbp), %rax
movsd 0x5a20(%rip), %xmm0     # 0xf060
movsd %xmm0, 0x78(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x68(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x70(%rax)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
mulsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
mulsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x38(%rax)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
mulsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x58(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELI5.c
// Function: traslat24
void traslat24(int a, real h, POINT p, MAT4 m)

{
	  int i;
	  traslat2(a,h,m);
      for(i=X;i<=Z;i++)
		  {
			  m[i][U]=m[i][U]+p[i];
		  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x4(%rbp), %edi
movsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rsi
callq 0x2080
movl $0x0, -0x24(%rbp)
cmpl $0x2, -0x24(%rbp)
jg 0x97b6
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd 0x18(%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd %xmm0, 0x18(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9770
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELI5.c
// Function: psedot
real psedot(MAT4 A, MAT4 B)

{
	  real ps;
	  ps=A[X][U]*B[X][U]+A[Y][U]*B[Y][U]+A[Z][U]*B[Z][U]+
	     A[Z][Y]*B[Z][Y]+A[X][Z]*B[X][Z]+A[Y][X]*B[Y][X];
	  return(ps);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm2
movq -0x8(%rbp), %rax
movsd 0x38(%rax), %xmm1
movq -0x10(%rbp), %rax
mulsd 0x38(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd 0x58(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x58(%rax), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x8(%rbp), %rax
movsd 0x48(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x48(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: screwtom
void screwtom (AXIS u, real phi, real h, POINT P, MAT4 Q)
{
	int i,j;
	real t;

	rotat(u,phi,M Q,4);  /* builds rotational sub-matrix */

	for(i=X;i<U;i++)
	{
		for(j=X,t=0;j<U;j++)
			t += -Q[i][j] * P[j];
		Q[i][U] = (real) t + P[i] + u[i] * h;
	}
	Q[U][X]=Q[U][Y]=Q[U][Z]= 0; Q[U][U]= 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movq -0x28(%rbp), %rsi
movl $0x4, %edx
callq 0x2300
movl $0x0, -0x2c(%rbp)
cmpl $0x3, -0x2c(%rbp)
jge 0xb302
movl $0x0, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
cmpl $0x3, -0x30(%rbp)
jge 0xb2b4
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xb255
movsd -0x38(%rbp), %xmm1
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm1
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd -0x18(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd %xmm0, 0x18(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb23c
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x70(%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x68(%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rax)
movq -0x28(%rbp), %rax
movsd 0x3d2e(%rip), %xmm0     # 0xf060
movsd %xmm0, 0x78(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: gtom
void gtom(real gx, real gy, real gz, MAT4 Hg)
{
	clear4(Hg);
	Hg[X][U]=gx;
	Hg[Y][U]=gy;
	Hg[Z][U]=gz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x4, %edx
movl %edx, %esi
callq 0x2410
movsd -0x8(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x38(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x58(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2370
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rdx
movl $0x4, %esi
callq 0x23e0
leaq -0x30(%rbp), %rdi
callq 0x2050
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm1
movsd -0x40(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb71a
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm1
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm2
movq -0x8(%rbp), %rax
movsd 0x38(%rax), %xmm0
movq -0x8(%rbp), %rax
mulsd 0x38(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x8(%rbp), %rax
movsd 0x58(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd 0x58(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x23f0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm1
movsd -0x40(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb73c
movq -0x10(%rbp), %rdi
movl $0x4, %edx
movl %edx, %esi
callq 0x2410
jmp 0xb75d
movq -0x8(%rbp), %rdi
movsd 0x3918(%rip), %xmm0     # 0xf060
divsd -0x38(%rbp), %xmm0
movq -0x10(%rbp), %rsi
movl $0x4, %ecx
movl %ecx, %edx
callq 0x2430
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: zerom
real zerom(void)
{
	real  a=(real)1., b=(real)-1;
	static real dzero= (real) -1.;

	if(dzero>(real)0.)
		return((real)dzero);
	loop:
		if (1.==b)
		{
			dzero=2*a;
			return(dzero);
		}

	a /=2.; b=a+1.;

	goto loop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd 0x38e4(%rip), %xmm0     # 0xf060
movsd %xmm0, -0x10(%rbp)
movsd 0x38df(%rip), %xmm0     # 0xf068
movsd %xmm0, -0x18(%rbp)
movsd 0x6aaa(%rip), %xmm0     # 0x12240
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xb7ae
movsd 0x6a99(%rip), %xmm0     # 0x12240
movsd %xmm0, -0x8(%rbp)
jmp 0xb80f
jmp 0xb7b0
movsd 0x38a8(%rip), %xmm0     # 0xf060
ucomisd -0x18(%rbp), %xmm0
jne 0xb7e5
jp 0xb7e5
movsd 0x3a5f(%rip), %xmm0     # 0xf228
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x6a6a(%rip)     # 0x12240
movsd 0x6a62(%rip), %xmm0     # 0x12240
movsd %xmm0, -0x8(%rbp)
jmp 0xb80f
movsd -0x10(%rbp), %xmm0
movsd 0x3a36(%rip), %xmm1     # 0xf228
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x385d(%rip), %xmm0     # 0xf060
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xb7b0
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl $0x4, %edx
movl %edx, %esi
callq 0x2410
movq -0x28(%rbp), %rdi
movl $0x4, %edx
movl %edx, %esi
callq 0x2410
cmpl $0x1, -0x8(%rbp)
jne 0xba34
movsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x58(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x58(%rax)
jmp 0xbaec
cmpl $0x0, -0x8(%rbp)
je 0xba5e
movq 0x65b7(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x39ed(%rip), %rsi      # 0xf438
movb $0x0, %al
callq 0x21b0
movl $0x0, -0x4(%rbp)
jmp 0xbaf3
movsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x10(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd -0x10(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: actom
void actom(real fx, real fy, real fz, real cx, real cy, real cz, MAT4 FI)
{
	FI[X][X]= (real) 0.; FI[X][Y]= -cz;      FI[X][Z]=  cy;
	FI[Y][X]=  cz;       FI[Y][Y]=(real) 0.; FI[Y][Z]= -cx;
	FI[Z][X]= -cy;       FI[Z][Y]=  cx;      FI[Z][Z]=(real) 0.;
	FI[U][X]= -fx;       FI[U][Y]= -fy;      FI[U][Z]= -fz;

	FI[X][U]=fx;
	FI[Y][U]=fy;
	FI[Z][U]=fz;
	FI[U][U]=(real)0.;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd %xmm4, -0x28(%rbp)
movsd %xmm5, -0x30(%rbp)
movq %rdi, -0x38(%rbp)
movq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
movsd -0x20(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x30(%rax)
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x40(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x48(%rax)
movq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rax)
movsd -0x8(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x60(%rax)
movsd -0x10(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x68(%rax)
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x70(%rax)
movsd -0x8(%rbp), %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x38(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x58(%rax)
movq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x78(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: coriolis
void coriolis(MAT4 H0, MAT4 H1, MAT4 W0, MAT4 W1, MAT4 H)
{

	real t;
	int i,j,k;

	for (i=0;i<3;i++)
	{
		for (j=0;j<4;j++)
		{
			t=0;
			for (k=0;k<3;k++)
			{
				t += W0[i][k]*W1[k][j];
			}
			H[i][j] =(real) 2.*t+H0[i][j]+H1[i][j];
		}
	}
	H[U][X]=H[U][Y]=H[U][Z]=H[U][U]=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x3, -0x34(%rbp)
jge 0xd5af
movl $0x0, -0x38(%rbp)
cmpl $0x4, -0x38(%rbp)
jge 0xd59f
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x3, -0x3c(%rbp)
jge 0xd53c
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xd4e9
movsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x38(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x38(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xd4d0
jmp 0xd5a1
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xd4bf
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x78(%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x70(%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x68(%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: invers
void invers(MAT4 m, MAT4 mi)
{
	int i,j;
	real t;

	if (m==mi){
		runtime_error("invers(m,mi)","the input and the output operands 'm' and 'mi' must be different", 1);
	}

	for (i=0;i<3;i++)
	{
		for (t=(real)0.,j=0;j<3;j++)
		{
			mi[i][j]=m[j][i];
			t -= m[j][i]*m[j][U];
		}
		mi[i][U]=t;
	}
	mi[U][X] = mi[U][Y] = mi[U][Z] = (real) 0.; mi[U][U]=(real)1.;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xd622
leaq 0x1ec9(%rip), %rdi      # 0xf4da
leaq 0x1ecf(%rip), %rsi      # 0xf4e7
movl $0x1, %edx
callq 0x22a0
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0xd706
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jge 0xd6df
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd 0x18(%rax), %xmm2
movsd -0x20(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd642
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd %xmm0, 0x18(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd629
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x70(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x68(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rax)
movq -0x10(%rbp), %rax
movsd 0x192a(%rip), %xmm0     # 0xf060
movsd %xmm0, 0x78(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0x488e(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x1e51(%rip), %rsi      # 0xf5c9
movb $0x0, %al
callq 0x21b0
movq 0x4872(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1e56(%rip), %rsi      # 0xf5ea
movb $0x0, %al
callq 0x21b0
cmpl $0x0, -0x14(%rbp)
je 0xd7a9
movl -0x14(%rbp), %edi
callq 0x23d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: trac_ljlt4
real trac_ljlt4(MAT4 L1, MAT4 J, MAT4 L2)
{
	int i,h,k;
	real t;

	t=0.;
	for (i=0;i<3;i++) /* 4th row of L1 and 4th column of L2 assumed null */
		for (h=0;h<4;h++)
			for (k=0;k<4;k++)
				t += L1[i][h]*J[h][k]*L2[i][k];
	return ((real) t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0xdb6c
movl $0x0, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0xdb5c
movl $0x0, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jge 0xdb4c
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x24(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xdae1
jmp 0xdb4e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xdad0
jmp 0xdb5e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xdabf
movsd -0x30(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: unitv
real unitv(VECTOR v, AXIS u)
{
	real t;

	t = sqrt (v[X]*v[X] +v[Y]*v[Y] +v[Z]*v[Z]);
	if(t!=0)
	{
		u[X] = v[X]/t; u[Y] = v[Y]/t; u[Z] = v[Z]/t;
	}
	else
	{
		u[X] = u[Y] = u[Z] =  0;
		return (0.); /* bug fixed 03/04/1997 AmGhiPu */
	}
	if (t>10. || t<.1)
		unitv(u,u);  /* to avoid numerical problems */
	return (real) t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x10(%rbp), %rax
movsd (%rax), %xmm2
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
mulsd 0x8(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x23f0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe220
jp 0xe220
jmp 0xe265
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
divsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
divsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
divsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x10(%rax)
jmp 0xe292
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xe2cb
movsd -0x20(%rbp), %xmm0
movsd 0x1161(%rip), %xmm1     # 0xf400
ucomisd %xmm1, %xmm0
ja 0xe2b4
movsd 0x113b(%rip), %xmm0     # 0xf3e8
ucomisd -0x20(%rbp), %xmm0
jbe 0xe2c1
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20f0
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: fprintm3
void fprintm3(FILE *out, char *s, MAT3 A)
{
	fprintf(out,"\n\n %s \n",s);
	fprintf(out,"             %8.3f  %8.3f  %8.3f\n",A[X][X],A[X][Y],A[X][Z]);
	fprintf(out,"             %8.3f  %8.3f  %8.3f\n",A[Y][X],A[Y][Y],A[Y][Z]);
	fprintf(out,"             %8.3f  %8.3f  %8.3f\n",A[Z][X],A[Z][Y],A[Z][Z]);
	fprintf(out,"\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1174(%rip), %rsi      # 0xf567
movb $0x0, %al
callq 0x21b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm2
leaq 0x1150(%rip), %rsi      # 0xf56f
movb $0x3, %al
callq 0x21b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x28(%rax), %xmm2
leaq 0x1123(%rip), %rsi      # 0xf56f
movb $0x3, %al
callq 0x21b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x30(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x38(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x40(%rax), %xmm2
leaq 0x10f6(%rip), %rsi      # 0xf56f
movb $0x3, %al
callq 0x21b0
movq -0x8(%rbp), %rdi
leaq 0x1162(%rip), %rsi      # 0xf5ed
movb $0x0, %al
callq 0x21b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: fprintm4
void fprintm4(FILE *out, char *s, MAT4 A)
{
	fprintf(out,"\n\n %s \n",s);
	fprintf(out,"            %8.3f  %8.3f  %8.3f  %8.3f\n"
					    ,A[X][X],A[X][Y],A[X][Z],A[X][U]);
	fprintf(out,"            %8.3f  %8.3f  %8.3f  %8.3f\n"
					    ,A[Y][X],A[Y][Y],A[Y][Z],A[Y][U]);
	fprintf(out,"            %8.3f  %8.3f  %8.3f  %8.3f\n"
					    ,A[Z][X],A[Z][Y],A[Z][Z],A[Z][U]);
	fprintf(out,"            %8.3f  %8.3f  %8.3f  %8.3f\n"
					    ,A[U][X],A[U][Y],A[U][Z],A[U][U]);
	fprintf(out,"\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x10a4(%rip), %rsi      # 0xf567
movb $0x0, %al
callq 0x21b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm2
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm3
leaq 0x1099(%rip), %rsi      # 0xf591
movb $0x4, %al
callq 0x21b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x28(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x30(%rax), %xmm2
movq -0x18(%rbp), %rax
movsd 0x38(%rax), %xmm3
leaq 0x1063(%rip), %rsi      # 0xf591
movb $0x4, %al
callq 0x21b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x40(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x48(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x50(%rax), %xmm2
movq -0x18(%rbp), %rax
movsd 0x58(%rax), %xmm3
leaq 0x102d(%rip), %rsi      # 0xf591
movb $0x4, %al
callq 0x21b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x60(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x68(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x70(%rax), %xmm2
movq -0x18(%rbp), %rax
movsd 0x78(%rax), %xmm3
leaq 0xff7(%rip), %rsi       # 0xf591
movb $0x4, %al
callq 0x21b0
movq -0x8(%rbp), %rdi
leaq 0x1041(%rip), %rsi      # 0xf5ed
movb $0x0, %al
callq 0x21b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: fprintv
void fprintv(FILE *out, char *s, real *v, int n)
{
	int i;

	fprintf(out,"\n %s \n   ",s);
	for (i=0;i<n;i++)
		fprintf(out,"%8.3f",v[i]);
	fprintf(out,"\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xfd3(%rip), %rsi       # 0xf5b9
movb $0x0, %al
callq 0x21b0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xe626
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0xfaf(%rip), %rsi       # 0xf5c3
movb $0x1, %al
callq 0x21b0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xe5f4
movq -0x8(%rbp), %rdi
leaq 0xfbc(%rip), %rsi       # 0xf5ed
movb $0x0, %al
callq 0x21b0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: fzerom
float fzerom(void)
{
	float a=(float)1.,b=(float)-1.;
	static float dzero= (float)-1.;

	if(dzero>(float)0)
		return(dzero);

	loop:
		if (1.==b)
		{
			dzero=2*a;
			return(dzero);
		}
		a /=2; b=a+1;

	goto loop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss 0xdc0(%rip), %xmm0      # 0xf40c
movss %xmm0, -0x8(%rbp)
movss 0xdaf(%rip), %xmm0      # 0xf408
movss %xmm0, -0xc(%rbp)
movss 0x3be2(%rip), %xmm0     # 0x12248
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xe67d
movss 0x3bd2(%rip), %xmm0     # 0x12248
movss %xmm0, -0x4(%rbp)
jmp 0xe6e6
jmp 0xe67f
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x9d0(%rip), %xmm0      # 0xf060
ucomisd %xmm1, %xmm0
jne 0xe6bc
jp 0xe6bc
movss 0xd70(%rip), %xmm0      # 0xf410
mulss -0x8(%rbp), %xmm0
movss %xmm0, 0x3b9b(%rip)     # 0x12248
movss 0x3b93(%rip), %xmm0     # 0x12248
movss %xmm0, -0x4(%rbp)
jmp 0xe6e6
movss -0x8(%rbp), %xmm0
movss 0xd47(%rip), %xmm1      # 0xf410
divss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss 0xd32(%rip), %xmm0      # 0xf40c
addss -0x8(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
jmp 0xe67f
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: dzerom
double dzerom(void)
{
	double a=1.,b=-1.;
	static double dzero= -1.;

	if(dzero>0.)
		return(dzero);

	loop:
		if (1.==b)
		{
			dzero=2*a;
			return(dzero);
		}
		a /=2.; b=a+1.;

	goto loop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd 0x964(%rip), %xmm0      # 0xf060
movsd %xmm0, -0x10(%rbp)
movsd 0x95f(%rip), %xmm0      # 0xf068
movsd %xmm0, -0x18(%rbp)
movsd 0x3b3a(%rip), %xmm0     # 0x12250
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xe72e
movsd 0x3b29(%rip), %xmm0     # 0x12250
movsd %xmm0, -0x8(%rbp)
jmp 0xe78f
jmp 0xe730
movsd 0x928(%rip), %xmm0      # 0xf060
ucomisd -0x18(%rbp), %xmm0
jne 0xe765
jp 0xe765
movsd 0xadf(%rip), %xmm0      # 0xf228
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x3afa(%rip)     # 0x12250
movsd 0x3af2(%rip), %xmm0     # 0x12250
movsd %xmm0, -0x8(%rbp)
jmp 0xe78f
movsd -0x10(%rbp), %xmm0
movsd 0xab6(%rip), %xmm1      # 0xf228
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x8dd(%rip), %xmm0      # 0xf060
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xe730
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cirocosta[P]stress/src/disk.c
// Function: write_to_disk
void
write_to_disk(char* filename, int count)
{
	FILE* f = fopen(filename, "w");
	char file_buffer[CHUNK_SIZE] = { 0 };
	unsigned long writes = count * _STRESS_MB(1) / CHUNK_SIZE;

	while (writes-- > 0) {
		fwrite(file_buffer, CHUNK_SIZE, 1, f);
	}

	fclose(f);
}

// Assembly:
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, 0x1020(%rsp)
movl %esi, 0x101c(%rsp)
movq 0x1020(%rsp), %rdi
leaq 0x84b(%rip), %rsi       # 0x2120
callq 0x10f0
movq %rax, 0x1010(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x10c0
movslq 0x101c(%rsp), %rax
shlq $0x14, %rax
shrq $0xc, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rsp)
cmpq $0x0, %rax
jbe 0x193d
leaq 0x10(%rsp), %rdi
movq 0x1010(%rsp), %rcx
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %edx
callq 0x1130
jmp 0x1908
movq 0x1010(%rsp), %rdi
callq 0x1080
addq $0x1028, %rsp           # imm = 0x1028
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cirocosta[P]stress/src/disk.c
// Function: main
int
main(int argc, char** argv)
{
	stress_args_t args = { 0 };

	setbuf(stdout, NULL);
	stress_parse_args(argc, argv, &args);

	_STRESS_MUST(strlen(args.f), "a filename must be specified");

	write_to_disk(args.f, args.n);

	if (args.b)
		stress_wait_until_signalized();
	return 0;
}

// Assembly:
subq $0x2018, %rsp           # imm = 0x2018
movl $0x0, 0x2014(%rsp)
movl %edi, 0x2010(%rsp)
movq %rsi, 0x2008(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x2008, %edx           # imm = 0x2008
callq 0x10c0
movq 0x2631(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10a0
movl 0x2010(%rsp), %edi
movq 0x2008(%rsp), %rsi
movq %rsp, %rdx
callq 0x12f0
movq %rsp, %rdi
addq $0x5, %rdi
callq 0x1090
cmpq $0x0, %rax
jne 0x1aa6
movq 0x2621(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x657(%rip), %rsi       # 0x2038
movb $0x0, %al
callq 0x10e0
movq 0x2609(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x645(%rip), %rsi       # 0x203e
movb $0x0, %al
callq 0x10e0
movq 0x25f1(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x711(%rip), %rsi       # 0x2122
movb $0x0, %al
callq 0x10e0
movq 0x25d9(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x63c(%rip), %rsi       # 0x2065
movb $0x0, %al
callq 0x10e0
movq 0x25c1(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x627(%rip), %rsi       # 0x2068
leaq 0x6f7(%rip), %rdx       # 0x213f
movb $0x0, %al
callq 0x10e0
movq 0x25a2(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x624(%rip), %rsi       # 0x2084
movl $0x27, %edx
movb $0x0, %al
callq 0x10e0
movq 0x2585(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x5e9(%rip), %rsi       # 0x2066
movb $0x0, %al
callq 0x10e0
movq 0x256d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x5fc(%rip), %rsi       # 0x2091
movb $0x0, %al
callq 0x10e0
movl $0x1, %edi
callq 0x1120
jmp 0x1aa8
movq %rsp, %rdi
addq $0x5, %rdi
movl (%rsp), %esi
callq 0x18b0
cmpb $0x0, 0x4(%rsp)
je 0x1ac3
callq 0x16f0
xorl %eax, %eax
addq $0x2018, %rsp           # imm = 0x2018
retq
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/dag.c
// Function: addlocal
void addlocal(Symbol p) {
	if (!p->defined) {
		code(Local)->u.var = p;
		p->defined = 1;
		p->scope = level;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb 0x1b(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x32eb
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x2, %edi
callq 0x3300
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movb 0x1b(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x1b(%rax)
leaq 0x3dcb2(%rip), %rax     # 0x40f90
movl (%rax), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/dag.c
// Function: code
Code code(int kind) {
	Code cp;

	if (kind > Label) {
		for (cp = codelist; cp->kind < Label; )
			cp = cp->prev;
		if (cp->kind == Jump)
			warning("unreachable code\n");
	}
	cp = (Code)talloc(sizeof *cp);
	cp->kind = kind;
	cp->prev = codelist;
	cp->next = 0;
	codelist->next = cp;
	return codelist = cp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x5, -0x4(%rbp)
jle 0x334c
movq 0x35e10(%rip), %rax     # 0x39128
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x5, (%rax)
jae 0x3333
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x331c
movq -0x10(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x334a
leaq 0x2bd19(%rip), %rdi     # 0x2f05c
movb $0x0, %al
callq 0xdba0
jmp 0x334c
leaq 0x382f5(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl $0x48, (%rax)
leaq 0x382e5(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x382d7(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
leaq 0x382c7(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jb 0x33a8
leaq 0x382b7(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl (%rax), %edi
leaq 0x382ab(%rip), %rsi     # 0x3b648
callq 0x253d0
movq %rax, -0x18(%rbp)
jmp 0x33f3
leaq 0x38299(%rip), %rax     # 0x3b648
movq (%rax), %rax
movl (%rax), %edx
leaq 0x3828d(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
leaq 0x38275(%rip), %rax     # 0x3b648
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0x38267(%rip), %rcx     # 0x3b648
movq (%rcx), %rcx
movslq (%rcx), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq 0x35d1d(%rip), %rcx     # 0x39128
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x35cfe(%rip), %rax     # 0x39128
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x35cef(%rip)     # 0x39128
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/dag.c
// Function: typestab
static void typestab(Symbol p, Generic cl){
	if (!isfunc(p->type) && (p->sclass == EXTERN || p->sclass == STATIC))
		stabsym(p);
	else if (p->sclass == TYPEDEF || p->sclass == 0)
		stabtype(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0xf, (%rax)
jb 0x36cb
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x36d7
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xb, (%rax)
je 0x36fc
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x4a, %eax
je 0x36fa
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x51, %eax
jne 0x36fc
jmp 0x371a
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x53, %eax
je 0x3716
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
jne 0x3718
jmp 0x3718
jmp 0x371a
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/dag.c
// Function: walk
void walk(Tree tp, int tlab, int flab) {
	listnodes(tp, tlab, flab);
	if (nodelist) {
		trash(0);
		code(Gen);
		codelist->u.node = nodelist->link;
		nodelist->link = 0;
		nodelist = 0;
		rmtemps(REGISTER, 0);
	}
	reset();
	ntree = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x3c30
cmpq $0x0, 0x37ec7(%rip)     # 0x3b970
je 0x3afa
xorl %eax, %eax
movl %eax, %edi
callq 0x57c0
movl $0x8, %edi
callq 0x3300
movq 0x37eab(%rip), %rax     # 0x3b970
movq 0x30(%rax), %rcx
movq 0x35658(%rip), %rax     # 0x39128
movq %rcx, 0x18(%rax)
movq 0x37e95(%rip), %rax     # 0x3b970
movq $0x0, 0x30(%rax)
movq $0x0, 0x37e82(%rip) # 0x3b970
movl $0x4e, %edi
xorl %esi, %esi
callq 0x242a0
callq 0x5f50
leaq 0x3d4d2(%rip), %rax     # 0x40fd8
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/dag.c
// Function: fixup
static void fixup(Node p) {
	for ( ; p; p = p->link)
		switch (generic(p->op)) {
		case JUMP:
			if (p->kids[0]->op == ADDRG+P)
				p->kids[0]->syms[0] = p->kids[0]->syms[0]->u.l.equatedto;
			break;
		case LABEL:
		case EQ: case GE: case GT: case LE: case LT: case NE:
			assert(p->syms[0]);
			p->syms[0] = p->syms[0]->u.l.equatedto;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3c25
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $-0x10, %eax
movl %eax, -0xc(%rbp)
subl $0x1e0, %eax            # imm = 0x1E0
je 0x3bd2
jmp 0x3b50
movl -0xc(%rbp), %eax
subl $0x1f0, %eax            # imm = 0x1F0
je 0x3bd2
jmp 0x3b5c
movl -0xc(%rbp), %eax
subl $0x200, %eax            # imm = 0x200
je 0x3bd2
jmp 0x3b68
movl -0xc(%rbp), %eax
subl $0x210, %eax            # imm = 0x210
je 0x3bd2
jmp 0x3b74
movl -0xc(%rbp), %eax
subl $0x220, %eax            # imm = 0x220
je 0x3bd2
jmp 0x3b80
movl -0xc(%rbp), %eax
subl $0x230, %eax            # imm = 0x230
je 0x3bd2
jmp 0x3b8c
movl -0xc(%rbp), %eax
subl $0x240, %eax            # imm = 0x240
je 0x3ba4
jmp 0x3b98
movl -0xc(%rbp), %eax
subl $0x250, %eax            # imm = 0x250
je 0x3bd2
jmp 0x3c12
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x107, (%rax)          # imm = 0x107
jne 0x3bd0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x3c12
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3bdf
jmp 0x3bfe
leaq 0x2b5e1(%rip), %rdi     # 0x2f1c7
leaq 0x2b4a7(%rip), %rsi     # 0x2f094
movl $0x8d, %edx
leaq 0x2b5d9(%rip), %rcx     # 0x2f1d2
callq 0x30c0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3c14
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3b2c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/dag.c
// Function: labelnode
static Node labelnode(int lab) {
	assert(lab);
	if (islabel(nodelist)) {
		equatelab(findlabel(lab), nodelist->syms[0]);
		return nodelist;
	}
	return list(newnode(LABEL+V, 0, 0, findlabel(lab)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x5713
jmp 0x5732
leaq 0x29a70(%rip), %rdi     # 0x2f18a
leaq 0x29973(%rip), %rsi     # 0x2f094
movl $0xe3, %edx
leaq 0x29ab6(%rip), %rcx     # 0x2f1e3
callq 0x30c0
cmpq $0x0, 0x36236(%rip)     # 0x3b970
je 0x5781
movq 0x3622d(%rip), %rax     # 0x3b970
cmpl $0x258, (%rax)          # imm = 0x258
jne 0x5781
movq 0x3621e(%rip), %rax     # 0x3b970
cmpq $0x0, 0x8(%rax)
je 0x5781
movl -0xc(%rbp), %edi
callq 0x245d0
movq %rax, %rdi
movq 0x36205(%rip), %rax     # 0x3b970
movq 0x8(%rax), %rsi
callq 0x20b60
movq 0x361f5(%rip), %rax     # 0x3b970
movq %rax, -0x8(%rbp)
jmp 0x57a9
movl -0xc(%rbp), %edi
callq 0x245d0
movq %rax, %rcx
movl $0x258, %edi            # imm = 0x258
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x5bf0
movq %rax, %rdi
callq 0x59a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/dag.c
// Function: trash
static void trash(Node p) {
	if (p) {
		register int i;
		register struct dag *q, **r;
		for (i = 0; i < NBUCKETS; i++)
			for (r = &buckets[i]; *r; ) {
                q = *r;
				if (generic(q->node.op) == INDIR
                    && (!isaddrop(q->node.kids[0]->op) || q->node.kids[0]->syms[0] == p->syms[0])) {
					*r = q->hlink;
					--nodecount;
				} else
					r = &q->hlink;
			}
	} else if (nodecount > 0)
		reset();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x58ae
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x58ac
movslq -0xc(%rbp), %rcx
leaq 0x3618d(%rip), %rax     # 0x3b980
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x589c
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $-0x10, %eax
cmpl $0x40, %eax
jne 0x588b
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x107, (%rax)          # imm = 0x107
je 0x5855
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x127, (%rax)          # imm = 0x127
je 0x5855
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x117, (%rax)          # imm = 0x117
jne 0x586b
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x588b
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl 0x36180(%rip), %eax     # 0x3ba00
addl $-0x1, %eax
movl %eax, 0x36177(%rip)     # 0x3ba00
jmp 0x5897
movq -0x18(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x20(%rbp)
jmp 0x57fe
jmp 0x589e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x57de
jmp 0x58be
cmpl $0x0, 0x3614b(%rip)     # 0x3ba00
jle 0x58bc
callq 0x5f50
jmp 0x58be
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/dag.c
// Function: remove
static void remove(Node p) {
	if (nodelist) {
		Node q = nodelist;
		for ( ; q->link != p && q->link != nodelist; q = q->link)
			;
		assert(q->link == p);
		q->link = p->link;
		if (p == nodelist)
			nodelist = q;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x3608c(%rip)     # 0x3b970
je 0x598f
movq 0x3607f(%rip), %rax     # 0x3b970
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x11(%rbp)
je 0x591d
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpq 0x36059(%rip), %rax     # 0x3b970
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x5926
jmp 0x5936
jmp 0x5928
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x58f5
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x5946
jmp 0x5965
leaq 0x298c6(%rip), %rdi     # 0x2f213
leaq 0x29740(%rip), %rsi     # 0x2f094
movl $0x27a, %edx            # imm = 0x27A
leaq 0x298c0(%rip), %rcx     # 0x2f220
callq 0x30c0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
cmpq 0x35ff0(%rip), %rax     # 0x3b970
jne 0x598d
movq -0x10(%rbp), %rax
movq %rax, 0x35fe3(%rip)     # 0x3b970
jmp 0x598f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/dag.c
// Function: list
static Node list(Node p){
	if (p && p->link == 0) {
		if (nodelist) {
			p->link = nodelist->link;
			nodelist->link = p;
		} else
			p->link = p;
		nodelist = p;
#ifdef DAGCHECK
		{ extern void type_checker(Node); type_checker(p); }
#endif
	}
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x59ff
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x59ff
cmpq $0x0, 0x35fae(%rip)     # 0x3b970
je 0x59e8
movq 0x35fa5(%rip), %rax     # 0x3b970
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rcx
movq 0x35f8e(%rip), %rax     # 0x3b970
movq %rcx, 0x30(%rax)
jmp 0x59f4
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x35f71(%rip)     # 0x3b970
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)