LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: Druse
void Druse()
{
  int i, charge;

  sprintf(scrstr,"%s: Chekov, drop shields ...", Name);
  SEndln();
  if (Ct[0]) {
    sprintf(scrstr,"Spock: %s, the %ss are not that stupid.",
      Title, Enemy);
    SEndln();
    return;
  }
  waddstr(Cmdwin,"   Transfer power to [engines or phasers]: ");
  mygetstr(Cmdwin,scrstr,true);
  if (!scrstr[0]) {
    ChWhat();
    return;
  }
  charge = (-10);
  if (scrstr[0] == 'e' || scrstr[0] == 'E') {
    Objects[0]->Fuel+=10;
    if (Objects[0]->Fuel > Ships[0]->Fcap)
      Objects[0]->Fuel = Ships[0]->Fcap;
  } else if (scrstr[0] == 'p' || scrstr[0] == 'P')
    charge = 10;
  else {
    ChWhat();
    return;
  }
  for (i=0; i<4; i++)
    Ships[0]->Sdrns[i] = 0;
  for (i=0; i<Phasers; i++)
    Ships[0]->PCrts[i] = charge;
  Ct[0] = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xa719(%rip), %rdx      # 0x155b8
leaq 0xa5fa(%rip), %rdi      # 0x154a0
leaq 0x6192(%rip), %rsi      # 0x1103f
movb $0x0, %al
callq 0x2190
callq 0x4320
cmpb $0x0, 0xa713(%rip)      # 0x155d3
je 0xaeef
movq 0xa6ff(%rip), %rdx      # 0x155c8
movq 0xaaa0(%rip), %rcx      # 0x15970
leaq 0xa5c9(%rip), %rdi      # 0x154a0
leaq 0x617e(%rip), %rsi      # 0x1105c
movb $0x0, %al
callq 0x2190
callq 0x4320
jmp 0xb03e
movq 0xaaf2(%rip), %rdi      # 0x159e8
leaq 0x6187(%rip), %rsi      # 0x11084
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
movq 0xaada(%rip), %rdi      # 0x159e8
leaq 0xa58b(%rip), %rsi      # 0x154a0
movl $0x1, %edx
callq 0x24a0
cmpb $0x0, 0xa57a(%rip)      # 0x154a0
jne 0xaf32
callq 0x8d30
jmp 0xb03e
movl $0xfffffff6, -0x8(%rbp) # imm = 0xFFFFFFF6
movsbl 0xa560(%rip), %eax      # 0x154a0
cmpl $0x65, %eax
je 0xaf51
movsbl 0xa554(%rip), %eax      # 0x154a0
cmpl $0x45, %eax
jne 0xafa8
movq 0xa688(%rip), %rax      # 0x155e0
movsd 0x40a8(%rip), %xmm0     # 0xf008
addsd 0x20(%rax), %xmm0
movsd %xmm0, 0x20(%rax)
movq 0xa66f(%rip), %rax      # 0x155e0
movsd 0x20(%rax), %xmm0
movq 0xaa03(%rip), %rax      # 0x15980
movzbl 0x18(%rax), %eax
cvtsi2sd %eax, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xafa6
movq 0xa9ee(%rip), %rax      # 0x15980
movzbl 0x18(%rax), %eax
cvtsi2sd %eax, %xmm0
movq 0xa63f(%rip), %rax      # 0x155e0
movsd %xmm0, 0x20(%rax)
jmp 0xafd2
movsbl 0xa4f1(%rip), %eax      # 0x154a0
cmpl $0x70, %eax
je 0xafc0
movsbl 0xa4e5(%rip), %eax      # 0x154a0
cmpl $0x50, %eax
jne 0xafc9
movl $0xa, -0x8(%rbp)
jmp 0xafd0
callq 0x8d30
jmp 0xb03e
jmp 0xafd2
movl $0x0, -0x4(%rbp)
cmpl $0x4, -0x4(%rbp)
jge 0xb001
movq 0xa99a(%rip), %rax      # 0x15980
movslq -0x4(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, 0x80(%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xafd9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movzbl 0xa19e(%rip), %ecx      # 0x151b0
cmpl %ecx, %eax
jge 0xb037
cvtsi2sdl -0x8(%rbp), %xmm0
movq 0xa95e(%rip), %rax      # 0x15980
movslq -0x4(%rbp), %rcx
movsd %xmm0, 0x40(%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xb008
movb $0x1, 0xa595(%rip)      # 0x155d3
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: AtRad
void AtRad()
{
  int Junk;
  boolean Ok;

  TCount = (-1);
  if (Ships[0]->Dmge[(long)Snsr]) {
    NoSnsr();
    return;
  }
  do {
    waddstr(Cmdwin,"   Display radius: [50-10000] ");
    mygetstr(Cmdwin,scrstr,true);
    Junk = atoi(scrstr);
    if (Junk >= 50 && Junk <= 10000) {
      Radius = (long)Junk;
      Ok = true;
    } else {
      waddstr(Cmdwin,"\nSpock:  Designate between 50 and 10000.");
      wrefresh(Cmdwin);
      Ok = false;
    }
  } while (!Ok);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, 0x9256(%rip) # imm = 0xFFFFFFFF
movq 0x91a7(%rip), %rax      # 0x15980
cmpb $0x0, 0xc1(%rax)
je 0xc7ec
callq 0x8dc0
jmp 0xc887
jmp 0xc7ee
movq 0x91f3(%rip), %rdi      # 0x159e8
leaq 0x4f91(%rip), %rsi      # 0x1178d
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
movq 0x91db(%rip), %rdi      # 0x159e8
leaq 0x8c8c(%rip), %rsi      # 0x154a0
movl $0x1, %edx
callq 0x24a0
leaq 0x8c7b(%rip), %rdi      # 0x154a0
callq 0x21c0
movl %eax, -0x4(%rbp)
cmpl $0x32, -0x4(%rbp)
jl 0xc84c
cmpl $0x2710, -0x4(%rbp)     # imm = 0x2710
jg 0xc84c
movslq -0x4(%rbp), %rax
movl %eax, 0x91d2(%rip)      # 0x15a18
movb $0x1, -0x5(%rbp)
jmp 0xc874
movq 0x9195(%rip), %rdi      # 0x159e8
leaq 0x4f52(%rip), %rsi      # 0x117ac
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
movq 0x917d(%rip), %rdi      # 0x159e8
callq 0x2180
movb $0x0, -0x5(%rbp)
jmp 0xc876
cmpb $0x0, -0x5(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc7ee
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: ENav
void ENav()
{
  double Temp;
  int Shp;
  boolean Ok, Ship;

  if (Ships[0]->Dmge[(long)Comp]) {
    NoComp();
    return;
  }
  Ok = false;
  waddstr(Cmdwin,"   Chekov, elude the ");
  Shp = GetShp(&Ok, &Ship);
  if (!(Ship && Ok)) {
    ChWhat();
    return;
  }
  Ok = Getwarp(Ok);
  if (!Ok) {
    return;
  }
  Objects[0]->Trgt = -(Shp+1);
  Temp = RMod(Bearing(0, Shp) + 180);
  sprintf(scrstr,"Chekov: Aye, %s, coming to course %3.0f", Title, Temp);
  mvwaddstr(Cmdwin,3,0,scrstr);
  Endln();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x90e1(%rip), %rax      # 0x15980
cmpb $0x0, 0xc0(%rax)
je 0xc8b2
callq 0x8df0
jmp 0xc9a1
movb $0x0, -0xd(%rbp)
movq 0x912b(%rip), %rdi      # 0x159e8
leaq 0x4f11(%rip), %rsi      # 0x117d5
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
leaq -0xd(%rbp), %rdi
leaq -0xe(%rbp), %rsi
callq 0x93b0
movl %eax, -0xc(%rbp)
movsbl -0xe(%rbp), %eax
cmpl $0x0, %eax
je 0xc8f0
movsbl -0xd(%rbp), %eax
cmpl $0x0, %eax
jne 0xc8fa
callq 0x8d30
jmp 0xc9a1
movsbl -0xd(%rbp), %edi
callq 0x8e20
movb %al, -0xd(%rbp)
cmpb $0x0, -0xd(%rbp)
jne 0xc911
jmp 0xc9a1
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, %cx
movq 0x8cbb(%rip), %rax      # 0x155e0
movw %cx, 0x48(%rax)
movl -0xc(%rbp), %esi
xorl %edi, %edi
callq 0x4430
movsd 0x26e5(%rip), %xmm1     # 0xf020
addsd %xmm1, %xmm0
callq 0x4380
movsd %xmm0, -0x8(%rbp)
movq 0x8c78(%rip), %rdx      # 0x155c8
movsd -0x8(%rbp), %xmm0
leaq 0x8b44(%rip), %rdi      # 0x154a0
leaq 0x41e3(%rip), %rsi      # 0x10b46
movb $0x1, %al
callq 0x2190
movq 0x9077(%rip), %rdi      # 0x159e8
movl $0x3, %esi
xorl %edx, %edx
callq 0x21d0
cmpl $-0x1, %eax
jne 0xc984
jmp 0xc99c
movq 0x905d(%rip), %rdi      # 0x159e8
leaq 0x8b0e(%rip), %rsi      # 0x154a0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
callq 0x42a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: EScan
void EScan()
{
  int Shp;
  boolean Ok, Ship;

  Ok = true;
  waddstr(Cmdwin,"   Spock, scan the ");
  Shp = GetShp(&Ok, &Ship);
  if (Ships[0]->Dmge[(long)Snsr]) {
    NoSnsr();
    return;
  }
  if (Ship && Ok)
    Scan_(Shp);
  else
    BParam();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x1, -0x5(%rbp)
movq 0x9025(%rip), %rdi      # 0x159e8
leaq 0x4e21(%rip), %rsi      # 0x117eb
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
leaq -0x5(%rbp), %rdi
leaq -0x6(%rbp), %rsi
callq 0x93b0
movl %eax, -0x4(%rbp)
movq 0x8f95(%rip), %rax      # 0x15980
cmpb $0x0, 0xc1(%rax)
je 0xc9fb
callq 0x8dc0
jmp 0xca1c
movsbl -0x6(%rbp), %eax
cmpl $0x0, %eax
je 0xca17
movsbl -0x5(%rbp), %eax
cmpl $0x0, %eax
je 0xca17
movl -0x4(%rbp), %edi
callq 0x9000
jmp 0xca1c
callq 0x8cd0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: Engin
void Engin()
{
  short I, FORLIM;

  if (Ships[0]->Dmge[(long)Engn]) {
    waddstr(Cmdwin,"   Detonate the Engineering section, Scotty!");
    Endln();
    Endln();
    waddstr(Cmdwin,"Scott:  ");
    if (Bombed) {
      sprintf(scrstr,"What section? It's already gone, %s!", Title);
      waddstr(Cmdwin,scrstr);
    }
    else {
      sprintf(scrstr,"Aye, %s! Detonating Engineering now!", Title);
      waddstr(Cmdwin,scrstr);
      for (I = 0; I < ObjCount; I++) {
	if (Objects[I] != NULL) {
	  if (Objects[I]->ObTyp == 10)
	    Objects[I]->Tim_Del = 10000.0;
	}
      }
      Bombed = true;
    }
    Endln();
    return;
  }
  waddstr(Cmdwin,"   Scotty, jettison the Engineering section!!");
  Endln();
  Endln();
  waddstr(Cmdwin,"Scott:  Aye, Captain (oh, me poor engines!)");
  Endln();
  Endln();
  Detach(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x8f41(%rip), %rax      # 0x15980
cmpb $0x0, 0xc4(%rax)
je 0xcb7a
movq 0x8f95(%rip), %rdi      # 0x159e8
leaq 0x4da5(%rip), %rsi      # 0x117ff
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
callq 0x42a0
callq 0x42a0
movq 0x8f73(%rip), %rdi      # 0x159e8
leaq 0x4db0(%rip), %rsi      # 0x1182c
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
testb $0x1, 0x8f9f(%rip)      # 0x15a2c
je 0xcac8
movq 0x8b32(%rip), %rdx      # 0x155c8
leaq 0x8a03(%rip), %rdi      # 0x154a0
leaq 0x4d91(%rip), %rsi      # 0x11835
movb $0x0, %al
callq 0x2190
movq 0x8f36(%rip), %rdi      # 0x159e8
leaq 0x89e7(%rip), %rsi      # 0x154a0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
jmp 0xcb73
movq 0x8af9(%rip), %rdx      # 0x155c8
leaq 0x89ca(%rip), %rdi      # 0x154a0
leaq 0x4d7d(%rip), %rsi      # 0x1185a
movb $0x0, %al
callq 0x2190
movq 0x8efd(%rip), %rdi      # 0x159e8
leaq 0x89ae(%rip), %rsi      # 0x154a0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
movw $0x0, -0x2(%rbp)
movswl -0x2(%rbp), %eax
movzbl 0x8ac5(%rip), %ecx      # 0x155d2
cmpl %ecx, %eax
jge 0xcb6c
movswq -0x2(%rbp), %rcx
leaq 0x8ac3(%rip), %rax      # 0x155e0
cmpq $0x0, (%rax,%rcx,8)
je 0xcb5c
movswq -0x2(%rbp), %rcx
leaq 0x8ab0(%rip), %rax      # 0x155e0
movq (%rax,%rcx,8), %rax
movswl 0x4a(%rax), %eax
cmpl $0xa, %eax
jne 0xcb5a
movswq -0x2(%rbp), %rcx
leaq 0x8a97(%rip), %rax      # 0x155e0
movq (%rax,%rcx,8), %rax
movsd 0x2553(%rip), %xmm0     # 0xf0a8
movsd %xmm0, 0x30(%rax)
jmp 0xcb5c
jmp 0xcb5e
movw -0x2(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x2(%rbp)
jmp 0xcb02
movb $0x1, 0x8eb9(%rip)      # 0x15a2c
callq 0x42a0
jmp 0xcbc5
movq 0x8e67(%rip), %rdi      # 0x159e8
leaq 0x4cf7(%rip), %rsi      # 0x1187f
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
callq 0x42a0
callq 0x42a0
movq 0x8e45(%rip), %rdi      # 0x159e8
leaq 0x4d03(%rip), %rsi      # 0x118ad
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
callq 0x42a0
callq 0x42a0
xorl %edi, %edi
callq 0x7890
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: Srndr
void Srndr()
{
  sprintf(scrstr,"%s:  Uhura, open a channel to the %ss.", Name, Enemy);
  SEndln();
  sprintf(scrstr,"Uhura:  Aye, %s.", Title);
  SEndln();
  sprintf(scrstr,"%s:  This is Captain %s of the U.S.S. %s. Will",
    Name, Name, Snams[0]);
  SEndln();
  waddstr(Cmdwin,"   you accept my unconditional surrender?");
  Endln();
  if (Win == 4) {
    sprintf(scrstr,"Spock:  %s, we have already surrendered.", Title);
    SEndln();
    return;
  }
  if (Ct[2]) {
    sprintf(scrstr,"Spock:  The %ss have already refused.", Enemy);
    SEndln();
  } else {
    if (Enemy == Romulan) {
      waddstr(Cmdwin,"Spock:  The Romulans have not been known to have taken");
      Endln();
      waddstr(Cmdwin,"   prisoners");
      Endln();
    }
    Ct[2]=1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x89dd(%rip), %rdx      # 0x155b8
movq 0x8d8e(%rip), %rcx      # 0x15970
leaq 0x88b7(%rip), %rdi      # 0x154a0
leaq 0x4ce9(%rip), %rsi      # 0x118d9
movb $0x0, %al
callq 0x2190
callq 0x4320
movq 0x89c5(%rip), %rdx      # 0x155c8
leaq 0x8896(%rip), %rdi      # 0x154a0
leaq 0x4cef(%rip), %rsi      # 0x11900
movb $0x0, %al
callq 0x2190
callq 0x4320
movq 0x8994(%rip), %rdx      # 0x155b8
movq 0x898d(%rip), %rcx      # 0x155b8
movq 0x8cee(%rip), %r8       # 0x15920
leaq 0x8867(%rip), %rdi      # 0x154a0
leaq 0x4cd1(%rip), %rsi      # 0x11911
movb $0x0, %al
callq 0x2190
callq 0x4320
movq 0x8d95(%rip), %rdi      # 0x159e8
leaq 0x4ce6(%rip), %rsi      # 0x11940
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
callq 0x42a0
movzbl 0x8967(%rip), %eax      # 0x155d7
cmpl $0x4, %eax
jne 0xcc98
movq 0x894c(%rip), %rdx      # 0x155c8
leaq 0x881d(%rip), %rdi      # 0x154a0
leaq 0x4ce0(%rip), %rsi      # 0x1196a
movb $0x0, %al
callq 0x2190
callq 0x4320
jmp 0xcd15
cmpb $0x0, 0x8936(%rip)      # 0x155d5
je 0xccc4
movq 0x8cc8(%rip), %rdx      # 0x15970
leaq 0x87f1(%rip), %rdi      # 0x154a0
leaq 0x4cdd(%rip), %rsi      # 0x11993
movb $0x0, %al
callq 0x2190
callq 0x4320
jmp 0xcd15
movq 0x8ca5(%rip), %rax      # 0x15970
cmpq 0x85e6(%rip), %rax      # 0x152b8
jne 0xcd0e
movq 0x8d0d(%rip), %rdi      # 0x159e8
leaq 0x4cd7(%rip), %rsi      # 0x119b9
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
callq 0x42a0
movq 0x8cf0(%rip), %rdi      # 0x159e8
leaq 0x4cf1(%rip), %rsi      # 0x119f0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
callq 0x42a0
movb $0x1, 0x88c0(%rip)      # 0x155d5
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: EStop
void EStop()
{
  waddstr(Cmdwin,"Quit game");
  if (Yes())
    Stop = true;
  TCount = (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x87dd(%rip), %rdi      # 0x159e8
leaq 0x4f48(%rip), %rsi      # 0x1215a
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
callq 0x8c40
cmpb $0x0, %al
je 0xd22c
movb $0x1, 0x87f8(%rip)      # 0x15a24
movl $0xffffffff, 0x87f2(%rip) # imm = 0xFFFFFFFF
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x3fa4
cmpl $0x3, -0x8(%rbp)
jle 0x3fc8
movq 0xe04d(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0xb0f2(%rip), %rsi      # 0xf0a7
movb $0x0, %al
callq 0x21b0
movl $0x0, -0x4(%rbp)
jmp 0x408e
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd 0xb087(%rip), %xmm1     # 0xf060
ucomisd %xmm1, %xmm0
jne 0x3fe3
jp 0x3fe3
jmp 0x4007
movq 0xe00e(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0xb0d3(%rip), %rsi      # 0xf0c7
movb $0x0, %al
callq 0x21b0
movl $0x0, -0x4(%rbp)
jmp 0x408e
movl -0x8(%rbp), %edi
movsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0x2350
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x38(%rax)
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x58(%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x70(%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x68(%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rax)
movq -0x20(%rbp), %rax
movsd 0xafde(%rip), %xmm0     # 0xf060
movsd %xmm0, 0x78(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x4347
cmpl $0x2, -0xc(%rbp)
jle 0x436b
movq 0xdcaa(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0xadb3(%rip), %rsi      # 0xf10b
movb $0x0, %al
callq 0x21b0
movl $0x0, -0x4(%rbp)
jmp 0x44b2
movq -0x28(%rbp), %rdi
movl $0x4, %edx
movl %edx, %esi
callq 0x2410
cmpl $0x1, -0x8(%rbp)
jne 0x43a2
movq -0x28(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd 0xacc8(%rip), %xmm0     # 0xf060
movsd %xmm0, 0x18(%rax)
jmp 0x44ab
cmpl $0x0, -0x8(%rbp)
jne 0x4488
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %edx, -0x2c(%rbp)
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %edx, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x2c(%rbp), %rcx
movsd 0xac71(%rip), %xmm0     # 0xf060
movsd %xmm0, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x30(%rbp), %rcx
movsd 0xac59(%rip), %xmm0     # 0xf068
movsd %xmm0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd %xmm0, 0x18(%rax)
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd %xmm0, 0x18(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd %xmm0, 0x18(%rax)
jmp 0x44a9
movq 0xdb69(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0xac91(%rip), %rsi      # 0xf12a
movb $0x0, %al
callq 0x21b0
movl $0x0, -0x4(%rbp)
jmp 0x44b2
jmp 0x44ab
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELI3.c
// Function: Wtovel
void Wtovel(MAT4 W, AXIS u, real *omega, real *vel, POINT P)
{
	AXIS v;

	P[U]=1;

	u[X]=W[Z][Y];
	u[Y]=W[X][Z];
	u[Z]=W[Y][X];
	*omega=unitv(u,u);
	if(*omega!=0)
	{
		v[X]=W[X][U]; v[Y]=W[Y][U]; v[Z]=W[Z][U];
		cross(u,v,P);
		P[X] /= *omega;
		P[Y] /= *omega;
		P[Z] /= *omega;
		*vel=dot(u,v);
	}
	else
	{
		u[X]=W[X][U]; u[Y]=W[Y][U]; u[Z]=W[Z][U];
		P[X]=P[Y]=P[Z]=0;
		*vel=unitv(u,u);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsd 0xab78(%rip), %xmm0     # 0xf060
movsd %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
movsd 0x48(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20f0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x454f
jp 0x454f
jmp 0x45ed
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movsd 0x38(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movsd 0x58(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x23b0
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movq -0x28(%rbp), %rax
movsd 0x10(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2030
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x465a
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x38(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd 0x58(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20f0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELI3.c
// Function: cardantoM
void cardantoM(real *q, int i, int j, int k, POINT O, MAT4 m)
{
	int l;

	cardantor4(q,i,j,k,m);
	for(l=0;l<4;l++)
		m[l][U]=O[l];
	m[U][X]=m[U][Y]=m[U][Z]=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %r8
movl $0x4, %r9d
callq 0x21c0
movl $0x0, -0x2c(%rbp)
cmpl $0x4, -0x2c(%rbp)
jge 0x50d2
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %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 0x50a0
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)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELI3.c
// Function: cardantoW
void cardantoW(real *q, real *qp, int i, int j, int k, POINT O, MAT4 W)
{
	int l,m;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movq 0x10(%rbp), %r9
movl $0x4, (%rsp)
callq 0x2100
movl $0x0, -0x2c(%rbp)
cmpl $0x2, -0x2c(%rbp)
jg 0x51f1
movq 0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
movl $0x0, -0x30(%rbp)
cmpl $0x2, -0x30(%rbp)
jg 0x51e1
movq 0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq 0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd 0x18(%rax), %xmm1
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x5173
jmp 0x51e3
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x514b
movq 0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x78(%rax)
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)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x18(%rbp), %rax
movq %rax, (%rsp)
movl $0x4, 0x8(%rsp)
callq 0x20e0
movl $0x0, -0x28(%rbp)
cmpl $0x2, -0x28(%rbp)
jg 0x5710
movq 0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
movl $0x0, -0x2c(%rbp)
cmpl $0x2, -0x2c(%rbp)
jg 0x5700
movq 0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq 0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd 0x18(%rax), %xmm1
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5692
jmp 0x5702
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x566a
movq 0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x78(%rax)
movq 0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x70(%rax)
movq 0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x68(%rax)
movq 0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %ecx
leaq -0x70(%rbp), %r8
movl $0x3, %r9d
callq 0x2210
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %ecx
leaq -0xc0(%rbp), %r8
movl $0x3, %r9d
callq 0x2060
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
mulsd 0x10(%rax), %xmm0
movsd %xmm0, -0xe0(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
mulsd 0x10(%rax), %xmm0
movsd %xmm0, -0xd8(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
mulsd 0x8(%rax), %xmm0
movsd %xmm0, -0xd0(%rbp)
leaq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x100(%rbp), %rdx
movl $0x3, %r8d
movl $0x1, %r9d
movl %r8d, %ecx
callq 0x20b0
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
leaq -0x120(%rbp), %rdx
movl $0x3, %r8d
movl $0x1, %r9d
movl %r8d, %ecx
callq 0x20b0
leaq -0x100(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq 0x10(%rbp), %rdx
movl $0x3, %ecx
movl $0x1, %r8d
callq 0x21f0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
je 0x5fa9
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x5f7d
movl -0x24(%rbp), %eax
movl %eax, -0x74(%rbp)
jmp 0x5f83
movl -0x28(%rbp), %eax
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
cmpl $0x0, %eax
jl 0x5fa9
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0x5f9b
movl -0x24(%rbp), %eax
movl %eax, -0x78(%rbp)
jmp 0x5fa1
movl -0x28(%rbp), %eax
movl %eax, -0x78(%rbp)
movl -0x78(%rbp), %eax
cmpl $0x2, %eax
jle 0x5fcd
movq 0xc048(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x9220(%rip), %rsi      # 0xf1da
movb $0x0, %al
callq 0x21b0
movl $0x0, -0x4(%rbp)
jmp 0x6075
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
subsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
subsd 0x8(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
subsd (%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
subsd 0x8(%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
movq -0x30(%rbp), %r8
movl 0x10(%rbp), %r9d
callq 0x2240
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
movl $0x4, (%rsp)
callq 0x2230
movl $0x0, -0x2c(%rbp)
cmpl $0x3, -0x2c(%rbp)
jg 0x632b
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %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 0x62f9
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)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELI3.c
// Function: frame4V
void frame4V(POINT P1, VECTOR v1, VECTOR v2, int a1, int a2, MAT4 m)
{
	int i;

	frameV(v1,v2, 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %r8
movl $0x4, %r9d
callq 0x2240
movl $0x0, -0x2c(%rbp)
cmpl $0x3, -0x2c(%rbp)
jg 0x63d5
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %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 0x63a3
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)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm1
movq -0x10(%rbp), %rax
subsd (%rax), %xmm1
movq -0x8(%rbp), %rax
movsd (%rax), %xmm2
movq -0x10(%rbp), %rax
subsd (%rax), %xmm2
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
subsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm3
movq -0x10(%rbp), %rax
subsd 0x8(%rax), %xmm3
mulsd %xmm3, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
subsd 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm2
movq -0x10(%rbp), %rax
subsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x23f0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm1
movq -0x10(%rbp), %rax
addsd (%rax), %xmm1
movsd 0x8ad8(%rip), %xmm0     # 0xf080
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
addsd 0x8(%rax), %xmm1
movsd 0x8ab2(%rip), %xmm0     # 0xf080
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm1
movq -0x10(%rbp), %rax
addsd 0x10(%rax), %xmm1
movsd 0x8a8b(%rip), %xmm0     # 0xf080
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rax
movsd 0x8a52(%rip), %xmm0     # 0xf060
movsd %xmm0, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x8aa5(%rip), %rsi      # 0xf218
movb $0x0, %al
callq 0x21b0
movl $0x0, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0x67f8
cmpl $0x2, -0x20(%rbp)
je 0x67db
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x67d9
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
leaq 0x8a56(%rip), %rsi      # 0xf21d
movb $0x1, %al
callq 0x21b0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6794
jmp 0x67db
movq -0x8(%rbp), %rdi
leaq 0x8e07(%rip), %rsi      # 0xf5ed
movb $0x0, %al
callq 0x21b0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6781
movq -0x8(%rbp), %rdi
leaq 0x8de9(%rip), %rsi      # 0xf5ec
movb $0x0, %al
callq 0x21b0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xa0, %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 -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x22d0
movq -0x20(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x4, %edx
movl $0x3, %r9d
movl %r9d, %ecx
movl %r9d, %r8d
callq 0x2190
leaq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x90(%rbp), %rdx
movl $0x3, %r8d
movl $0x1, %r9d
movl %r8d, %ecx
callq 0x20b0
leaq -0x90(%rbp), %rdi
movq -0x20(%rbp), %r8
movl $0x3, %esi
movl $0x4, %r9d
movl $0x1, %ecx
movl %r9d, %edx
movl $0x4, (%rsp)
callq 0x20d0
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELI4.c
// Function: Gtomegapto
void Gtomegapto(MAT3 G, VECTOR omegapto)
{
	MAT3 Gt;              /* transpose of matrix G */
	MAT3 OMEGAPTO;        /* angular velocity matrix */

	transp3(G,Gt);
	sub3(G,Gt,OMEGAPTO);
	rmolt3(OMEGAPTO,0.5,OMEGAPTO); /* OMEGAPTO=1/2(G-G(t)) (t)= transp. */
	mtov3(omegapto,OMEGAPTO);      /* a. v. matrix to vector */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x3, %ecx
movl %ecx, %edx
callq 0x2070
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
movl $0x3, %r8d
movl %r8d, %ecx
callq 0x2420
leaq -0xb0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movsd 0x8646(%rip), %xmm0     # 0xf080
movl $0x3, %ecx
movl %ecx, %edx
callq 0x2430
leaq -0xb0(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x3, %esi
callq 0x23e0
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x6d84
cmpl $0x2, -0x14(%rbp)
jg 0x6d84
cmpl $0x0, -0x18(%rbp)
jl 0x6d84
cmpl $0x2, -0x18(%rbp)
jg 0x6d84
cmpl $0x0, -0x1c(%rbp)
jl 0x6d84
cmpl $0x2, -0x1c(%rbp)
jg 0x6d84
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0x6d84
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x6da8
movq 0xb26d(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x84bb(%rip), %rsi      # 0xf250
movb $0x0, %al
callq 0x21b0
movl $0x0, -0x4(%rbp)
jmp 0x6e8c
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movl $0x4, %edx
movl $0x3, %r9d
movl %r9d, %ecx
movl %r9d, %r8d
callq 0x2190
leaq -0x80(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
movl $0x3, %esi
movq %rax, (%rsp)
callq 0x22b0
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x6e28
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x2120
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6e0d
jp 0x6e0d
jmp 0x6e64
movq -0x30(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x2120
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6e28
jp 0x6e28
jmp 0x6e64
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x6e85
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x2380
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6e4b
jp 0x6e4b
jmp 0x6e64
movq -0x30(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x2380
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6e85
jp 0x6e85
movq 0xb18d(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x83fd(%rip), %rsi      # 0xf272
movb $0x0, %al
callq 0x21b0
movl $0x0, -0x4(%rbp)
jmp 0x6e8c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x7a92
jp 0x7a92
movq 0xa584(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x78bc(%rip), %rsi      # 0xf33a
movb $0x0, %al
callq 0x21b0
movsd 0x75d3(%rip), %xmm0     # 0xf060
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x2, -0x2c(%rbp)
jg 0x7ae8
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd -0x10(%rbp), %xmm2
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x38(%rbp), %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7a99
movq -0x28(%rbp), %rax
movsd 0x756c(%rip), %xmm0     # 0xf060
movsd %xmm0, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, %rax
leaq 0x10(%rbp), %rsi
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rsi
leaq -0x40(%rbp), %rdx
callq 0x22e0
movq -0x48(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2180
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2260
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Alessandro-Barbieri[P]SpaceLib/src/SPACELI4.c
// Function: project
real project(POINT P, PLANE pl, POINT I)
{
	real r;

	I[U]=1;
	r=distpp(pl,P);
	rmoltv(pl,r,I);
	subv(P,I,I);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsd 0x73d0(%rip), %xmm0     # 0xf060
movsd %xmm0, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2310
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rsi
movl $0x3, %edx
movl $0x1, %ecx
callq 0x2430
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x3, %ecx
movl $0x1, %r8d
callq 0x2420
movsd -0x20(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7d7d
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7d3e
movsd -0x20(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x2370
movq -0x58(%rbp), %rsi
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rsi
callq 0x2030
movq -0x58(%rbp), %rsi
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %edx
callq 0x2140
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm1
movaps 0x7111(%rip), %xmm0     # 0xf240
pand %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x8166
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x815a
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
jmp 0x8164
movq -0x18(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x81d9
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0x20, %rdi
movsd -0x38(%rbp), %xmm0
leaq -0x50(%rbp), %rsi
callq 0x2200
movq -0x58(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x3, %ecx
movl $0x1, %r8d
callq 0x21f0
movq -0x10(%rbp), %rax
movsd 0x6e8c(%rip), %xmm0     # 0xf060
movsd %xmm0, 0x18(%rax)
addq $0x60, %rsp
popq %rbp
retq
nop