LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/hyc[P]trek73c/trekx.c
// Function: Indigits
void Indigits(X)
int *X;
{
  reg int I, J;

  for (I = 0; I <= 9; I++)
    X[I] = 0;
  J = (-1);
  mygetstr(Cmdwin,scrstr,true);
  for (I = 0; scrstr[I]; I++) {
    if (isdigit(scrstr[I])) {
      J++;
      X[J] = scrstr[I]-'0';
    }
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
movq 0xbd6f(%rip), %rdi      # 0x139f8
leaq 0xb820(%rip), %rsi      # 0x134b0
movl $0x1, %edx
callq 0x249f
movb 0xb80f(%rip), %bpl      # 0x134b0
testb %bpl, %bpl
je 0x7ce0
callq 0x2170
movq (%rax), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
leaq 0xb7f7(%rip), %rdx      # 0x134b1
movsbq %bpl, %rsi
testb $0x8, 0x1(%rax,%rsi,2)
je 0x7cd5
movsbl %bpl, %esi
addl $-0x30, %esi
movslq %ecx, %rdi
incl %ecx
movl %esi, 0x4(%rbx,%rdi,4)
movb (%rdx), %bpl
incq %rdx
testb %bpl, %bpl
jne 0x7cba
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hyc[P]trek73c/trekx.c
// Function: GetShp
int GetShp(Ok, Shp)
boolean *Ok, *Shp;
{
  int I, J, X, Y;

  getyx(Cmdwin, Y, X);
  *Shp = true;
  mygetstr(Cmdwin,scrstr,false);
  J = 0;
  if (scrstr[0] != '\0') {
    if (islower(scrstr[0]))
      scrstr[0]=toupper(scrstr[0]);
    for (I = 1; I <= Enemies; I++) {
      if (scrstr[0] == Snams[I][0]) {
	mvwaddstr(Cmdwin, Y, X, Snams[I]);
	waddstr(Cmdwin,"\n");
	wclrtoeol(Cmdwin);
	wrefresh(Cmdwin);
	*Ok = true;
	J = I;
	if (Ships[J] == NULL)
	  *Ok = false;
	break;
      }
    }
  }
  if (J != 0)
    return J;
  I = (sscanf(scrstr, "%d", &J) == 0);
  if (I == 0)
    *Shp = false;
  return J;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xba00(%rip), %rax      # 0x139f8
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x800c
movswl (%rax), %r15d
testq %rax, %rax
je 0x8015
movswl 0x2(%rax), %ebp
movb $0x1, (%rbx)
movq 0xb9d9(%rip), %rdi      # 0x139f8
leaq 0xb48a(%rip), %rsi      # 0x134b0
xorl %edx, %edx
callq 0x249f
movl $0x0, 0x4(%rsp)
movsbq 0xb473(%rip), %r12      # 0x134b0
testq %r12, %r12
je 0x8127
callq 0x2170
movq (%rax), %rax
testb $0x2, 0x1(%rax,%r12,2)
je 0x8068
callq 0x2110
movq (%rax), %rax
movb (%rax,%r12,4), %al
movb %al, 0xb448(%rip)       # 0x134b0
movzbl 0xb571(%rip), %eax      # 0x135e0
testq %rax, %rax
je 0x8127
movb 0xb432(%rip), %cl       # 0x134b0
negq %rax
movl $0x1, %r12d
leaq 0xb8a2(%rip), %r13      # 0x13930
movq (%r13,%r12,8), %rdx
cmpb (%rdx), %cl
je 0x80a9
leaq (%rax,%r12), %rdx
incq %rdx
incq %r12
cmpq $0x1, %rdx
jne 0x808e
jmp 0x8127
movq 0xb948(%rip), %rdi      # 0x139f8
movl %r15d, %esi
movl %ebp, %edx
callq 0x21e0
cmpl $-0x1, %eax
je 0x80dc
leaq (,%r12,8), %rax
movq 0xb92a(%rip), %rdi      # 0x139f8
movq (%rax,%r13), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
movq 0xb915(%rip), %rdi      # 0x139f8
leaq 0x5b47(%rip), %rsi      # 0xdc31
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
movq 0xb8fd(%rip), %rdi      # 0x139f8
callq 0x2220
movq 0xb8f1(%rip), %rdi      # 0x139f8
callq 0x2190
movb $0x1, (%r14)
movl %r12d, 0x4(%rsp)
leaq 0xb874(%rip), %rax      # 0x13990
cmpq $0x0, (%rax,%r12,8)
jne 0x8127
movb $0x0, (%r14)
movl 0x4(%rsp), %eax
testl %eax, %eax
jne 0x8154
leaq 0xb37a(%rip), %rdi      # 0x134b0
leaq 0x6410(%rip), %rsi      # 0xe54d
leaq 0x4(%rsp), %rdx
xorl %eax, %eax
callq 0x20b0
testl %eax, %eax
je 0x8150
movb $0x0, (%rbx)
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hyc[P]trek73c/trekx.c
// Function: TFire
void TFire()
{
  int I, Bad;
  Digs Temp;
  boolean Stat[6];
  boolean Ok;
  reg Srec *WITH;

  waddstr(Cmdwin,"   Fire Tubes [1-6] ");
  Indigits(Temp);
  Ok = true;
  Bad = 0;
  for (I = 0; I <= 5; I++)
    Stat[I] = true;
  WITH = Ships[0];
  for (I = 0; I <= 5; I++) {
    if (Temp[I] > 0 && Temp[I] < 7) {
      if (WITH->Tstat[Temp[I] - 1] < 0 ||
	  WITH->TDepl[Temp[I] - 1] > 135 && WITH->TDepl[Temp[I] - 1] < 225 ||
	  WITH->Tengy[Temp[I] - 1] <= 0) {
	Bad++;
	Stat[Temp[I] - 1] = false;
      } else
	WITH->Tstat[Temp[I] - 1] += 100;
    } else if (Temp[I] > 6)
      Ok = false;
  }
  if (!Ok) {
    BParam();
    return;
  }
  if (Bad <= 0)
    return;
  waddstr(Cmdwin," Computer: Tube");
  if (Bad > 1)
    waddch(Cmdwin,'s');
  for (I = 1; I <= 6; I++) {
    if (!Stat[I - 1]) {
      sprintf(scrstr,"%2d", I);
      waddstr(Cmdwin,scrstr);
    }
  }
  waddstr(Cmdwin," unable to fire.");
  Endln();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq 0xb42d(%rip), %rdi      # 0x139f8
leaq 0x6235(%rip), %rsi      # 0xe807
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
leaq 0x10(%rsp), %rdi
callq 0x7c6a
movw $0x101, 0xc(%rsp)       # imm = 0x101
movl $0x1010101, 0x8(%rsp)   # imm = 0x1010101
xorl %ecx, %ecx
movb $0x1, %al
movq 0xb390(%rip), %rdx      # 0x13990
movsd 0x4ab0(%rip), %xmm0     # 0xd0b8
movsd 0x4a48(%rip), %xmm1     # 0xd058
xorl %esi, %esi
xorl %ebx, %ebx
movslq 0x10(%rsp,%rsi,4), %rdi
leal -0x1(%rdi), %r8d
cmpl $0x5, %r8d
ja 0x8666
decq %rdi
movl %edi, %r8d
cmpw $0x0, 0x110(%rdx,%r8,2)
js 0x8671
movsd 0xe0(%rdx,%r8,8), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x864b
ucomisd %xmm2, %xmm1
ja 0x8671
movslq %r8d, %r8
cmpw $0x0, 0xc6(%rdx,%r8,2)
jle 0x8671
addw $0x64, 0x110(%rdx,%r8,2)
jmp 0x8678
cmpl $0x7, %edi
movzbl %al, %eax
cmovgel %ecx, %eax
jmp 0x8678
incl %ebx
movb $0x0, 0x8(%rsp,%rdi)
incq %rsi
cmpq $0x6, %rsi
jne 0x8614
testb %al, %al
je 0x872c
testl %ebx, %ebx
jle 0x873a
movq 0xb360(%rip), %rdi      # 0x139f8
leaq 0x617d(%rip), %rsi      # 0xe81c
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
cmpl $0x1, %ebx
je 0x86bf
movq 0xb343(%rip), %rdi      # 0x139f8
movl $0x73, %esi
callq 0x2160
movq $-0x6, %r15
leaq 0xade3(%rip), %rbx      # 0x134b0
leaq 0x611e(%rip), %r14      # 0xe7f2
cmpb $0x0, 0xe(%rsp,%r15)
jne 0x8701
leal 0x7(%r15), %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x21a0
movq 0xb304(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
incq %r15
jne 0x86d4
movq 0xb2eb(%rip), %rdi      # 0x139f8
leaq 0x60e2(%rip), %rsi      # 0xe7f6
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3c58
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7a95
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hyc[P]trek73c/trekx.c
// Function: MNav
void MNav()
{
  double Temp;
  int Code;
  boolean Ok;

  Ok = true;
  waddstr(Cmdwin,"   Helmsman, come to course [0-360] ");
  mygetstr(Cmdwin,scrstr,true);
  Code = (sscanf(scrstr, "%lg", &Temp) == 0);
  if (Code > 0)
    Ok = false;
  else
    Objects[0]->Des_Crs = Temp;
  Ok = Getwarp(Ok);
  if (Ok) {
    Objects[0]->Trgt = 0;
    sprintf(scrstr,"Sulu: Aye, %s.",Title);
    SEndln();
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0xaa7c(%rip), %rdi      # 0x139f8
leaq 0x5a3c(%rip), %rsi      # 0xe9bf
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
movq 0xaa64(%rip), %rdi      # 0x139f8
leaq 0xa515(%rip), %r14      # 0x134b0
movq %r14, %rsi
movl $0x1, %edx
callq 0x249f
leaq 0x63f9(%rip), %rsi      # 0xf3a8
xorl %ebx, %ebx
movq %rsp, %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x20b0
testl %eax, %eax
je 0x8fd8
movsd (%rsp), %xmm0
movq 0xa622(%rip), %rax      # 0x135f0
movsd %xmm0, 0x18(%rax)
movl $0x1, %ebx
movl %ebx, %edi
callq 0x7bac
testb %al, %al
je 0x9028
movq 0xa606(%rip), %rax      # 0x135f0
movw $0x0, 0x48(%rax)
movq 0xa5e1(%rip), %rdx      # 0x135d8
leaq 0xa4b2(%rip), %rbx      # 0x134b0
leaq 0x59df(%rip), %rsi      # 0xe9e4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21a0
movq 0xa9e2(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/hyc[P]trek73c/trekx.c
// Function: PNav
void PNav()
{
  double Temp;
  int Shp;
  boolean Ok, Ship;

  if (Ships[0]->Dmge[(long)Comp]) {
    NoComp();
    return;
  }
  Ok = false;
  waddstr(Cmdwin,"   Chekov, pursue the ");
  Shp = GetShp(&Ok, &Ship);
  if (!(Ship && Ok)) {
    ChWhat();
    return;
  }
  Ok = Getwarp(Ok);
  if (!Ok) {
    return;
  }
  Objects[0]->Trgt = Shp+1;
  Temp = Bearing(0, Shp);
  Endln();
  sprintf(scrstr,"Chekov: Aye, %s, coming to course %3.0f", Title, Temp);
  SEndln();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0xa950(%rip), %rax      # 0x13990
cmpb $0x0, 0xc0(%rax)
je 0x9057
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7b6d
leaq 0x6(%rsp), %r14
movb $0x0, (%r14)
movq 0xa991(%rip), %rdi      # 0x139f8
leaq 0x5985(%rip), %rsi      # 0xe9f3
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
leaq 0x7(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7fe0
movl %eax, %ebx
cmpb $0x0, (%r15)
setne %cl
movb (%r14), %al
testb %al, %al
setne %dl
testb %dl, %cl
je 0x9117
movsbl %al, %edi
callq 0x7bac
movb %al, 0x6(%rsp)
testb %al, %al
je 0x9125
movl %ebx, %eax
incl %eax
movq 0xa538(%rip), %rcx      # 0x135f0
movw %ax, 0x48(%rcx)
xorl %edi, %edi
movl %ebx, %esi
callq 0x3d75
movsd %xmm0, 0x8(%rsp)
callq 0x3c58
movq 0xa501(%rip), %rdx      # 0x135d8
leaq 0xa3d2(%rip), %rbx      # 0x134b0
leaq 0x5925(%rip), %rsi      # 0xea0a
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x21a0
movq 0xa8fc(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3c58
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7add
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hyc[P]trek73c/trekx.c
// Function: ASrndr
void ASrndr()
{
  sprintf(scrstr,"%s: Uhura, open a hailing frequency 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. I give you",
    Name, Name, Snams[0]);
  SEndln();
  waddstr(Cmdwin,"   one last chance to surrender before we resume our attack.");
  Endln();
  if (Win == 5) {
    sprintf(scrstr,"%s: %s, we are already complying with your previous request!",
      Capt, Name);
    SEndln();
    return;
  }
  if (Ct[3]) {
    sprintf(scrstr,"Spock: %s, our offer has already been refused.", Title);
    SEndln();
  } else
    Ct[3]=1;
}

// Assembly:
pushq %rbx
movq 0x9fdc(%rip), %rdx      # 0x135c8
movq 0xa38d(%rip), %rcx      # 0x13980
leaq 0x9eb6(%rip), %rbx      # 0x134b0
leaq 0x57e5(%rip), %rsi      # 0xede6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21a0
movq 0xa3e6(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
movq 0x9fad(%rip), %rdx      # 0x135d8
leaq 0x57e4(%rip), %rsi      # 0xee16
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21a0
movq 0xa3b5(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
movq 0x9f6c(%rip), %rcx      # 0x135c8
movq 0xa2cd(%rip), %r8       # 0x13930
leaq 0x57bc(%rip), %rsi      # 0xee26
movq %rbx, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x21a0
movq 0xa37a(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
movq 0xa361(%rip), %rdi      # 0x139f8
leaq 0x57bc(%rip), %rsi      # 0xee5a
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
cmpb $0x5, 0x9f34(%rip)      # 0x135e8
jne 0x96de
movq 0xa2cb(%rip), %rdx      # 0x13988
movq 0x9f04(%rip), %rcx      # 0x135c8
leaq 0x9de5(%rip), %rbx      # 0x134b0
leaq 0x57c5(%rip), %rsi      # 0xee97
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21a0
jmp 0x9706
cmpb $0x0, 0x9f02(%rip)      # 0x135e7
je 0x9720
movq 0x9eea(%rip), %rdx      # 0x135d8
leaq 0x9dbb(%rip), %rbx      # 0x134b0
leaq 0x57d8(%rip), %rsi      # 0xeed4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21a0
movq 0xa2eb(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
popq %rbx
jmp 0x3c58
movb $0x1, 0x9ec0(%rip)      # 0x135e7
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq 0x9e97(%rip), %rdx      # 0x135c8
leaq 0x9d78(%rip), %rbx      # 0x134b0
leaq 0x57c4(%rip), %rsi      # 0xef03
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21a0
movq 0xa2a8(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
cmpb $0x0, 0x9e7b(%rip)      # 0x135e4
je 0x97ab
movq 0x9e66(%rip), %rdx      # 0x135d8
movq 0xa207(%rip), %rcx      # 0x13980
leaq 0x9d30(%rip), %rbx      # 0x134b0
leaq 0x5799(%rip), %rsi      # 0xef20
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21a0
movq 0xa260(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
popq %rbx
jmp 0x3c58
movq 0xa246(%rip), %rdi      # 0x139f8
leaq 0x578f(%rip), %rsi      # 0xef48
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
movq 0xa22e(%rip), %rdi      # 0x139f8
leaq 0x9cdf(%rip), %rsi      # 0x134b0
movl $0x1, %edx
callq 0x249f
movzbl 0x9cce(%rip), %eax      # 0x134b0
testl %eax, %eax
je 0x9830
andl $-0x21, %eax
cmpl $0x50, %eax
je 0x9836
cmpl $0x45, %eax
jne 0x9830
movq 0x9df6(%rip), %rax      # 0x135f0
movsd 0x20(%rax), %xmm2
addsd 0x3801(%rip), %xmm2     # 0xd008
movsd %xmm2, 0x20(%rax)
movq 0xa17d(%rip), %rcx      # 0x13990
movzbl 0x18(%rcx), %ecx
cvtsi2sd %ecx, %xmm1
movsd 0x38d5(%rip), %xmm0     # 0xd0f8
ucomisd %xmm1, %xmm2
jbe 0x983e
movsd %xmm1, 0x20(%rax)
jmp 0x983e
popq %rbx
jmp 0x7add
movsd 0x37ca(%rip), %xmm0     # 0xd008
movq 0xa14b(%rip), %rax      # 0x13990
xorpd %xmm1, %xmm1
movupd %xmm1, 0x90(%rax)
movupd %xmm1, 0x80(%rax)
movzbl 0x9960(%rip), %eax      # 0x131c0
testq %rax, %rax
je 0x987c
movq 0xa124(%rip), %rcx      # 0x13990
xorl %edx, %edx
movsd %xmm0, 0x40(%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x986e
movb $0x1, 0x9d61(%rip)      # 0x135e4
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0xffffffff, 0x8e90(%rip) # imm = 0xFFFFFFFF
movq 0x8de1(%rip), %rax      # 0x13990
cmpb $0x0, 0xc1(%rax)
jne 0x7b49
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4a87(%rip), %rbx      # 0xf651
leaq 0x88df(%rip), %r14      # 0x134b0
leaq 0x4a98(%rip), %r15      # 0xf670
movq 0x8e19(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
movq 0x8e05(%rip), %rdi      # 0x139f8
movq %r14, %rsi
movl $0x1, %edx
callq 0x249f
movq %r14, %rdi
callq 0x21d0
leal -0x2711(%rax), %ebp
cmpl $0xffffd921, %ebp       # imm = 0xFFFFD921
jae 0xac38
movq 0x8ddb(%rip), %rdi      # 0x139f8
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
movq 0x8dc7(%rip), %rdi      # 0x139f8
callq 0x2190
jmp 0xac3e
movl %eax, 0x8dea(%rip)      # 0x13a28
cmpl $0xffffd921, %ebp       # imm = 0xFFFFD921
jb 0xabd8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x8d2f(%rip), %rax      # 0x13990
cmpb $0x0, 0xc0(%rax)
je 0xac78
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7b6d
leaq 0xe(%rsp), %r14
movb $0x0, (%r14)
movq 0x8d70(%rip), %rdi      # 0x139f8
leaq 0x4a0a(%rip), %rsi      # 0xf699
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
leaq 0xf(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7fe0
movl %eax, %ebx
cmpb $0x0, (%r15)
setne %cl
movb (%r14), %al
testb %al, %al
setne %dl
testb %dl, %cl
je 0xadc3
movsbl %al, %edi
callq 0x7bac
movb %al, 0xe(%rsp)
testb %al, %al
je 0xadd1
movl %ebx, %eax
notl %eax
movq 0x890f(%rip), %rcx      # 0x135f0
movw %ax, 0x48(%rcx)
xorl %edi, %edi
movl %ebx, %esi
callq 0x3d75
addsd 0x2322(%rip), %xmm0     # 0xd018
movsd %xmm0, 0x10(%rsp)
movsd 0x231c(%rip), %xmm2     # 0xd020
divsd %xmm2, %xmm0
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x22b0
movsd 0x230b(%rip), %xmm0     # 0xd028
movsd (%rbx), %xmm1
mulsd %xmm0, %xmm1
addsd 0x10(%rsp), %xmm1
addsd %xmm1, %xmm0
movsd 0x22e9(%rip), %xmm3     # 0xd020
movapd %xmm3, %xmm2
cmpnlesd %xmm1, %xmm2
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
addsd %xmm2, %xmm3
xorpd %xmm1, %xmm1
movapd %xmm2, %xmm0
cmpltsd %xmm1, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm2, %xmm0
orpd %xmm3, %xmm0
movq 0x8868(%rip), %rdx      # 0x135d8
leaq 0x8739(%rip), %rdi      # 0x134b0
leaq 0x3c8c(%rip), %rsi      # 0xea0a
movb $0x1, %al
callq 0x21a0
movq 0x8c6c(%rip), %rdi      # 0x139f8
movl $0x3, %esi
xorl %edx, %edx
callq 0x21e0
cmpl $-0x1, %eax
je 0xadb5
movq 0x8c54(%rip), %rdi      # 0x139f8
leaq 0x8705(%rip), %rsi      # 0x134b0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3c58
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7add
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
leaq 0xf(%rsp), %rbx
movb $0x1, (%rbx)
movq 0x8c09(%rip), %rdi      # 0x139f8
leaq 0x48b9(%rip), %rsi      # 0xf6af
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
leaq 0xe(%rsp), %rsi
movq %rbx, %rdi
callq 0x7fe0
movq 0x8b7c(%rip), %rcx      # 0x13990
cmpb $0x0, 0xc1(%rcx)
je 0xae27
addq $0x10, %rsp
popq %rbx
jmp 0x7b49
cmpb $0x0, 0xe(%rsp)
je 0xae41
cmpb $0x0, 0xf(%rsp)
je 0xae41
movl %eax, %edi
addq $0x10, %rsp
popq %rbx
jmp 0x7ce7
addq $0x10, %rsp
popq %rbx
jmp 0x7a95
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq 0x8b3d(%rip), %rax      # 0x13990
cmpb $0x0, 0xc4(%rax)
movq 0x8b97(%rip), %rdi      # 0x139f8
je 0xaed7
leaq 0x4859(%rip), %rsi      # 0xf6c3
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
callq 0x3c58
movq 0x8b73(%rip), %rdi      # 0x139f8
leaq 0x4864(%rip), %rsi      # 0xf6f0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
movq 0x873b(%rip), %rdx      # 0x135d8
cmpb $0x1, 0x8b98(%rip)      # 0x13a3c
jne 0xaf1c
leaq 0x8603(%rip), %rbx      # 0x134b0
leaq 0x4845(%rip), %rsi      # 0xf6f9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21a0
movq 0x8b33(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
jmp 0xaf8e
leaq 0x4865(%rip), %rsi      # 0xf743
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
callq 0x3c58
movq 0x8aff(%rip), %rdi      # 0x139f8
leaq 0x4871(%rip), %rsi      # 0xf771
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
callq 0x3c58
xorl %edi, %edi
popq %rbx
jmp 0x69ff
leaq 0x858d(%rip), %rbx      # 0x134b0
leaq 0x47f4(%rip), %rsi      # 0xf71e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21a0
movq 0x8abd(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
movzbl 0x8693(%rip), %eax      # 0x135e2
testl %eax, %eax
je 0xaf87
xorl %ecx, %ecx
leaq 0x8694(%rip), %rdx      # 0x135f0
movabsq $0x40c3880000000000, %rsi # imm = 0x40C3880000000000
movswq %cx, %rdi
movq (%rdx,%rdi,8), %rdi
testq %rdi, %rdi
je 0xaf7e
cmpw $0xa, 0x4a(%rdi)
jne 0xaf7e
movq %rsi, 0x30(%rdi)
incl %ecx
movswl %cx, %edi
cmpl %eax, %edi
jl 0xaf66
movb $0x1, 0x8aae(%rip)      # 0x13a3c
popq %rbx
jmp 0x3c58
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq 0x862c(%rip), %rdx      # 0x135c8
movq 0x89dd(%rip), %rcx      # 0x13980
leaq 0x8506(%rip), %rbx      # 0x134b0
leaq 0x47ec(%rip), %rsi      # 0xf79d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21a0
movq 0x8a36(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
movq 0x85fd(%rip), %rdx      # 0x135d8
leaq 0x47e2(%rip), %rsi      # 0xf7c4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21a0
movq 0x8a05(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
movq 0x85bc(%rip), %rcx      # 0x135c8
movq 0x891d(%rip), %r8       # 0x13930
leaq 0x47bb(%rip), %rsi      # 0xf7d5
movq %rbx, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x21a0
movq 0x89ca(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
movq 0x89b1(%rip), %rdi      # 0x139f8
leaq 0x47b6(%rip), %rsi      # 0xf804
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
cmpb $0x4, 0x8584(%rip)      # 0x135e8
jne 0xb07d
movq 0x856b(%rip), %rdx      # 0x135d8
leaq 0x843c(%rip), %rbx      # 0x134b0
leaq 0x47b3(%rip), %rsi      # 0xf82e
jmp 0xb09b
cmpb $0x0, 0x8562(%rip)      # 0x135e6
movq 0x88f5(%rip), %rdx      # 0x13980
je 0xb0bf
leaq 0x841c(%rip), %rbx      # 0x134b0
leaq 0x47bc(%rip), %rsi      # 0xf857
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21a0
movq 0x894c(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
popq %rbx
jmp 0x3c58
cmpq 0x8202(%rip), %rdx      # 0x132c8
jne 0xb102
movq 0x8929(%rip), %rdi      # 0x139f8
leaq 0x47a7(%rip), %rsi      # 0xf87d
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
movq 0x890c(%rip), %rdi      # 0x139f8
leaq 0x47c1(%rip), %rsi      # 0xf8b4
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
movb $0x1, 0x84dd(%rip)      # 0x135e6
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/hyc[P]trek73c/trekx.c
// Function: EStop
void EStop()
{
  waddstr(Cmdwin,"Quit game");
  if (Yes())
    Stop = true;
  TCount = (-1);
}

// Assembly:
pushq %rax
movq 0x835e(%rip), %rdi      # 0x139f8
leaq 0x497d(%rip), %rsi      # 0x1001e
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x7a1d
testb %al, %al
je 0xb6bb
movb $0x1, 0x8379(%rip)      # 0x13a34
movl $0xffffffff, 0x8373(%rip) # imm = 0xFFFFFFFF
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/hyc[P]trek73c/trekx.c
// Function: main
int main(argc, argv)
int argc;
Char *argv[];
{
  int I;

  SysInit();
again:
  TrekInit();
  Radius = 5000;
  TCount = (-1);
  Win = 0;
  Win2 = 0;
  LKnt = 0;
  DrawScr();
  Stop = false;
  Redo = false;
  do {
    TCount++;
    if (TCount > Enemies)
      Execute();
    else if (Objects[TCount] != NULL) {
      I = Objects[TCount]->ObTyp;
      if (I < 10 && Ships[TCount] != NULL) {
	if (Ships[TCount]->Crew != 0) {
	  if (!I)
	    Command();
	  else
	    EStrat();
	}
      }
    }
  } while (!Stop);

  waddstr(Cmdwin,"Computer:  Do you desire another battle");
  if (Yes())
  {
    delwin(Prbwin);
    delwin(Scnwin);
    delwin(Diswin);
    delwin(Cmdwin);
    delwin(Repwin);
    delwin(Radwin);
    for (I = ObjCount; I >= 0; I--)
    {
      if (Objects[I])
      {
	free(Objects[I]);
	Objects[I] = NULL;
      }
    }
    for (I = 0; I<10; I++)
    {
      if (Ships[I])
      {
      	free(Ships[I]);
	Ships[I] = NULL;
      }
    }
    goto again;
  }
  endwin();
  exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x2591
xorl %r14d, %r14d
leaq 0x7c42(%rip), %r15      # 0x135f0
leaq 0x7fdb(%rip), %r12      # 0x13990
leaq 0x4674(%rip), %rbx      # 0x10030
callq 0x2662
movl $0x1388, 0x805d(%rip)   # imm = 0x1388
movl $0xffffffff, 0x8063(%rip) # imm = 0xFFFFFFFF
movb %r14b, 0x7c0c(%rip)     # 0x135e8
movl %r14d, 0x804d(%rip)     # 0x13a30
movl %r14d, 0x803a(%rip)     # 0x13a24
callq 0x37b3
movb %r14b, 0x803e(%rip)     # 0x13a34
movb %r14b, 0x802f(%rip)     # 0x13a2c
movslq 0x8034(%rip), %rax      # 0x13a38
leal 0x1(%rax), %ecx
movl %ecx, 0x802b(%rip)      # 0x13a38
movzbl 0x7bcc(%rip), %ecx      # 0x135e0
cmpl %ecx, %eax
jge 0xba49
movq 0x8(%r15,%rax,8), %rcx
testq %rcx, %rcx
je 0xba4e
movzwl 0x4a(%rcx), %ecx
cmpw $0x9, %cx
jg 0xba4e
movq 0x8(%r12,%rax,8), %rax
testq %rax, %rax
je 0xba4e
cmpw $0x0, 0x1a(%rax)
je 0xba4e
testw %cx, %cx
je 0xba59
callq 0x6b07
jmp 0xba4e
callq 0x651e
cmpb $0x1, 0x7fdf(%rip)      # 0x13a34
jne 0xb9fd
jmp 0xba60
callq 0xb6c7
jmp 0xba4e
movq 0x7f91(%rip), %rdi      # 0x139f8
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x7a1d
testb %al, %al
je 0xbb21
movq 0x7f90(%rip), %rdi      # 0x13a18
callq 0x21c0
movq 0x7f7c(%rip), %rdi      # 0x13a10
callq 0x21c0
movq 0x7f68(%rip), %rdi      # 0x13a08
callq 0x21c0
movq 0x7f4c(%rip), %rdi      # 0x139f8
callq 0x21c0
movq 0x7f30(%rip), %rdi      # 0x139e8
callq 0x21c0
movq 0x7f2c(%rip), %rdi      # 0x139f0
callq 0x21c0
movzbl 0x7b11(%rip), %r13d     # 0x135e2
leaq (%r15,%r13,8), %rbp
incq %r13
movq (%rbp), %rdi
testq %rdi, %rdi
je 0xbaee
callq 0x2130
movq $0x0, (%rbp)
addq $-0x8, %rbp
decq %r13
jg 0xbad8
xorl %r13d, %r13d
movq (%r13,%r12), %rdi
testq %rdi, %rdi
je 0xbb12
callq 0x2130
movq $0x0, (%r13,%r12)
addq $0x8, %r13
cmpq $0x50, %r13
jne 0xbafa
jmp 0xb9bc
callq 0x2200
xorl %edi, %edi
callq 0x20d0
// File: /workspace/github_c_makefile_star2_O1/Alessandro-Barbieri[P]SpaceLib/src/SPACELIB.c
// Function: runtime_error
void runtime_error(const char *name, const char *msg, int ex)
{
	fprintf(stderr,"\n\n*** runtime error spacelib/%s\n",name);
	fprintf(stderr,"%s\n\n",msg);
	if (ex){
		exit(ex);
	}
}

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

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

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

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

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

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

	free(H); free(ivet);

	return irank;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %r14d
movq %rdx, 0x30(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, 0x38(%rsp)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
leal 0x1(%r14), %ebp
movl %ebp, %eax
imull %ecx, %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x2180
movq %rax, 0x18(%rsp)
movslq %r14d, %r15
movl $0x4, %esi
movq %r15, %rdi
callq 0x2180
movq %r14, %rsi
movq %rax, 0x28(%rsp)
movl %esi, %eax
movq %rax, 0x10(%rsp)
testl %r15d, %r15d
jle 0x34ff
movq 0x10(%rsp), %r14
leaq (,%r14,8), %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
movl %r12d, %eax
movq %rsi, %rbx
movq 0x38(%rsp), %rcx
leaq (%rcx,%rax,8), %rsi
movl %r13d, %eax
movq 0x18(%rsp), %rcx
leaq (%rcx,%rax,8), %rdi
movq %r15, %rdx
callq 0x2200
movq %rbx, %rsi
addl %esi, %r12d
addl %ebp, %r13d
decq %r14
jne 0x34ce
movl %ebp, %r15d
testl %esi, %esi
movq 0x18(%rsp), %r14
movq 0x10(%rsp), %r13
movq 0x20(%rsp), %rdi
jle 0x3537
leaq (%r14,%r13,8), %rax
leaq (,%r15,8), %rcx
xorl %edx, %edx
movsd (%rdi,%rdx,8), %xmm0
movsd %xmm0, (%rax)
incq %rdx
addq %rcx, %rax
cmpq %rdx, %r13
jne 0x3523
leaq 0xc(%rsp), %rax
leaq 0x40(%rsp), %r10
leaq 0x8(%rsp), %r11
movq %r14, %rdi
movq %rsi, %r12
movl %ebp, %edx
movl %r12d, %ecx
movl %r12d, %r8d
movl $0x1, %r9d
pushq %rax
pushq %r10
pushq %r11
movq 0x40(%rsp), %rbx
pushq %rbx
callq 0x21f0
addq $0x20, %rsp
testl %r12d, %r12d
movq 0x30(%rsp), %rsi
jle 0x359a
leaq (%r14,%r13,8), %rax
shlq $0x3, %r15
xorl %ecx, %ecx
movsd (%rax), %xmm0
movslq (%rbx,%rcx,4), %rdx
movsd %xmm0, (%rsi,%rdx,8)
incq %rcx
addq %r15, %rax
cmpq %rcx, %r13
jne 0x3582
movq %r14, %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x2040
movl 0x8(%rsp), %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Alessandro-Barbieri[P]SpaceLib/src/LINEAR2.c
// Function: minvers
int minvers(MAT A, MAT Ai, int dim)
{

	real *H;                /* matrix where A and I must be copied */
	int *ivet;              /* vector filled with reordering info. */
	int vpr = -1;
	int irank;
	real arm;
	int i,j;

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

	for (i=0;i<dim;i++)     /* copies matrix A into matrix H */
		for (j=0;j<dim;j++)
			H[i*dim*2+j] = *(A+i*dim+j);
	for (i=0;i<dim;i++)     /* copies identity matrix I into matrix H */
		for (j=dim;j<2*dim;j++)
			if (i!=(j-dim))
				H[i*dim*2+j] = 0;
			else
				H[i*dim*2+j] = 1;
	linear(H,dim,2*dim,dim,dim,dim,ivet,&irank,&arm,&vpr);
	for (j=dim;j<2*dim;j++) /* extracts solution x reordering matrix H */
		for (i=0;i<dim;i++)
			*(Ai+ivet[i]*dim+j-dim) = *(H+i*2*dim+j);

	free (H); free (ivet);

	return irank;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r14d
movq %rsi, 0x20(%rsp)
movq %rdi, 0x38(%rsp)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
leal (%r14,%r14), %ebp
movl %ebp, %eax
imull %edx, %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x2180
movq %rax, 0x10(%rsp)
movslq %r14d, %rbx
movl $0x4, %esi
movq %rbx, %rdi
callq 0x2180
movq %r14, %rcx
movq %rax, %r13
movl %ecx, %r15d
movq %rbx, 0x18(%rsp)
testl %ebx, %ebx
jle 0x3667
leaq (,%r15,8), %rax
movq %rax, 0x28(%rsp)
xorl %ebx, %ebx
movq %r15, %r14
xorl %r12d, %r12d
movq %rcx, 0x30(%rsp)
movl %r12d, %eax
movq 0x38(%rsp), %rcx
leaq (%rcx,%rax,8), %rsi
movl %ebx, %eax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,8), %rdi
movq 0x28(%rsp), %rdx
callq 0x2200
movq 0x30(%rsp), %rcx
addl %ecx, %r12d
addl %ebp, %ebx
decq %r14
jne 0x3637
testl %ecx, %ecx
movq %rcx, %rbx
movq 0x10(%rsp), %r14
jle 0x36c0
movl %ebp, %eax
leaq (%r14,%r15,8), %rcx
subq %r15, %rax
xorl %edx, %edx
movsd 0x69f2(%rip), %xmm0     # 0xa078
cmpl %ebx, %ebp
jle 0x36b8
movl %ebp, %esi
imull %edx, %esi
xorl %edi, %edi
movl %esi, %r8d
movaps %xmm0, %xmm1
cmpq %rdi, %rdx
cmovel %esi, %r8d
je 0x36a3
xorps %xmm1, %xmm1
movslq %r8d, %r8
leaq (%rcx,%r8,8), %r8
movsd %xmm1, (%r8,%rdi,8)
incq %rdi
cmpq %rdi, %rax
jne 0x3691
incq %rdx
cmpq %r15, %rdx
jne 0x3686
leaq 0xc(%rsp), %rax
leaq 0x40(%rsp), %r10
leaq 0x8(%rsp), %r11
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
movl %ebx, %ecx
movl %ebx, %r8d
movl %ebx, %r9d
pushq %rax
pushq %r10
pushq %r11
pushq %r13
callq 0x21f0
addq $0x20, %rsp
cmpl %ebx, %ebp
movq 0x20(%rsp), %r10
movq 0x18(%rsp), %r11
jle 0x3747
leaq (,%r11,8), %rax
subq %rax, %r10
movslq %ebp, %rax
movq %r11, %rcx
testl %ebx, %ebx
jle 0x373f
leaq (%r14,%rcx,8), %rdx
leaq (%r10,%rcx,8), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
movslq %edi, %rdi
movsd (%rdx,%rdi,8), %xmm0
movslq (%r13,%r8,4), %r9
imulq %r11, %r9
movsd %xmm0, (%rsi,%r9,8)
incq %r8
addl %ebp, %edi
cmpq %r8, %r15
jne 0x371e
incq %rcx
cmpq %rax, %rcx
jne 0x370d
movq %r14, %rdi
callq 0x2040
movq %r13, %rdi
callq 0x2040
movl 0x8(%rsp), %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/Alessandro-Barbieri[P]SpaceLib/src/SPACELI3.c
// Function: rotat24
int rotat24(int a, real q, POINT O, MAT4 m)
{
	if (a<X || a>U)
	{
		fprintf(stderr,"Error (rotat24) : illegal axis\n");
		return(NOTOK);
	}
	if (O[U] != 1)
	{
		fprintf(stderr,"Error (rotat24) : illegal point");
		return(NOTOK);
	}
	rotat2(a, q, M m, 4);

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

	return (OK);
}

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

	clear4(L);

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

	return(OK);
}

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

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

	clear4(L);

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

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

	return(OK);
}

// Assembly:
pushq %rax
cmpl $0x2, %esi
ja 0x3b76
xorps %xmm1, %xmm1
movups %xmm1, 0x70(%rcx)
movups %xmm1, 0x60(%rcx)
movups %xmm1, 0x50(%rcx)
movups %xmm1, 0x40(%rcx)
movups %xmm1, 0x30(%rcx)
movups %xmm1, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm1, (%rcx)
testl %edi, %edi
je 0x3adc
cmpl $0x1, %edi
jne 0x3b7d
movl %esi, %eax
shlq $0x5, %rax
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
movq %rdx, 0x18(%rcx,%rax)
jmp 0x3b6f
leal 0x1(%rsi), %eax
movl $0xaaaaaaab, %edi       # imm = 0xAAAAAAAB
imulq %rdi, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %eax
negl %eax
addl %esi, %eax
incl %eax
leal 0x2(%rsi), %r8d
imulq %rdi, %r8
shrq $0x21, %r8
leal (%r8,%r8,2), %edi
negl %edi
addl %esi, %edi
addl $0x2, %edi
movl %edi, %r8d
shll $0x5, %r8d
leaq (%rcx,%r8), %r9
leal (,%rax,8), %r10d
movabsq $0x3ff0000000000000, %r11 # imm = 0x3FF0000000000000
movq %r11, (%r10,%r9)
shll $0x5, %eax
leaq (%rcx,%rax), %r9
shll $0x3, %edi
movabsq $-0x4010000000000000, %r11 # imm = 0xBFF0000000000000
movq %r11, (%rdi,%r9)
movsd (%rdx,%rdi), %xmm1
movsd %xmm1, 0x18(%rcx,%rax)
movsd (%rdx,%r10), %xmm1
xorps 0x64a3(%rip), %xmm1     # 0xa000
movlps %xmm1, 0x18(%rcx,%r8)
movl %esi, %eax
shlq $0x5, %rax
movsd %xmm0, 0x18(%rcx,%rax)
movl $0x1, %eax
popq %rcx
retq
callq 0x2508
jmp 0x3b82
callq 0x24ec
xorl %eax, %eax
jmp 0x3b74
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x18(%r8)
movsd 0x48(%rdi), %xmm0
movsd %xmm0, (%rsi)
movsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x8(%rsi)
movsd 0x20(%rdi), %xmm0
movsd %xmm0, 0x10(%rsi)
movq %rsi, %rdi
callq 0x2110
movsd %xmm0, (%r12)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movsd 0x18(%r13), %xmm0
jne 0x3bee
jnp 0x3c5b
movq %rsp, %rbp
movsd %xmm0, (%rbp)
movsd 0x38(%r13), %xmm0
movsd %xmm0, 0x8(%rbp)
movsd 0x58(%r13), %xmm0
movsd %xmm0, 0x10(%rbp)
movq %r14, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x2390
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
divsd (%r12), %xmm0
movsd %xmm0, (%r15)
divsd (%r12), %xmm1
movsd %xmm1, 0x8(%r15)
movsd 0x10(%r15), %xmm0
divsd (%r12), %xmm0
movsd %xmm0, 0x10(%r15)
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2030
jmp 0x3c94
movsd %xmm0, (%r14)
movsd 0x38(%r13), %xmm0
movsd %xmm0, 0x8(%r14)
movsd 0x58(%r13), %xmm0
movsd %xmm0, 0x10(%r14)
xorpd %xmm0, %xmm0
movupd %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq %r14, %rdi
movq %r14, %rsi
callq 0x2110
movsd %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %r9, %r8
movl $0x4, %r9d
callq 0x21d0
xorl %eax, %eax
movsd (%r14,%rax), %xmm0
movsd %xmm0, 0x18(%rbx,%rax,4)
addq $0x8, %rax
cmpq $0x20, %rax
jne 0x42d3
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movq 0x20(%rsp), %r14
movl $0x4, (%rsp)
movq %r14, %r9
callq 0x2120
xorl %eax, %eax
movq %r14, %rcx
movq %rax, %rdx
shlq $0x5, %rdx
addq %r14, %rdx
addq $0x18, %rdx
movq $0x0, (%rdx)
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm1
mulsd (%rbx,%rsi,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%rdx)
incq %rsi
cmpq $0x3, %rsi
jne 0x433b
incq %rax
addq $0x20, %rcx
cmpq $0x3, %rax
jne 0x4320
xorpd %xmm0, %xmm0
movupd %xmm0, 0x70(%r14)
movupd %xmm0, 0x60(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Alessandro-Barbieri[P]SpaceLib/src/SPACELI3.c
// Function: cardantoH
void cardantoH(real *q,real *qp,real *qpp, int i, int j, int k, POINT O,
	       MAT4 H)
{
	int l,m;

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

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

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

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

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

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

/* #undef RR 	Bug fixed 03.04.97 AmGhiPu */

	return(OK);
}

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rdi, %r14
movl $0x4, (%rsp)
callq 0x2250
xorl %eax, %eax
movsd (%r14,%rax), %xmm0
movsd %xmm0, 0x18(%rbx,%rax,4)
addq $0x8, %rax
cmpq $0x20, %rax
jne 0x4de3
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq