LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: Torpfire
void Torpfire(I)
int I;
{
  int J, K, Num;
  double X;
  reg Object *WITH;

  K = (-1);
  for (J = 0; J < Tubes; J++) {
    if (Ships[I]->Tstat[J] > 99) {
      K = J;
      break;
    }
  }
  if (K < 0)
    return;
  TrakTorp(I, K);
  if (Ships[I]->Tstat[K] <= 99)
    return;
  Launch(I, &Num);
  sprintf(scrstr,"<<%s firing Torpedo %d>>", Snams[I], Num);
  SEndln();
  WITH = Objects[Num];
  WITH->Des_Spd = Ships[I]->Tstat[6];
  WITH->Act_Spd = WITH->Des_Spd;
  WITH->Des_Crs = RMod(Ships[I]->TDepl[K] + Objects[I]->Act_Crs);
  WITH->Act_Crs = WITH->Des_Crs;
  WITH->Fuel = Ships[I]->Tengy[K];
  WITH->ObTyp = I + 30;
  WITH->Tim_Del = 10000 - Ships[I]->Tstat[7] * 4.0;
  WITH->Prx_Del = Ships[I]->Tstat[8];
  X = Radians(WITH->Act_Crs);
  WITH->XPos += WITH->Act_Spd * cos(X) * Iter * 100;
  WITH->YPos -= WITH->Act_Spd * sin(X) * Iter * 100;
  Ships[I]->Tstat[K] -= 100;
  Ships[I]->Tengy[K] = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movzbl 0xd75d(%rip), %eax      # 0x121b1
movslq %edi, %r14
xorl %ebx, %ebx
leaq 0xdf20(%rip), %r12      # 0x12980
cmpq %rbx, %rax
je 0x4c06
movq (%r12,%r14,8), %rcx
cmpw $0x63, 0x110(%rcx,%rbx,2)
jg 0x4a7d
incq %rbx
jmp 0x4a60
movl %r14d, %edi
movl %ebx, %esi
callq 0x495b
movq (%r12,%r14,8), %rax
cmpw $0x64, 0x110(%rax,%rbx,2)
jl 0x4c06
leaq 0x1c(%rsp), %r15
movl %r14d, %edi
movq %r15, %rsi
callq 0x48c0
leaq 0xde6f(%rip), %rax      # 0x12920
movq (%rax,%r14,8), %rdx
movslq (%r15), %r15
leaq 0xd9e1(%rip), %rdi      # 0x124a0
leaq 0x7576(%rip), %rsi      # 0xc03c
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2190
callq 0x399b
leaq 0xdb04(%rip), %rax      # 0x125e0
movq (%rax,%r15,8), %r15
movq (%r12,%r14,8), %r13
movswl 0x11c(%r13), %ecx
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x8(%r15)
movsd %xmm0, (%r15)
movsd 0xe0(%r13,%rbx,8), %xmm0
movq (%rax,%r14,8), %rax
addsd 0x10(%rax), %xmm0
callq 0x39cd
movsd %xmm0, 0x18(%r15)
movsd %xmm0, 0x10(%r15)
leal 0x1e(%r14), %eax
pxor %xmm2, %xmm2
pinsrw $0x1, 0xc6(%r13,%rbx,2), %xmm2
movw %ax, 0x4a(%r15)
movswl 0x11e(%r13), %eax
cvtsi2sd %eax, %xmm1
mulsd 0x6577(%rip), %xmm1     # 0xb0c8
addsd 0x6577(%rip), %xmm1     # 0xb0d0
movsd %xmm1, 0x30(%r15)
pinsrw $0x3, 0x120(%r13), %xmm2
psrad $0x10, %xmm2
cvtdq2pd %xmm2, %xmm1
movups %xmm1, 0x20(%r15)
mulsd 0x6499(%rip), %xmm0     # 0xb018
divsd 0x6499(%rip), %xmm0     # 0xb020
movsd %xmm0, 0x10(%rsp)
callq 0x20e0
mulsd 0x8(%rsp), %xmm0
mulsd 0xd600(%rip), %xmm0     # 0x121a0
mulsd 0x64c8(%rip), %xmm0     # 0xb070
addsd 0x38(%r15), %xmm0
movsd %xmm0, 0x38(%r15)
movsd (%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2300
mulsd 0x8(%rsp), %xmm0
mulsd 0xd5c8(%rip), %xmm0     # 0x121a0
movsd 0x40(%r15), %xmm1
mulsd 0x648a(%rip), %xmm0     # 0xb070
subsd %xmm0, %xmm1
movsd %xmm1, 0x40(%r15)
movq (%r12,%r14,8), %rax
addw $-0x64, 0x110(%rax,%rbx,2)
andw $0x0, 0xc6(%rax,%rbx,2)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: AMHits
int AMHits(I, J)
int I, J;
{
  int Hits;
  double F1, F2, G2;

  Hits = 0;
  F1 = Objects[I]->Fuel * 5;
  G2 = Range(I, J);
  F2 = F1 * 10;
  if (G2 <= F2)
    Hits = (long)(F1 * sqrt(1 - G2 / F2));
  return Hits;
}

// Assembly:
pushq %rax
movslq %edi, %rdi
leaq 0xd9c1(%rip), %rax      # 0x125e0
movq (%rax,%rdi,8), %rax
movsd 0x20(%rax), %xmm0
mulsd 0x64a8(%rip), %xmm0     # 0xb0d8
movsd %xmm0, (%rsp)
callq 0x3ae6
movsd 0x63c6(%rip), %xmm1     # 0xb008
mulsd (%rsp), %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
jb 0x4c86
divsd %xmm1, %xmm0
movsd 0x63b5(%rip), %xmm1     # 0xb010
subsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x4c6f
sqrtsd %xmm1, %xmm0
jmp 0x4c78
movapd %xmm1, %xmm0
callq 0x22e0
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: Antimatter
void Antimatter(I)
int I;
{
  int J, M, K0;
  boolean Boom;
  reg Object *WITH;

  WITH = Objects[I];
  M = WITH->ObTyp % 10;
  WITH->Tim_Del++;
  K0 = (long)WITH->Tim_Del;
  if (K0 > 10000) {
    Detonate(I);
    return;
  }
  Boom = false;
  if (WITH->Prx_Del != 0) {
    for (J = 0; J < ObjCount; J++) {
      if (Objects[J] != NULL && J != I) {
	if (Objects[J]->ObTyp < 20 && WITH->Prx_Del >= Range(I, J) && J != M)
	  Boom = true;
      }
    }
  }
  if (Boom)
    Detonate(I);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movslq %edi, %rax
leaq 0xd6bc(%rip), %r12      # 0x125e0
movq (%r12,%rax,8), %rcx
movzwl 0x4a(%rcx), %eax
movw $0xa, %si
cwtd
idivw %si
movsd 0x30(%rcx), %xmm0
addsd 0x60ce(%rip), %xmm0     # 0xb010
movsd %xmm0, 0x30(%rcx)
cvttsd2si %xmm0, %rax
cmpl $0x2710, %eax           # imm = 0x2710
jg 0x4fe1
movsd 0x28(%rcx), %xmm1
xorpd %xmm0, %xmm0
movsd %xmm1, 0x10(%rsp)
ucomisd %xmm0, %xmm1
jne 0x4f72
jnp 0x4ff4
movswq %dx, %rax
movl %edi, 0xc(%rsp)
movl %edi, %r14d
movzbl 0xd64d(%rip), %r13d     # 0x125d2
movl %eax, %ebp
xorl %r15d, %r15d
xorl %ebx, %ebx
cmpq %r15, %r13
je 0x4fd9
movq (%r12), %rax
testq %rax, %rax
sete %cl
cmpq %r15, %r14
sete %dl
orb %cl, %dl
jne 0x4fd0
cmpw $0x13, 0x4a(%rax)
jg 0x4fd0
movl %r14d, %edi
movl %r15d, %esi
callq 0x3ae6
cmpq %r15, %rbp
movzbl %bl, %eax
pushq $0x1
popq %rbx
cmovel %eax, %ebx
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
cmovbl %eax, %ebx
incq %r15
addq $0x8, %r12
jmp 0x4f8c
testb %bl, %bl
movl 0xc(%rsp), %edi
je 0x4ff4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4c88
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: Nowarp
static void Nowarp(i)
int i;
{
  double Temp;
  reg Object *WITH;

  WITH = Objects[i];
  Temp = fabs(WITH->Des_Spd);
  if (Temp > 0.99)
    Temp = 0.99;
  WITH->Des_Spd = Sign(WITH->Des_Spd) * Temp;
}

// Assembly:
movslq %edi, %rax
leaq 0xd28b(%rip), %rcx      # 0x125e0
movq (%rcx,%rax,8), %rax
movsd 0x8(%rax), %xmm0
movapd 0x5eda(%rip), %xmm1     # 0xb240
andpd %xmm0, %xmm1
movsd 0x5d6e(%rip), %xmm2     # 0xb0e0
minsd %xmm1, %xmm2
movapd 0x5e72(%rip), %xmm1     # 0xb1f0
xorpd %xmm2, %xmm1
xorpd %xmm3, %xmm3
cmpltsd %xmm3, %xmm0
movapd %xmm0, %xmm3
andnpd %xmm2, %xmm3
andpd %xmm1, %xmm0
orpd %xmm3, %xmm0
movlpd %xmm0, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: Detach
void Detach(I)
int I;
{
  int J;
  boolean Drop;

  Launch(I, &J);
  Drop = false;
  Objects[J]->Tim_Del = 10000 - 10 / Iter;
  Objects[J]->Fuel = Objects[I]->Fuel;
  Objects[I]->Fuel = 0.0;
  Objects[J]->ObTyp = I + 10;
  Ships[I]->Regen = 0.0;
  Ships[I]->Fcap = 0;
  Ships[I]->Weff = 10.0;
  Ships[I]->Dmge[(long)Engn] = true;
  Ships[I]->Dmge[(long)Prob] = true;
  for (J = 0; J < Phasers; J++) {
    if (Ships[I]->PChrg[J] > 0)
      Drop = true;
  }
  if (Drop) {
    for (J = 0; J <= 3; J++)
      Ships[I]->Seff[J] = 0.0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x4(%rsp), %r14
movq %r14, %rsi
callq 0x48c0
movsd 0x5344(%rip), %xmm0     # 0xb008
movapd %xmm0, %xmm1
divsd 0xc4d0(%rip), %xmm1     # 0x121a0
movsd 0x53f8(%rip), %xmm2     # 0xb0d0
subsd %xmm1, %xmm2
movslq (%r14), %rax
leaq 0xc8fa(%rip), %rcx      # 0x125e0
movq (%rcx,%rax,8), %rdx
movsd %xmm2, 0x30(%rdx)
movslq %ebx, %rax
movq (%rcx,%rax,8), %rcx
movsd 0x20(%rcx), %xmm1
movsd %xmm1, 0x20(%rdx)
andq $0x0, 0x20(%rcx)
xorpd %xmm1, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
leal 0xa(%rax), %ecx
movw %cx, 0x4a(%rdx)
leaq 0xcc65(%rip), %rcx      # 0x12980
movq (%rcx,%rax,8), %rdx
movb $0x0, 0x18(%rdx)
movupd %xmm1, (%rdx)
movb $0x1, %sil
movb %sil, 0xc4(%rdx)
movq (%rcx,%rax,8), %rdx
movb %sil, 0xc2(%rdx)
movzbl 0xc46d(%rip), %edx      # 0x121b0
xorl %esi, %esi
xorpd %xmm0, %xmm0
pushq $0x1
popq %rdi
xorl %r8d, %r8d
cmpq %rsi, %rdx
je 0x5d70
movq (%rcx,%rax,8), %r9
movsd 0x20(%r9,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
movzbl %r8b, %r8d
cmoval %edi, %r8d
incq %rsi
jmp 0x5d4f
testb %r8b, %r8b
je 0x5d8f
movq (%rcx,%rax,8), %rax
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x5d8f
andq $0x0, 0xa0(%rax,%rcx,8)
incq %rcx
jmp 0x5d7b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: Yes
boolean Yes()
{
  Char Ch;

  waddstr(Cmdwin,"? [Y/N] ");
  wrefresh(Cmdwin);
  Ch=wgetch(Cmdwin);
  waddstr(Cmdwin,"\n");
  wclrtoeol(Cmdwin);
  wrefresh(Cmdwin);
  if (toupper(Ch) == 'Y')
    return true;
  else
    return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0xbf32(%rip), %rdi      # 0x129e8
leaq 0x5b59(%rip), %rsi      # 0xc616
pushq $-0x1
popq %rbx
movl %ebx, %edx
callq 0x2200
movq 0xbf1a(%rip), %rdi      # 0x129e8
callq 0x2180
movq 0xbf0e(%rip), %rdi      # 0x129e8
callq 0x22f0
movl %eax, %r14d
movq 0xbeff(%rip), %rdi      # 0x129e8
leaq 0x5181(%rip), %rsi      # 0xbc71
movl %ebx, %edx
callq 0x2200
movq 0xbeea(%rip), %rdi      # 0x129e8
callq 0x2210
movq 0xbede(%rip), %rdi      # 0x129e8
callq 0x2180
callq 0x2100
movq (%rax), %rax
movsbq %r14b, %rcx
cmpl $0x59, (%rax,%rcx,4)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: Getwarp
boolean Getwarp(ok)
boolean ok;
{
  double temp;
  short code;

  waddstr(Cmdwin,"\n   Warp factor [-9 to 9] ");
  mygetstr(Cmdwin,scrstr,true);
  code = (sscanf(scrstr, "%lg", &temp) == 0);
  if (code > 0) {
    ok = false;
    return ok;
  }
  if (fabs(temp) > 9) {
    ok = false;
    ChWhat();
  } else if ((fabs(temp) >= 1) && Ships[0]->Dmge[(int)Warp]) {
    ok=false;
    NoEngy();
  } else if (ok)
    Objects[0]->Des_Spd = temp;
  return ok;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movq 0xbdb9(%rip), %rdi      # 0x129e8
leaq 0x5ab4(%rip), %rsi      # 0xc6ea
pushq $-0x1
popq %rdx
callq 0x2200
movq 0xbda3(%rip), %rdi      # 0x129e8
leaq 0xb854(%rip), %r14      # 0x124a0
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x246d
leaq 0x678a(%rip), %rsi      # 0xd3e8
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x20a0
testl %eax, %eax
je 0x6ccd
movsd 0x8(%rsp), %xmm0
movapd 0x45bf(%rip), %xmm1     # 0xb240
andpd %xmm0, %xmm1
ucomisd 0x44b3(%rip), %xmm1     # 0xb140
jbe 0x6c96
callq 0x6b6e
jmp 0x6ccb
ucomisd 0x4372(%rip), %xmm1     # 0xb010
jb 0x6cb7
movq 0xbcd9(%rip), %rax      # 0x12980
cmpb $0x0, 0xc3(%rax)
je 0x6cb7
callq 0x6b90
jmp 0x6ccb
testb %bl, %bl
je 0x6ccb
movq 0xb91e(%rip), %rax      # 0x125e0
movsd %xmm0, 0x8(%rax)
movl %ebx, %ebp
jmp 0x6ccd
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0xa, %rax
je 0x6cf3
andl $0x0, (%rbx,%rax,4)
incq %rax
jmp 0x6ce4
movq 0xbcee(%rip), %rdi      # 0x129e8
leaq 0xb79f(%rip), %r14      # 0x124a0
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x246d
pushq $-0x1
popq %rbp
movsbq (%r14), %r15
testq %r15, %r15
je 0x6d3b
callq 0x2160
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r15,2)
je 0x6d36
addl $-0x30, %r15d
movslq %ebp, %rax
incl %ebp
movl %r15d, 0x4(%rbx,%rax,4)
incq %r14
jmp 0x6d0f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %rsi, %r14
movq 0xb9a1(%rip), %rax      # 0x129e8
testq %rax, %rax
movq %rdi, 0x10(%rsp)
je 0x705b
movswl (%rax), %ebp
movswl 0x2(%rax), %r12d
jmp 0x7061
pushq $-0x1
popq %rbp
movl %ebp, %r12d
movb $0x1, (%r14)
movq 0xb97c(%rip), %rdi      # 0x129e8
leaq 0xb42d(%rip), %rsi      # 0x124a0
xorl %edx, %edx
callq 0x246d
andl $0x0, 0xc(%rsp)
movsbq 0xb419(%rip), %r13      # 0x124a0
testq %r13, %r13
je 0x70dc
callq 0x2160
movq (%rax), %rax
testb $0x2, 0x1(%rax,%r13,2)
je 0x70af
callq 0x2100
movq (%rax), %rax
movb (%rax,%r13,4), %r13b
movb %r13b, 0xb3f1(%rip)     # 0x124a0
movzbl 0xb51a(%rip), %eax      # 0x125d0
negq %rax
pushq $0x1
popq %r15
leaq 0xb85c(%rip), %rbx      # 0x12920
leaq (%rax,%r15), %rcx
cmpq $0x1, %rcx
je 0x70dc
movq (%rbx,%r15,8), %rcx
cmpb (%rcx), %r13b
je 0x7105
incq %r15
jmp 0x70c4
leaq 0xb3bd(%rip), %rdi      # 0x124a0
leaq 0x54a3(%rip), %rsi      # 0xc58d
leaq 0xc(%rsp), %rdx
xorl %eax, %eax
callq 0x20a0
testl %eax, %eax
je 0x70fe
movb $0x0, (%r14)
movl 0xc(%rsp), %r15d
jmp 0x7182
movq 0xb8dc(%rip), %rdi      # 0x129e8
movl %ebp, %esi
movl %r12d, %edx
callq 0x21d0
cmpl $-0x1, %eax
je 0x7136
leaq (,%r15,8), %rax
movq 0xb8be(%rip), %rdi      # 0x129e8
movq (%rax,%rbx), %rsi
pushq $-0x1
popq %rdx
callq 0x2200
movq 0xb8ab(%rip), %rdi      # 0x129e8
leaq 0x4b2d(%rip), %rsi      # 0xbc71
pushq $-0x1
popq %rdx
callq 0x2200
movq 0xb895(%rip), %rdi      # 0x129e8
callq 0x2210
movq 0xb889(%rip), %rdi      # 0x129e8
callq 0x2180
movq 0x10(%rsp), %rcx
movb $0x1, (%rcx)
movl %r15d, 0xc(%rsp)
leaq 0xb808(%rip), %rax      # 0x12980
cmpq $0x0, (%rax,%r15,8)
jne 0x7182
movb $0x0, (%rcx)
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: PRStt
void PRStt()
{
  int I, J, X, Y;
  double Z;
  char *Junk;

  werase(Prbwin);
  mvwaddstr(Prbwin, 0, 0, "Num Dist Crse  Target  Range Pods Time Prox\n");
  for (I = 1; I < ObjCount; I++) {
    if (Objects[I] != NULL) {
      if (Objects[I]->ObTyp == 20) {
	sprintf(scrstr,"%2d%6.0f%4.0f", I, Range(0, I), Objects[I]->Act_Crs);
	waddstr(Prbwin,scrstr);
	if (Objects[I]->Trgt == 0)
	  waddstr(Prbwin,"   Manual ");
	else {
	  Junk = Snams[Objects[I]->Trgt - 1];
	  J = strlen(Junk) / 2 + 6;
	  sprintf(scrstr,"%*s%*s", J, Junk, 10 - J, "");
	  waddstr(Prbwin,scrstr);
	}
	sprintf(scrstr,"%6.0f%4.0f",
	       Range(I, Objects[I]->Trgt-1), Objects[I]->Fuel);
	waddstr(Prbwin,scrstr);
	Z = (10000 - Objects[I]->Tim_Del) * Iter;
	sprintf(scrstr,"%5.0f%5.0f\n", Z, Objects[I]->Prx_Del);
	waddstr(Prbwin,scrstr);
      }
    }
  }
  wrefresh(Prbwin);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xb862(%rip), %rdi      # 0x12a08
callq 0x2080
movq 0xb856(%rip), %rdi      # 0x12a08
xorl %esi, %esi
xorl %edx, %edx
callq 0x21d0
cmpl $-0x1, %eax
je 0x71d6
movq 0xb841(%rip), %rdi      # 0x12a08
leaq 0x55cf(%rip), %rsi      # 0xc79d
pushq $-0x1
popq %rdx
callq 0x2200
pushq $0x1
popq %rbx
movb 0xb3f3(%rip), %al       # 0x125d2
leaq 0xb3fa(%rip), %r12      # 0x125e0
leaq 0xb2b3(%rip), %r14      # 0x124a0
pushq $-0x1
popq %rbp
movzbl %al, %ecx
cmpq %rcx, %rbx
jae 0x733d
movq (%r12,%rbx,8), %r15
testq %r15, %r15
je 0x7335
cmpw $0x14, 0x4a(%r15)
jne 0x7335
leaq (,%rbx,8), %r13
xorl %edi, %edi
movl %ebx, %esi
callq 0x3ae6
movsd 0x10(%r15), %xmm1
movq %r14, %rdi
leaq 0x5594(%rip), %rsi      # 0xc7ca
movl %ebx, %edx
movb $0x2, %al
callq 0x2190
movq 0xb7c2(%rip), %rdi      # 0x12a08
movq %r14, %rsi
movl %ebp, %edx
callq 0x2200
movq (%r13,%r12), %rax
movswq 0x48(%rax), %rax
leaq 0x5577(%rip), %rsi      # 0xc7d8
testq %rax, %rax
je 0x72a5
leaq 0xb6b3(%rip), %rcx      # 0x12920
movq -0x8(%rcx,%rax,8), %r15
movq %r15, %rdi
callq 0x2140
shrq %rax
pushq $0x4
popq %r8
subl %eax, %r8d
leal 0x6(%rax), %edx
movq %r14, %rdi
leaq 0x5552(%rip), %rsi      # 0xc7e3
movq %r15, %rcx
leaq 0x49d7(%rip), %r9       # 0xbc72
xorl %eax, %eax
callq 0x2190
movq %r14, %rsi
movq 0xb75c(%rip), %rdi      # 0x12a08
movl %ebp, %edx
callq 0x2200
movq (%r13,%r12), %r15
movswl 0x48(%r15), %esi
decl %esi
movl %ebx, %edi
callq 0x3ae6
movsd 0x20(%r15), %xmm1
movq %r14, %rdi
leaq 0x54f7(%rip), %rsi      # 0xc7cd
movb $0x2, %al
callq 0x2190
movq 0xb724(%rip), %rdi      # 0x12a08
movq %r14, %rsi
movl %ebp, %edx
callq 0x2200
movq (%r13,%r12), %rax
movsd 0x3dd5(%rip), %xmm0     # 0xb0d0
subsd 0x30(%rax), %xmm0
mulsd 0xae98(%rip), %xmm0     # 0x121a0
movsd 0x28(%rax), %xmm1
movq %r14, %rdi
leaq 0x54d3(%rip), %rsi      # 0xc7ea
movb $0x2, %al
callq 0x2190
movq 0xb6e3(%rip), %rdi      # 0x12a08
movq %r14, %rsi
movl %ebp, %edx
callq 0x2200
movb 0xb29d(%rip), %al       # 0x125d2
incq %rbx
jmp 0x71f0
movq 0xb6c4(%rip), %rdi      # 0x12a08
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2180
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq 0xb48f(%rip), %rdi      # 0x129e8
leaq 0x52e7(%rip), %rsi      # 0xc847
pushq $-0x1
popq %rdx
callq 0x2200
leaq 0x10(%rsp), %rdi
callq 0x6cd8
xorl %eax, %eax
cmpq $0x6, %rax
je 0x7584
movb $0x1, 0xa(%rsp,%rax)
incq %rax
jmp 0x7574
movb $0x1, %al
xorl %ecx, %ecx
movq 0xb3f1(%rip), %rdx      # 0x12980
movsd 0x3b29(%rip), %xmm0     # 0xb0c0
movsd 0x3ab1(%rip), %xmm1     # 0xb050
xorl %esi, %esi
xorl %ebx, %ebx
cmpq $0x6, %rsi
je 0x760f
movl 0x10(%rsp,%rsi,4), %edi
leal -0x1(%rdi), %r8d
cmpl $0x5, %r8d
ja 0x75f8
movl %r8d, %edi
movzwl 0x110(%rdx,%rdi,2), %r8d
testw %r8w, %r8w
js 0x7603
movsd 0xe0(%rdx,%rdi,8), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x75de
ucomisd %xmm2, %xmm1
ja 0x7603
cmpw $0x0, 0xc6(%rdx,%rdi,2)
jle 0x7603
addl $0x64, %r8d
movw %r8w, 0x110(%rdx,%rdi,2)
jmp 0x760a
cmpl $0x7, %edi
movzbl %al, %eax
cmovgel %ecx, %eax
jmp 0x760a
incl %ebx
movb $0x0, 0xa(%rsp,%rdi)
incq %rsi
jmp 0x75a3
testb %al, %al
je 0x76b7
testl %ebx, %ebx
jle 0x76c6
movq 0xb3c2(%rip), %rdi      # 0x129e8
leaq 0x522f(%rip), %rsi      # 0xc85c
pushq $-0x1
popq %rdx
callq 0x2200
cmpl $0x1, %ebx
je 0x7649
movq 0xb3a7(%rip), %rdi      # 0x129e8
pushq $0x73
popq %rsi
callq 0x2150
leaq 0xae50(%rip), %rbx      # 0x124a0
leaq 0x51db(%rip), %r14      # 0xc832
pushq $-0x1
popq %rbp
xorl %r15d, %r15d
cmpq $0x6, %r15
je 0x7692
cmpb $0x0, 0xa(%rsp,%r15)
jne 0x768d
leal 0x1(%r15), %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2190
movq 0xb365(%rip), %rdi      # 0x129e8
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2200
incq %r15
jmp 0x765d
movq 0xb34f(%rip), %rdi      # 0x129e8
leaq 0x5196(%rip), %rsi      # 0xc836
pushq $-0x1
popq %rdx
callq 0x2200
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3933
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6b2a
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0xab63(%rip), %rdi      # 0x129e8
leaq 0x4b73(%rip), %rsi      # 0xc9ff
pushq $-0x1
popq %rdx
callq 0x2200
movq 0xab4d(%rip), %rdi      # 0x129e8
leaq 0xa5fe(%rip), %r14      # 0x124a0
pushq $0x1
popq %rbx
movq %r14, %rsi
movl %ebx, %edx
callq 0x246d
leaq 0x5532(%rip), %rsi      # 0xd3e8
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x20a0
testl %eax, %eax
je 0x7edf
movsd 0x8(%rsp), %xmm0
movq 0xa708(%rip), %rax      # 0x125e0
movsd %xmm0, 0x18(%rax)
movl %ebx, %ebp
movl %ebp, %edi
callq 0x6c1e
testb %al, %al
je 0x7f17
movq 0xa6ef(%rip), %rax      # 0x125e0
andw $0x0, 0x48(%rax)
movq 0xa6cb(%rip), %rdx      # 0x125c8
leaq 0xa59c(%rip), %rdi      # 0x124a0
leaq 0x4b19(%rip), %rsi      # 0xca24
xorl %eax, %eax
callq 0x2190
callq 0x399b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xaa50(%rip), %rax      # 0x12980
cmpb $0x0, 0xc0(%rax)
je 0x7f47
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x6bf6
leaq 0x7(%rsp), %r14
movb $0x0, (%r14)
movq 0xaa91(%rip), %rdi      # 0x129e8
leaq 0x4ad5(%rip), %rsi      # 0xca33
pushq $-0x1
popq %rdx
callq 0x2200
leaq 0x6(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x702f
movl %eax, %ebx
cmpb $0x0, (%r15)
setne %cl
movb (%r14), %al
testb %al, %al
setne %dl
testb %dl, %cl
je 0x7fea
movsbl %al, %edi
callq 0x6c1e
testb %al, %al
je 0x7ff8
movl %ebx, %eax
incl %eax
movq 0xa63e(%rip), %rcx      # 0x125e0
movw %ax, 0x48(%rcx)
xorl %edi, %edi
movl %ebx, %esi
callq 0x3a49
movsd %xmm0, 0x8(%rsp)
callq 0x3933
movq 0xa607(%rip), %rdx      # 0x125c8
leaq 0xa4d8(%rip), %rdi      # 0x124a0
leaq 0x4a7b(%rip), %rsi      # 0xca4a
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x2190
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x399b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x6b6e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa1d0(%rip), %rdx      # 0x125b8
movq 0xa581(%rip), %rcx      # 0x12970
leaq 0xa0aa(%rip), %rbx      # 0x124a0
leaq 0x4a29(%rip), %rsi      # 0xce26
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2190
callq 0x399b
movq 0xa1b5(%rip), %rdx      # 0x125c8
leaq 0x4a3c(%rip), %rsi      # 0xce56
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2190
callq 0x399b
movq 0xa188(%rip), %rcx      # 0x125b8
movq 0xa4e9(%rip), %r8       # 0x12920
leaq 0x4a28(%rip), %rsi      # 0xce66
movq %rbx, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x2190
callq 0x399b
movq 0xa591(%rip), %rdi      # 0x129e8
leaq 0x4a3c(%rip), %rsi      # 0xce9a
pushq $-0x1
popq %rdx
callq 0x2200
callq 0x3933
cmpb $0x5, 0xa165(%rip)      # 0x125d7
jne 0x8499
movq 0xa4fd(%rip), %rdx      # 0x12978
movq 0xa136(%rip), %rcx      # 0x125b8
leaq 0xa017(%rip), %rdi      # 0x124a0
leaq 0x4a47(%rip), %rsi      # 0xced7
xorl %eax, %eax
callq 0x2190
jmp 0x84be
cmpb $0x0, 0xa136(%rip)      # 0x125d6
je 0x84c4
movq 0xa11f(%rip), %rdx      # 0x125c8
leaq 0x9ff0(%rip), %rdi      # 0x124a0
leaq 0x4a5d(%rip), %rsi      # 0xcf14
xorl %eax, %eax
callq 0x2190
popq %rbx
jmp 0x399b
movb $0x1, 0xa10b(%rip)      # 0x125d6
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movq 0xa0e3(%rip), %rdx      # 0x125b8
leaq 0x9fc4(%rip), %rdi      # 0x124a0
leaq 0x4a60(%rip), %rsi      # 0xcf43
xorl %eax, %eax
callq 0x2190
callq 0x399b
cmpb $0x0, 0xa0dd(%rip)      # 0x125d3
je 0x8521
movq 0xa0c9(%rip), %rdx      # 0x125c8
movq 0xa46a(%rip), %rcx      # 0x12970
leaq 0x9f93(%rip), %rdi      # 0x124a0
leaq 0x4a4c(%rip), %rsi      # 0xcf60
xorl %eax, %eax
callq 0x2190
popq %rax
jmp 0x399b
movq 0xa4c0(%rip), %rdi      # 0x129e8
leaq 0x4a59(%rip), %rsi      # 0xcf88
pushq $-0x1
popq %rdx
callq 0x2200
movq 0xa4aa(%rip), %rdi      # 0x129e8
leaq 0x9f5b(%rip), %rsi      # 0x124a0
pushq $0x1
popq %rdx
callq 0x246d
movzbl 0x9f4c(%rip), %eax      # 0x124a0
testl %eax, %eax
je 0x8576
andl $-0x21, %eax
cmpl $0x45, %eax
je 0x857c
cmpl $0x50, %eax
jne 0x8576
movsd 0x2a9b(%rip), %xmm0     # 0xb008
movq 0xa40c(%rip), %rax      # 0x12980
jmp 0x85b7
popq %rax
jmp 0x6b6e
movq 0xa05d(%rip), %rcx      # 0x125e0
movsd 0x20(%rcx), %xmm2
addsd 0x2a78(%rip), %xmm2     # 0xb008
movsd %xmm2, 0x20(%rcx)
movq 0xa3e4(%rip), %rax      # 0x12980
movzbl 0x18(%rax), %edx
cvtsi2sd %edx, %xmm1
movsd 0x2bb4(%rip), %xmm0     # 0xb160
ucomisd %xmm1, %xmm2
jbe 0x85b7
movsd %xmm1, 0x20(%rcx)
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x85cd
andq $0x0, 0x80(%rax,%rcx,8)
incq %rcx
jmp 0x85b9
movzbl 0x9bdc(%rip), %eax      # 0x121b0
movq 0xa3a5(%rip), %rcx      # 0x12980
xorl %edx, %edx
cmpq %rdx, %rax
je 0x85ed
movsd %xmm0, 0x40(%rcx,%rdx,8)
incq %rdx
jmp 0x85dd
movb $0x1, 0x9fdf(%rip)      # 0x125d3
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
orl $-0x1, 0x9302(%rip)     # 0x12a28
movq 0x9253(%rip), %rax      # 0x12980
cmpb $0x0, 0xc1(%rax)
jne 0x6bd4
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x3f48(%rip), %rbx      # 0xd691
pushq $-0x1
popq %rbp
leaq 0x8d4d(%rip), %r14      # 0x124a0
pushq $0x1
popq %r15
leaq 0x3f52(%rip), %r12      # 0xd6b0
movq 0x9283(%rip), %rdi      # 0x129e8
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2200
movq 0x9272(%rip), %rdi      # 0x129e8
movq %r14, %rsi
movl %r15d, %edx
callq 0x246d
movq %r14, %rdi
callq 0x21c0
leal -0x2711(%rax), %ecx
cmpl $0xffffd921, %ecx       # imm = 0xFFFFD921
jae 0x97b6
movq 0x924a(%rip), %rdi      # 0x129e8
movq %r12, %rsi
movl %ebp, %edx
callq 0x2200
movq 0x9239(%rip), %rdi      # 0x129e8
callq 0x2180
jmp 0x975e
movl %eax, 0x925c(%rip)      # 0x12a18
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x10, %rsp
movq 0x91ab(%rip), %rax      # 0x12980
cmpb $0x0, 0xc0(%rax)
je 0x97ec
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x6bf6
leaq 0xf(%rsp), %r14
movb $0x0, (%r14)
movq 0x91ec(%rip), %rdi      # 0x129e8
leaq 0x3ed6(%rip), %rsi      # 0xd6d9
pushq $-0x1
popq %rdx
callq 0x2200
leaq 0xe(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x702f
movl %eax, %ebx
cmpb $0x0, (%r15)
setne %cl
movb (%r14), %al
testb %al, %al
setne %dl
testb %dl, %cl
je 0x98bf
movsbl %al, %edi
callq 0x6c1e
testb %al, %al
je 0x98cd
movl %ebx, %eax
notl %eax
movq 0x8d91(%rip), %rcx      # 0x125e0
movw %ax, 0x48(%rcx)
xorl %edi, %edi
movl %ebx, %esi
callq 0x3a49
addsd 0x17bc(%rip), %xmm0     # 0xb020
callq 0x39cd
movq 0x8d58(%rip), %rdx      # 0x125c8
leaq 0x8c29(%rip), %rdi      # 0x124a0
leaq 0x31cc(%rip), %rsi      # 0xca4a
movb $0x1, %al
callq 0x2190
movq 0x915c(%rip), %rdi      # 0x129e8
pushq $0x3
popq %rsi
xorl %edx, %edx
callq 0x21d0
cmpl $-0x1, %eax
je 0x98b1
movq 0x9146(%rip), %rdi      # 0x129e8
leaq 0x8bf7(%rip), %rsi      # 0x124a0
pushq $-0x1
popq %rdx
callq 0x2200
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3933
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x6b6e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x90fd(%rip), %rdi      # 0x129e8
leaq 0x3dfd(%rip), %rsi      # 0xd6ef
pushq $-0x1
popq %rdx
callq 0x2200
leaq 0xe(%rsp), %rsi
movq %rbx, %rdi
callq 0x702f
movq 0x9072(%rip), %rcx      # 0x12980
cmpb $0x0, 0xc1(%rcx)
je 0x9921
addq $0x10, %rsp
popq %rbx
jmp 0x6bd4
cmpb $0x0, 0xe(%rsp)
je 0x993b
cmpb $0x0, 0xf(%rsp)
je 0x993b
movl %eax, %edi
addq $0x10, %rsp
popq %rbx
jmp 0x6d46
addq $0x10, %rsp
popq %rbx
jmp 0x6b2a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq 0x9031(%rip), %rax      # 0x12980
cmpb $0x0, 0xc4(%rax)
movq 0x908b(%rip), %rdi      # 0x129e8
je 0x99ce
leaq 0x3d9d(%rip), %rsi      # 0xd703
pushq $-0x1
popq %rbx
movl %ebx, %edx
callq 0x2200
callq 0x3933
callq 0x3933
movq 0x9067(%rip), %rdi      # 0x129e8
leaq 0x3da8(%rip), %rsi      # 0xd730
movl %ebx, %edx
callq 0x2200
movq 0x8c32(%rip), %rdx      # 0x125c8
cmpb $0x1, 0x908f(%rip)      # 0x12a2c
jne 0x9a15
leaq 0x8afa(%rip), %rbx      # 0x124a0
leaq 0x3d8c(%rip), %rsi      # 0xd739
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2190
movq 0x902a(%rip), %rdi      # 0x129e8
pushq $-0x1
popq %rdx
movq %rbx, %rsi
callq 0x2200
jmp 0x9a83
leaq 0x3dae(%rip), %rsi      # 0xd783
pushq $-0x1
popq %rbx
movl %ebx, %edx
callq 0x2200
callq 0x3933
callq 0x3933
movq 0x8ff8(%rip), %rdi      # 0x129e8
leaq 0x3dba(%rip), %rsi      # 0xd7b1
movl %ebx, %edx
callq 0x2200
callq 0x3933
callq 0x3933
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5ca9
leaq 0x8a84(%rip), %rbx      # 0x124a0
leaq 0x3d3b(%rip), %rsi      # 0xd75e
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2190
movq 0x8fb2(%rip), %rdi      # 0x129e8
pushq $-0x1
popq %rdx
movq %rbx, %rsi
callq 0x2200
movzbl 0x8b8a(%rip), %eax      # 0x125d2
leaq 0x8b91(%rip), %rcx      # 0x125e0
movabsq $0x40c3880000000000, %rdx # imm = 0x40C3880000000000
movswl %bp, %esi
cmpl %eax, %esi
jge 0x9a7c
movswq %bp, %rsi
movq (%rcx,%rsi,8), %rsi
testq %rsi, %rsi
je 0x9a78
cmpw $0xa, 0x4a(%rsi)
jne 0x9a78
movq %rdx, 0x30(%rsi)
incl %ebp
jmp 0x9a59
movb $0x1, 0x8fa9(%rip)      # 0x12a2c
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3933
// File: /workspace/github_c_makefile_star2_O2/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 0x8b22(%rip), %rdx      # 0x125b8
movq 0x8ed3(%rip), %rcx      # 0x12970
leaq 0x89fc(%rip), %rbx      # 0x124a0
leaq 0x3d32(%rip), %rsi      # 0xd7dd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2190
callq 0x399b
movq 0x8b07(%rip), %rdx      # 0x125c8
leaq 0x3d3c(%rip), %rsi      # 0xd804
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2190
callq 0x399b
movq 0x8ada(%rip), %rcx      # 0x125b8
movq 0x8e3b(%rip), %r8       # 0x12920
leaq 0x3d29(%rip), %rsi      # 0xd815
movq %rbx, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x2190
callq 0x399b
movq 0x8ee3(%rip), %rdi      # 0x129e8
leaq 0x3d38(%rip), %rsi      # 0xd844
pushq $-0x1
popq %rdx
callq 0x2200
callq 0x3933
cmpb $0x4, 0x8ab7(%rip)      # 0x125d7
jne 0x9b39
movq 0x8a9f(%rip), %rdx      # 0x125c8
leaq 0x8970(%rip), %rdi      # 0x124a0
leaq 0x3d37(%rip), %rsi      # 0xd86e
jmp 0x9b57
cmpb $0x0, 0x8a95(%rip)      # 0x125d5
movq 0x8e29(%rip), %rdx      # 0x12970
je 0x9b64
leaq 0x8950(%rip), %rdi      # 0x124a0
leaq 0x3d40(%rip), %rsi      # 0xd897
xorl %eax, %eax
callq 0x2190
popq %rbx
jmp 0x399b
cmpq 0x874d(%rip), %rdx      # 0x122b8
jne 0x9ba4
movq 0x8e74(%rip), %rdi      # 0x129e8
leaq 0x3d42(%rip), %rsi      # 0xd8bd
pushq $-0x1
popq %rbx
movl %ebx, %edx
callq 0x2200
callq 0x3933
movq 0x8e57(%rip), %rdi      # 0x129e8
leaq 0x3d5c(%rip), %rsi      # 0xd8f4
movl %ebx, %edx
callq 0x2200
callq 0x3933
movb $0x1, 0x8a2a(%rip)      # 0x125d5
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: EStop
void EStop()
{
  waddstr(Cmdwin,"Quit game");
  if (Yes())
    Stop = true;
  TCount = (-1);
}

// Assembly:
pushq %rax
movq 0x89d6(%rip), %rdi      # 0x129e8
leaq 0x4045(%rip), %rsi      # 0xe05e
pushq $-0x1
popq %rdx
callq 0x2200
callq 0x6aab
testb %al, %al
je 0xa031
movb $0x1, 0x89f3(%rip)      # 0x12a24
orl $-0x1, 0x89f0(%rip)     # 0x12a28
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2555
xorl %r14d, %r14d
leaq 0x834f(%rip), %r15      # 0x125e0
leaq 0x86e8(%rip), %r12      # 0x12980
pushq $-0x1
popq %rbp
callq 0x2607
orl $-0x1, 0x8781(%rip)     # 0x12a28
movl $0x1388, 0x8767(%rip)   # imm = 0x1388
andl $0x0, 0x8768(%rip)      # 0x12a20
movb %r14b, 0x8318(%rip)     # 0x125d7
andl $0x0, 0x874e(%rip)      # 0x12a14
callq 0x34aa
movb %r14b, 0x8752(%rip)     # 0x12a24
movb %r14b, 0x8743(%rip)     # 0x12a1c
movslq 0x8748(%rip), %rax      # 0x12a28
leal 0x1(%rax), %ecx
movl %ecx, 0x873f(%rip)      # 0x12a28
movzbl 0x82e0(%rip), %ecx      # 0x125d0
cmpl %ecx, %eax
jge 0xa325
movq 0x8(%r15,%rax,8), %rcx
testq %rcx, %rcx
je 0xa32a
movzwl 0x4a(%rcx), %ecx
cmpw $0x9, %cx
jg 0xa32a
movq 0x8(%r12,%rax,8), %rax
testq %rax, %rax
je 0xa32a
cmpw $0x0, 0x1a(%rax)
je 0xa32a
testw %cx, %cx
je 0xa335
callq 0x5d97
jmp 0xa32a
callq 0x58bf
cmpb $0x1, 0x86f3(%rip)      # 0x12a24
jne 0xa2d9
jmp 0xa33c
callq 0xa03a
jmp 0xa32a
movq 0x86a5(%rip), %rdi      # 0x129e8
leaq 0x3d26(%rip), %rsi      # 0xe070
movl %ebp, %edx
callq 0x2200
callq 0x6aab
testb %al, %al
je 0xa3f6
movq 0x86a3(%rip), %rdi      # 0x12a08
callq 0x21b0
movq 0x868f(%rip), %rdi      # 0x12a00
callq 0x21b0
movq 0x867b(%rip), %rdi      # 0x129f8
callq 0x21b0
movq 0x865f(%rip), %rdi      # 0x129e8
callq 0x21b0
movq 0x8643(%rip), %rdi      # 0x129d8
callq 0x21b0
movq 0x863f(%rip), %rdi      # 0x129e0
callq 0x21b0
movzbl 0x8224(%rip), %r13d     # 0x125d2
testl %r13d, %r13d
js 0xa3ce
movl %r13d, %ebx
movq (%r15,%rbx,8), %rdi
testq %rdi, %rdi
je 0xa3c9
callq 0x2120
andq $0x0, (%r15,%rbx,8)
decl %r13d
jmp 0xa3ae
xorl %r13d, %r13d
cmpq $0x50, %r13
je 0xa29b
movq (%r13,%r12), %rdi
testq %rdi, %rdi
je 0xa3f0
callq 0x2120
andq $0x0, (%r13,%r12)
addq $0x8, %r13
jmp 0xa3d1
callq 0x21f0
xorl %edi, %edi
callq 0x20c0
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movl %ecx, %r15d
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %rbp
orl $-0x1, 0x14(%rsp)
leal 0x1(%r15), %eax
movl %eax, 0xc(%rsp)
imull %ecx, %eax
movslq %eax, %rdi
pushq $0x8
popq %rsi
callq 0x2190
movq %rax, 0x18(%rsp)
movslq %r15d, %r12
pushq $0x4
popq %rsi
movq %r12, %rdi
callq 0x2190
movq %rax, %r15
xorl %eax, %eax
testl %r12d, %r12d
movl $0x0, %r14d
cmovgl %r12d, %r14d
movl %r12d, %ecx
leaq (,%r12,8), %rdx
movq %r12, %r11
leaq 0x8(,%r12,8), %r12
movq 0x18(%rsp), %rsi
movq %rsi, %r8
cmpq %r14, %rax
je 0x309b
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x3090
movsd (%rbp,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
jmp 0x307b
incq %rax
addq %r12, %rsi
addq %rdx, %rbp
jmp 0x3074
movq %r8, %rbp
leaq (%r8,%r11,8), %rax
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x30bc
movsd (%r13,%rcx,8), %xmm0
movsd %xmm0, (%rax)
incq %rcx
addq %r12, %rax
jmp 0x30a4
leaq 0x14(%rsp), %rax
leaq 0x20(%rsp), %r10
pushq $0x1
popq %r9
movq %rbp, %rdi
movq %r11, %r13
movl %r13d, %esi
movl 0xc(%rsp), %edx
movl %r13d, %ecx
movl %r13d, %r8d
pushq %rax
pushq %r10
leaq 0x20(%rsp), %rax
pushq %rax
pushq %r15
callq 0x2210
addq $0x20, %rsp
leaq (,%r13,8), %rax
addq %rbp, %rax
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x3118
movsd (%rax), %xmm0
movslq (%r15,%rcx,4), %rdx
movsd %xmm0, (%rbx,%rdx,8)
incq %rcx
addq %r12, %rax
jmp 0x30fe
movq %rbp, %rdi
callq 0x2040
movq %r15, %rdi
callq 0x2040
movl 0x10(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movl %edx, %r14d
movq %rsi, 0x18(%rsp)
movq %rdi, %r13
orl $-0x1, 0x4(%rsp)
leal (%r14,%r14), %ebp
movl %ebp, %eax
imull %edx, %eax
movslq %eax, %rdi
pushq $0x8
popq %rsi
callq 0x2190
movq %rax, %rbx
movslq %r14d, %r15
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0x2190
movq %rbx, %r9
movq %rax, %r12
xorl %eax, %eax
testl %r15d, %r15d
movl $0x0, %ebx
movq %r14, 0x8(%rsp)
cmovgl %r14d, %ebx
movl %r15d, %ecx
movq %r15, %rdx
shlq $0x4, %rdx
leaq (,%r15,8), %r14
movq %r9, %rsi
cmpq %rbx, %rax
je 0x31d4
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x31c9
movsd (%r13,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
jmp 0x31b3
incq %rax
addq %rdx, %rsi
addq %r14, %r13
jmp 0x31ac
movslq %ebp, %r13
leaq (%r9,%r15,8), %rax
xorl %ecx, %ecx
movsd 0x6e93(%rip), %xmm0     # 0xa078
xorl %edx, %edx
cmpq %rbx, %rdx
je 0x321a
movslq %ecx, %rsi
leaq (%rax,%rsi,8), %rsi
xorl %edi, %edi
leaq (%r15,%rdi), %r8
cmpq %r13, %r8
jge 0x3213
movaps %xmm0, %xmm1
cmpq %rdi, %rdx
je 0x3209
xorps %xmm1, %xmm1
movsd %xmm1, (%rsi,%rdi,8)
incq %rdi
jmp 0x31f5
incq %rdx
addl %ebp, %ecx
jmp 0x31e7
leaq 0x4(%rsp), %rax
movq %r9, 0x10(%rsp)
leaq 0x20(%rsp), %r10
movq %rsp, %r11
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rcx
movl %ecx, %esi
movl %ebp, %edx
movl %ecx, %r8d
movl %ecx, %r9d
pushq %rax
pushq %r10
pushq %r11
pushq %r12
callq 0x2210
movq 0x30(%rsp), %rdi
addq $0x20, %rsp
movq 0x18(%rsp), %r9
subq %r14, %r9
movslq 0x8(%rsp), %rax
cmpq %r13, %r15
jge 0x329b
leaq (%rdi,%r15,8), %rcx
leaq (%r9,%r15,8), %rdx
xorl %esi, %esi
xorl %r10d, %r10d
cmpq %r10, %rbx
je 0x3296
movslq %esi, %rsi
movsd (%rcx,%rsi,8), %xmm0
movslq (%r12,%r10,4), %r8
imulq %rax, %r8
movsd %xmm0, (%rdx,%r8,8)
incq %r10
addl %ebp, %esi
jmp 0x3274
incq %r15
jmp 0x3262
callq 0x2040
movq %r12, %rdi
callq 0x2040
movl (%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x3467
movq %rsi, %r14
movsd 0x18(%rsi), %xmm1
ucomisd 0x6c68(%rip), %xmm1     # 0xa078
jne 0x347a
jp 0x347a
movq %rdx, %rbx
pushq $0x4
popq %rdx
movq %rbx, %rsi
callq 0x2380
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
andq $0x0, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xab8a(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x6c47(%rip), %rdi      # 0xa0bf
jmp 0x348b
movq 0xab77(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x6c54(%rip), %rdi      # 0xa0df
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
callq 0x2410
xorl %eax, %eax
jmp 0x345f