LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/lib/cmdopt.c
// Function: cmdopt_parse
int cmdopt_parse(int argc, char *const argv[], const struct cmdopt *opts)
{
	int arg;
	const struct cmdopt *param_opt = opts;
	while(param_opt->option)
		++param_opt;
	for(arg = 1; arg != argc; ++arg) {
		const char *s = argv[arg];
		if(s[0] != '-') /* non-option parameter */
			handle(param_opt, s);
		else {
			const char *eq = strchr(++s, '='); /* drop out '-' */
			if(eq) { /* parameter with value */
				size_t param_len = eq - s;
				const struct cmdopt *opt;
				for(opt = opts; opt->option; ++opt)
					if(strncmp(s, opt->option, param_len) == 0
							&& opt->option[param_len] == '\0') {
						handle(opt, eq + 1);
						goto loop;
					}
				return arg;
			} else { /* parameter without value */
				const struct cmdopt *opt;
				for(opt = opts; opt->option; ++opt)
					if(strcmp(s, opt->option) == 0) {
						handle(opt, NULL);
						goto loop;
					}
				return arg;
			}
		}
loop: ;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x22793
movq -0x28(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
jmp 0x2277b
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
je 0x228ce
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x227d4
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x228e0
jmp 0x228bc
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
movq %rdi, -0x30(%rbp)
movl $0x3d, %esi
callq 0x4100
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x2286e
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq $0x0, (%rax)
je 0x22866
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rax
movq (%rax), %rsi
movq -0x40(%rbp), %rdx
callq 0x41d0
cmpl $0x0, %eax
jne 0x22856
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x22856
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x1, %rsi
callq 0x228e0
jmp 0x228be
jmp 0x22858
movq -0x48(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x48(%rbp)
jmp 0x2280c
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x228d5
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq $0x0, (%rax)
je 0x228b4
movq -0x30(%rbp), %rdi
movq -0x50(%rbp), %rax
movq (%rax), %rsi
callq 0x4510
cmpl $0x0, %eax
jne 0x228a4
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x228e0
jmp 0x228be
jmp 0x228a6
movq -0x50(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x50(%rbp)
jmp 0x22876
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x228d5
jmp 0x228be
jmp 0x228c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2279a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/lib/cmdopt.c
// Function: handle
static void handle(const struct cmdopt *opt, const char *param)
{
	if(opt->flag)
		*opt->flag = 1;
	if(opt->handler)
		opt->handler(param);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x22909
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x22922
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/lib/cmdopt.c
// Function: cmdopt_print
void cmdopt_print(const struct cmdopt *opts)
{
	const struct cmdopt *opt;
	int maxlen = 0;
	/* calculate maximum option length */
	for(opt = opts; opt->option; ++opt) {
		int len = strlen(opt->option);
		if(len > maxlen)
			maxlen = len;
	}
	for(opt = opts; opt->option; ++opt)
		printf("  -%-*s%s  %s\n", maxlen, opt->option,
				opt->handler ? "=v" : "  ", opt->description);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x22982
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4190
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x22972
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x22974
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
jmp 0x2294b
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x229e0
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0xf2c(%rip), %rcx       # 0x238d9
leaq 0xf22(%rip), %rax       # 0x238d6
cmpq $0x0, %rdi
cmovneq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %r8
leaq 0xefc(%rip), %rdi       # 0x238c7
movb $0x0, %al
callq 0x4060
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
jmp 0x2298a
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: Delay
void Delay(int msec)
{
  struct timeval Timeout;

  msec *= 1000;
  Timeout.tv_usec = msec % 1000000;
  Timeout.tv_sec = msec / 1000000;
  select(0, NULL, NULL, NULL, &Timeout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
imull $0x3e8, -0x4(%rbp), %eax # imm = 0x3E8
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl $0xf4240, %ecx          # imm = 0xF4240
cltd
idivl %ecx
movslq %edx, %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl $0xf4240, %ecx          # imm = 0xF4240
cltd
idivl %ecx
cltq
movq %rax, -0x18(%rbp)
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x18(%rbp), %r8
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x20c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: SysInit
void SysInit()
{
  srand(getpid());
  initscr();

  if ((LINES < 24) || (COLS < 80)) {
	printf("Sorry, you must have at least a 24 by 80 screen to play.\n");
	exit(1);
  }

  _Erase=erasechar();
  _Kill=killchar();
  noecho();
  raw();
  nonl();

  Disrow = LINES * 19 / 24;
  Cmdrow = LINES - Disrow;
  if (!(Disrow & 1)) {
	Disrow++;	/* Insure Disrow is odd */
	Cmdrow--;
  }
  Discol = COLS - 45;
  if (!(Discol & 1)) {
	Discol--;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2100
movl %eax, %edi
callq 0x2240
callq 0x2270
movq 0x12914(%rip), %rax     # 0x14fc0
cmpl $0x18, (%rax)
jl 0x26bd
movq 0x12928(%rip), %rax     # 0x14fe0
cmpl $0x50, (%rax)
jge 0x26d5
leaq 0xd534(%rip), %rdi      # 0xfbf8
movb $0x0, %al
callq 0x2040
movl $0x1, %edi
callq 0x20d0
callq 0x2170
movb %al, 0x12db0(%rip)      # 0x15490
callq 0x2030
movb %al, 0x12da6(%rip)      # 0x15491
callq 0x2060
callq 0x2110
callq 0x2280
movq 0x128bf(%rip), %rax     # 0x14fc0
imull $0x13, (%rax), %eax
movl $0x18, %ecx
cltd
idivl %ecx
movl %eax, 0x12d82(%rip)     # 0x15494
movq 0x128a7(%rip), %rax     # 0x14fc0
movl (%rax), %eax
subl 0x12d73(%rip), %eax     # 0x15494
movl %eax, 0x12d71(%rip)     # 0x15498
movl 0x12d67(%rip), %eax     # 0x15494
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x2753
movl 0x12d59(%rip), %eax     # 0x15494
addl $0x1, %eax
movl %eax, 0x12d50(%rip)     # 0x15494
movl 0x12d4e(%rip), %eax     # 0x15498
addl $-0x1, %eax
movl %eax, 0x12d45(%rip)     # 0x15498
movq 0x12886(%rip), %rax     # 0x14fe0
movl (%rax), %eax
subl $0x2d, %eax
movl %eax, 0x12d37(%rip)     # 0x1549c
movl 0x12d31(%rip), %eax     # 0x1549c
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x2782
movl 0x12d23(%rip), %eax     # 0x1549c
addl $-0x1, %eax
movl %eax, 0x12d1a(%rip)     # 0x1549c
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: DrawRep
void DrawRep()
{
  int i, j;

  werase(Repwin);
  mvwaddstr(Repwin,0,14,"Warp Course Bearing Range");
  j=1;
  for (i=0; i<=Enemies; i++)
    if (Ships[i]) {
      sprintf(scrstr,"%12s:",Snams[i]);
      mvwaddstr(Repwin,j,0,scrstr);
      j++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x11f19(%rip), %rdi     # 0x159d8
callq 0x2090
movq 0x11f0d(%rip), %rdi     # 0x159d8
xorl %esi, %esi
movl $0xe, %edx
callq 0x21d0
cmpl $-0x1, %eax
jne 0x3ade
jmp 0x3af6
movq 0x11ef3(%rip), %rdi     # 0x159d8
leaq 0xc4f0(%rip), %rsi      # 0xffdc
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
movl $0x1, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movzbl 0x11ac2(%rip), %ecx     # 0x155d0
cmpl %ecx, %eax
jg 0x3b91
movslq -0x4(%rbp), %rcx
leaq 0x11e63(%rip), %rax     # 0x15980
cmpq $0x0, (%rax,%rcx,8)
je 0x3b81
movslq -0x4(%rbp), %rcx
leaq 0x11df1(%rip), %rax     # 0x15920
movq (%rax,%rcx,8), %rdx
leaq 0x11966(%rip), %rdi     # 0x154a0
leaq 0xc4b5(%rip), %rsi      # 0xfff6
movb $0x0, %al
callq 0x2190
movq 0x11e89(%rip), %rdi     # 0x159d8
movl -0x8(%rbp), %esi
xorl %edx, %edx
callq 0x21d0
cmpl $-0x1, %eax
jne 0x3b60
jmp 0x3b78
movq 0x11e71(%rip), %rdi     # 0x159d8
leaq 0x11932(%rip), %rsi     # 0x154a0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3b83
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3b04
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: DrawBox
void DrawBox(win, rows, cols)
WINDOW *win;
int rows, cols;
{
  int i, j;

  rows--;
  cols--;
  wmove(win, 0, 1);
  for (i=1; i<cols; i++)
    waddch(win,ACS_HLINE);
  j=cols;
  for (i=1; i<rows; i++)
  {
    mvwaddch(win, i, j, ACS_VLINE);
    mvwaddch(win, i, 0, ACS_VLINE);
  }
  wmove(win, i, 1);
  for (i=1; i<cols; i++)
    waddch(win,ACS_HLINE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x21d0
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3c04
movq -0x8(%rbp), %rdi
movq 0x11402(%rip), %rax     # 0x14ff0
movl 0x1c4(%rax), %esi
callq 0x2150
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3bdb
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3c7b
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x21d0
cmpl $-0x1, %eax
jne 0x3c2f
jmp 0x3c45
movq -0x8(%rbp), %rdi
movq 0x113b6(%rip), %rax     # 0x14ff0
movl 0x1e0(%rax), %esi
callq 0x2150
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x21d0
cmpl $-0x1, %eax
jne 0x3c5a
jmp 0x3c70
movq -0x8(%rbp), %rdi
movq 0x1138b(%rip), %rax     # 0x14ff0
movl 0x1e0(%rax), %esi
callq 0x2150
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3c11
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x21d0
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3cbc
movq -0x8(%rbp), %rdi
movq 0x1134a(%rip), %rax     # 0x14ff0
movl 0x1c4(%rax), %esi
callq 0x2150
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3c93
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: Endln
void Endln()
{
  LKnt++;
  if (LKnt == Cmdrow) {
    wrefresh(Cmdwin);
    getch();
    LKnt = 0;
  }
  waddstr(Cmdwin,"\n");
  wclrtoeol(Cmdwin);
  wrefresh(Cmdwin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x1176a(%rip), %eax     # 0x15a14
addl $0x1, %eax
movl %eax, 0x11761(%rip)     # 0x15a14
movl 0x1175b(%rip), %eax     # 0x15a14
cmpl 0x111d9(%rip), %eax     # 0x15498
jne 0x42e6
movq 0x11720(%rip), %rdi     # 0x159e8
callq 0x2180
movq 0x10d14(%rip), %rax     # 0x14fe8
movq (%rax), %rdi
callq 0x22f0
movl $0x0, 0x1172e(%rip)     # 0x15a14
movq 0x116fb(%rip), %rdi     # 0x159e8
leaq 0xba3f(%rip), %rsi      # 0xfd33
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
movq 0x116e3(%rip), %rdi     # 0x159e8
callq 0x2210
movq 0x116d7(%rip), %rdi     # 0x159e8
callq 0x2180
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: Sign
int Sign(X)
double X;
{
  int Y;

  if (X < 0)
    Y = -1;
  else
    Y = 1;
  return Y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0x436c
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0x4373
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: RMod
double RMod(X)
double X;
{
  double TEMP;

  modf(X/360, &TEMP);
  X -= TEMP * 360;
  if (X >= 360)
    X -= 360;
  if (X < 0)
    X += 360;
  return X;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xacde(%rip), %xmm1     # 0xf078
divsd %xmm1, %xmm0
leaq -0x10(%rbp), %rdi
callq 0x22a0
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0xaca8(%rip), %xmm2     # 0xf078
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xac8e(%rip), %xmm1     # 0xf078
ucomisd %xmm1, %xmm0
jb 0x4406
movsd -0x8(%rbp), %xmm0
movsd 0xac7b(%rip), %xmm1     # 0xf078
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0x4422
movsd 0xac60(%rip), %xmm0     # 0xf078
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: Bearing
double Bearing(From, NTo)
int From, NTo;
{
  double X, Y, Temp;

  X = Objects[NTo]->XPos - Objects[From]->XPos;
  Y = Objects[From]->YPos - Objects[NTo]->YPos;
  if (X != 0)
    Temp = atan(Y / X) * 180 / M_PI;
  else
    Temp = 90.0;
  if (X >= 0 && Y < 0)
    Temp += 360;
  else if (X < 0)
    Temp += 180;
  return Temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x11197(%rip), %rax     # 0x155e0
movq (%rax,%rcx,8), %rax
movsd 0x38(%rax), %xmm0
movslq -0x4(%rbp), %rcx
leaq 0x11183(%rip), %rax     # 0x155e0
movq (%rax,%rcx,8), %rax
subsd 0x38(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x1116a(%rip), %rax     # 0x155e0
movq (%rax,%rcx,8), %rax
movsd 0x40(%rax), %xmm0
movslq -0x8(%rbp), %rcx
leaq 0x11156(%rip), %rax     # 0x155e0
movq (%rax,%rcx,8), %rax
subsd 0x40(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x44aa
jp 0x44aa
jmp 0x44d8
movsd -0x18(%rbp), %xmm0
divsd -0x10(%rbp), %xmm0
callq 0x2130
movsd 0xab5f(%rip), %xmm1     # 0xf020
mulsd %xmm1, %xmm0
movsd 0xab5b(%rip), %xmm1     # 0xf028
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x44e5
movsd 0xab60(%rip), %xmm0     # 0xf040
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4511
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x4511
movsd 0xab73(%rip), %xmm0     # 0xf078
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x452f
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x452d
movsd 0xaafd(%rip), %xmm0     # 0xf020
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x452f
movsd -0x20(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: Range
double Range(From, NTo)
int From, NTo;
{
  double X, Y;

  if (Objects[NTo] != NULL) {
    X = Objects[NTo]->XPos - Objects[From]->XPos;
    Y = Objects[From]->YPos - Objects[NTo]->YPos;
    return sqrt(X * X + Y * Y);
  } else
    return 9999.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movslq -0x10(%rbp), %rcx
leaq 0x11087(%rip), %rax     # 0x155e0
cmpq $0x0, (%rax,%rcx,8)
je 0x45e6
movslq -0x10(%rbp), %rcx
leaq 0x11071(%rip), %rax     # 0x155e0
movq (%rax,%rcx,8), %rax
movsd 0x38(%rax), %xmm0
movslq -0xc(%rbp), %rcx
leaq 0x1105d(%rip), %rax     # 0x155e0
movq (%rax,%rcx,8), %rax
subsd 0x38(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x11044(%rip), %rax     # 0x155e0
movq (%rax,%rcx,8), %rax
movsd 0x40(%rax), %xmm0
movslq -0x10(%rbp), %rcx
leaq 0x11030(%rip), %rax     # 0x155e0
movq (%rax,%rcx,8), %rax
subsd 0x40(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x18(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x22e0
movsd %xmm0, -0x8(%rbp)
jmp 0x45f3
movsd 0xaa92(%rip), %xmm0     # 0xf080
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: TrakPhas
void TrakPhas(I, J)
int I, J;
{
  int K;
  double D;

  K = Ships[I]->Pstat[J];
  if (K >= 100)
    K -= 100;
  if (K) {
    if (Ships[K-1] == NULL) {
      Ships[I]->Pstat[J] = 0;
      K = 0;
      if (!I) {
	sprintf(scrstr," Phaser %d disengaging.", J+1);
	SEndln();
      }
    } else {
      D = Bearing(I, K-1) - Objects[I]->Act_Crs;
      D = RMod(D);
      Ships[I]->Pdepl[J] = (long)floor(D + 0.5);
    }
  }
  D = Ships[I]->Pdepl[J];
  /* If phaser was set to fire, but engineering is in the way, don't fire. */
  if (D > 125 && D < 235 && !Ships[I]->Dmge[(int)Engn])
    Ships[I]->Pstat[J] = K;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x10487(%rip), %rax     # 0x15980
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movswl 0xd2(%rax,%rcx,2), %eax
movl %eax, -0xc(%rbp)
cmpl $0x64, -0xc(%rbp)
jl 0x551b
movl -0xc(%rbp), %eax
subl $0x64, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x55f5
movl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x1044b(%rip), %rax     # 0x15980
cmpq $0x0, (%rax,%rcx,8)
jne 0x5588
movslq -0x4(%rbp), %rcx
leaq 0x10439(%rip), %rax     # 0x15980
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movw $0x0, 0xd2(%rax,%rcx,2)
movl $0x0, -0xc(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x5586
movl -0x8(%rbp), %edx
addl $0x1, %edx
leaq 0xff2d(%rip), %rdi      # 0x154a0
leaq 0xab03(%rip), %rsi      # 0x1007d
movb $0x0, %al
callq 0x2190
callq 0x4320
jmp 0x55f3
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
subl $0x1, %esi
callq 0x4430
movslq -0x4(%rbp), %rcx
leaq 0x1003f(%rip), %rax     # 0x155e0
movq (%rax,%rcx,8), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x4380
movsd %xmm0, -0x18(%rbp)
movsd 0x9ac2(%rip), %xmm0     # 0xf088
addsd -0x18(%rbp), %xmm0
callq 0x22c0
cvttsd2si %xmm0, %rax
cvtsi2sd %rax, %xmm0
movslq -0x4(%rbp), %rcx
leaq 0x1039b(%rip), %rax     # 0x15980
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movsd %xmm0, 0x60(%rax,%rcx,8)
jmp 0x55f5
movslq -0x4(%rbp), %rcx
leaq 0x10380(%rip), %rax     # 0x15980
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movsd 0x60(%rax,%rcx,8), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x9a90(%rip), %xmm1     # 0xf0b0
ucomisd %xmm1, %xmm0
jbe 0x566e
movsd 0x9a8a(%rip), %xmm0     # 0xf0b8
ucomisd -0x18(%rbp), %xmm0
jbe 0x566e
movslq -0x4(%rbp), %rcx
leaq 0x10340(%rip), %rax     # 0x15980
movq (%rax,%rcx,8), %rax
cmpb $0x0, 0xc4(%rax)
jne 0x566e
movl -0xc(%rbp), %eax
movw %ax, %dx
movslq -0x4(%rbp), %rcx
leaq 0x10322(%rip), %rax     # 0x15980
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movw %dx, 0xd2(%rax,%rcx,2)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: PhHits
int PhHits(From, NTo, Phnum, Units)
int From, NTo, Phnum, *Units;
{
  double F3, G2, G3;
  int Hits;

  Hits = 0;
  *Units = (long)floor(Ships[From]->Pstat[5] / 100.0 *
		       Ships[From]->PChrg[Phnum] + 0.5);
  G2 = Range(From, NTo);
  if (G2 > 1000)
    return Hits;
  F3 = Ships[From]->Pstat[4];
  G3 = Bearing(From, NTo);
  G3 = RMod(Objects[From]->Act_Crs + Ships[From]->Pdepl[Phnum] - G3);
  if (G3 <= F3 || 360 - G3 <= F3)
    Hits = (long)(*Units * sqrt(1 - G2 / 1000) * 45 / F3);
  return Hits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x102d9(%rip), %rax     # 0x15980
movq (%rax,%rcx,8), %rax
movswl 0xdc(%rax), %eax
cvtsi2sd %eax, %xmm0
movsd 0x99aa(%rip), %xmm1     # 0xf068
divsd %xmm1, %xmm0
movslq -0x8(%rbp), %rcx
leaq 0x102b3(%rip), %rax     # 0x15980
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsd 0x20(%rax,%rcx,8), %xmm1
mulsd %xmm1, %xmm0
movsd 0x99a1(%rip), %xmm1     # 0xf088
addsd %xmm1, %xmm0
callq 0x22c0
cvttsd2si %xmm0, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x4540
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x99a6(%rip), %xmm1     # 0xf0c0
ucomisd %xmm1, %xmm0
jbe 0x572b
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5818
movslq -0x8(%rbp), %rcx
leaq 0x1024a(%rip), %rax     # 0x15980
movq (%rax,%rcx,8), %rax
movswl 0xda(%rax), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x4430
movsd %xmm0, -0x30(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0xfe7b(%rip), %rax      # 0x155e0
movq (%rax,%rcx,8), %rax
movsd 0x10(%rax), %xmm0
movslq -0x8(%rbp), %rcx
leaq 0x10207(%rip), %rax     # 0x15980
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
addsd 0x60(%rax,%rcx,8), %xmm0
subsd -0x30(%rbp), %xmm0
callq 0x4380
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jae 0x57be
movsd 0x98ca(%rip), %xmm1     # 0xf078
subsd -0x30(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x5812
movq -0x18(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x28(%rbp), %xmm1
movsd 0x98e8(%rip), %xmm0     # 0xf0c0
divsd %xmm0, %xmm1
movsd 0x982c(%rip), %xmm0     # 0xf010
subsd %xmm1, %xmm0
callq 0x22e0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd 0x98c7(%rip), %xmm1     # 0xf0c8
mulsd %xmm1, %xmm0
divsd -0x20(%rbp), %xmm0
cvttsd2si %xmm0, %rax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: Launch
void Launch(I, J)
int I, *J;
{
  reg int K;
  reg Object *WITH;

  *J = 0;
  for (K = 1; K < AryMax; K++) {
    if (Objects[K] == NULL) {
      *J = K;
      break;
    }
  }
  if (*J == 0) {
    printf("Sorry, game has run out of array space (Too many Torps, etc)\n");
    exit(1);
  }
  Objects[K] = (Object *)Malloc(sizeof(Object));
  WITH = Objects[K];
  WITH->ObTyp = (-1);
  WITH->XPos = Objects[I]->XPos;
  WITH->YPos = Objects[I]->YPos;
  WITH->Act_Spd = 0.0;
  WITH->Des_Spd = 0.0;
  WITH->Act_Crs = 0.0;
  WITH->Des_Crs = 0.0;
  WITH->Fuel = 0.0;
  WITH->Trgt = 0;
  WITH->Tim_Del = 0.0;
  WITH->Prx_Del = 0.0;
  K = 0;
  for (I = AryMax-1; I > 0; I--) {
    if (Objects[I]) {
      K = I+1;
      break;
    }
  }
  ObjCount = K;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x1, -0x14(%rbp)
cmpl $0x64, -0x14(%rbp)
jge 0x5b80
movslq -0x14(%rbp), %rcx
leaq 0xfa7f(%rip), %rax      # 0x155e0
cmpq $0x0, (%rax,%rcx,8)
jne 0x5b73
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x5b80
jmp 0x5b75
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5b50
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x5ba1
leaq 0xa554(%rip), %rdi      # 0x100e4
movb $0x0, %al
callq 0x2040
movl $0x1, %edi
callq 0x20d0
movl $0x50, %edi
callq 0x20e0
movq %rax, %rdx
movslq -0x14(%rbp), %rcx
leaq 0xfa27(%rip), %rax      # 0x155e0
movq %rdx, (%rax,%rcx,8)
movslq -0x14(%rbp), %rcx
leaq 0xfa18(%rip), %rax      # 0x155e0
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movw $0xffff, 0x4a(%rax)     # imm = 0xFFFF
movslq -0x4(%rbp), %rcx
leaq 0xf9fb(%rip), %rax      # 0x155e0
movq (%rax,%rcx,8), %rax
movsd 0x38(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x38(%rax)
movslq -0x4(%rbp), %rcx
leaq 0xf9de(%rip), %rax      # 0x155e0
movq (%rax,%rcx,8), %rax
movsd 0x40(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x40(%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x20(%rbp), %rax
movw $0x0, 0x48(%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
movl $0x0, -0x14(%rbp)
movl $0x63, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x5caf
movslq -0x4(%rbp), %rcx
leaq 0xf950(%rip), %rax      # 0x155e0
cmpq $0x0, (%rax,%rcx,8)
je 0x5ca2
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5caf
jmp 0x5ca4
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x5c7f
movl -0x14(%rbp), %eax
movb %al, 0xf91a(%rip)       # 0x155d2
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hyc[P]trek73c/trekx.c
// Function: TrakTorp
void TrakTorp(I, J)
int I, J;
{
  int K;
  double D;

  K = Ships[I]->Tstat[J];
  if (K >= 100)
    K -= 100;
  if (K) {
    if (Ships[K-1] == NULL) {
      Ships[I]->Tstat[J] = 0;
      K = 0;
      if (!I) {
	sprintf(scrstr," Tube %d disengaging.", J+1);
	SEndln();
      }
    } else {
      D = Bearing(I, K-1) - Objects[I]->Act_Crs;
      D = RMod(D);
      Ships[I]->TDepl[J] = D;
    }
  }
  D = Ships[I]->TDepl[J];
  if (D > 135 && D < 225 && !Ships[I]->Dmge[(long)Engn])
    Ships[I]->Tstat[J] = K;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xfca7(%rip), %rax      # 0x15980
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movswl 0x110(%rax,%rcx,2), %eax
movl %eax, -0xc(%rbp)
cmpl $0x64, -0xc(%rbp)
jl 0x5cfb
movl -0xc(%rbp), %eax
subl $0x64, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x5dc1
movl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xfc6b(%rip), %rax      # 0x15980
cmpq $0x0, (%rax,%rcx,8)
jne 0x5d68
movslq -0x4(%rbp), %rcx
leaq 0xfc59(%rip), %rax      # 0x15980
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movw $0x0, 0x110(%rax,%rcx,2)
movl $0x0, -0xc(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x5d66
movl -0x8(%rbp), %edx
addl $0x1, %edx
leaq 0xf74d(%rip), %rdi      # 0x154a0
leaq 0xa3c8(%rip), %rsi      # 0x10122
movb $0x0, %al
callq 0x2190
callq 0x4320
jmp 0x5dbf
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
subl $0x1, %esi
callq 0x4430
movslq -0x4(%rbp), %rcx
leaq 0xf85f(%rip), %rax      # 0x155e0
movq (%rax,%rcx,8), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x4380
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movslq -0x4(%rbp), %rcx
leaq 0xfbd2(%rip), %rax      # 0x15980
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movsd %xmm0, 0xe0(%rax,%rcx,8)
jmp 0x5dc1
movslq -0x4(%rbp), %rcx
leaq 0xfbb4(%rip), %rax      # 0x15980
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movsd 0xe0(%rax,%rcx,8), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x92e9(%rip), %xmm1     # 0xf0d8
ucomisd %xmm1, %xmm0
jbe 0x5e3d
movsd 0x9293(%rip), %xmm0     # 0xf090
ucomisd -0x18(%rbp), %xmm0
jbe 0x5e3d
movslq -0x4(%rbp), %rcx
leaq 0xfb71(%rip), %rax      # 0x15980
movq (%rax,%rcx,8), %rax
cmpb $0x0, 0xc4(%rax)
jne 0x5e3d
movl -0xc(%rbp), %eax
movw %ax, %dx
movslq -0x4(%rbp), %rcx
leaq 0xfb53(%rip), %rax      # 0x15980
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movw %dx, 0x110(%rax,%rcx,2)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xf490(%rip), %rax      # 0x155e0
movq (%rax,%rcx,8), %rax
movsd 0x8f8c(%rip), %xmm0     # 0xf0e8
mulsd 0x20(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x4540
movsd %xmm0, -0x28(%rbp)
movsd 0x8e8a(%rip), %xmm0     # 0xf008
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x61d1
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm1
divsd -0x20(%rbp), %xmm1
movsd 0x8e5c(%rip), %xmm0     # 0xf010
subsd %xmm1, %xmm0
callq 0x22e0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xf06a(%rip), %rax      # 0x155e0
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movswl 0x4a(%rax), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
movq -0x20(%rbp), %rax
movsd 0x8a73(%rip), %xmm0     # 0xf010
addsd 0x30(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
movq -0x20(%rbp), %rax
cvttsd2si 0x30(%rax), %rax
movl %eax, -0x10(%rbp)
cmpl $0x2710, -0x10(%rbp)    # imm = 0x2710
jle 0x65ca
movl -0x4(%rbp), %edi
callq 0x61e0
jmp 0x6683
movb $0x0, -0x11(%rbp)
movq -0x20(%rbp), %rax
movsd 0x28(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x65e7
jp 0x65e7
jmp 0x6675
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movzbl 0xefda(%rip), %ecx      # 0x155d2
cmpl %ecx, %eax
jge 0x6673
movslq -0x8(%rbp), %rcx
leaq 0xefd9(%rip), %rax      # 0x155e0
cmpq $0x0, (%rax,%rcx,8)
je 0x6663
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
je 0x6663
movslq -0x8(%rbp), %rcx
leaq 0xefbf(%rip), %rax      # 0x155e0
movq (%rax,%rcx,8), %rax
movswl 0x4a(%rax), %eax
cmpl $0x14, %eax
jge 0x6661
movq -0x20(%rbp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x4540
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x6661
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x6661
movb $0x1, -0x11(%rbp)
jmp 0x6663
jmp 0x6665
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x65ee
jmp 0x6675
cmpb $0x0, -0x11(%rbp)
je 0x6683
movl -0x4(%rbp), %edi
callq 0x61e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xea6a(%rip), %rax      # 0x155e0
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movaps 0x8842(%rip), %xmm1     # 0xf3d0
pand %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x8554(%rip), %xmm1     # 0xf0f8
ucomisd %xmm1, %xmm0
jbe 0x6bb7
movsd 0x8546(%rip), %xmm0     # 0xf0f8
movsd %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x4350
cvtsi2sd %eax, %xmm0
mulsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq -0x8(%rbp), %rsi
callq 0x5b30
movb $0x0, -0x9(%rbp)
movsd 0x7755(%rip), %xmm1     # 0xf008
divsd 0xd8e5(%rip), %xmm1     # 0x151a0
movsd 0x77e5(%rip), %xmm0     # 0xf0a8
subsd %xmm1, %xmm0
movslq -0x8(%rbp), %rcx
leaq 0xdd0e(%rip), %rax      # 0x155e0
movq (%rax,%rcx,8), %rax
movsd %xmm0, 0x30(%rax)
movslq -0x4(%rbp), %rcx
leaq 0xdcfa(%rip), %rax      # 0x155e0
movq (%rax,%rcx,8), %rax
movsd 0x20(%rax), %xmm0
movslq -0x8(%rbp), %rcx
leaq 0xdce6(%rip), %rax      # 0x155e0
movq (%rax,%rcx,8), %rax
movsd %xmm0, 0x20(%rax)
movslq -0x4(%rbp), %rcx
leaq 0xdcd2(%rip), %rax      # 0x155e0
movq (%rax,%rcx,8), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
movl -0x4(%rbp), %eax
addl $0xa, %eax
movw %ax, %cx
movslq -0x8(%rbp), %rdx
leaq 0xdcb2(%rip), %rax      # 0x155e0
movq (%rax,%rdx,8), %rax
movw %cx, 0x4a(%rax)
movslq -0x4(%rbp), %rcx
leaq 0xe03f(%rip), %rax      # 0x15980
movq (%rax,%rcx,8), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movslq -0x4(%rbp), %rcx
leaq 0xe029(%rip), %rax      # 0x15980
movq (%rax,%rcx,8), %rax
movb $0x0, 0x18(%rax)
movslq -0x4(%rbp), %rcx
leaq 0xe016(%rip), %rax      # 0x15980
movq (%rax,%rcx,8), %rax
movsd 0x7692(%rip), %xmm0     # 0xf008
movsd %xmm0, 0x8(%rax)
movslq -0x4(%rbp), %rcx
leaq 0xdffa(%rip), %rax      # 0x15980
movq (%rax,%rcx,8), %rax
movb $0x1, 0xc4(%rax)
movslq -0x4(%rbp), %rcx
leaq 0xdfe4(%rip), %rax      # 0x15980
movq (%rax,%rcx,8), %rax
movb $0x1, 0xc2(%rax)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movzbl 0xd7f8(%rip), %ecx      # 0x151b0
cmpl %ecx, %eax
jge 0x79ef
movslq -0x4(%rbp), %rcx
leaq 0xdfb9(%rip), %rax      # 0x15980
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movsd 0x20(%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x79e2
movb $0x1, -0x9(%rbp)
jmp 0x79e4
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x79ae
cmpb $0x0, -0x9(%rbp)
je 0x7a2e
movl $0x0, -0x8(%rbp)
cmpl $0x3, -0x8(%rbp)
jg 0x7a2c
movslq -0x4(%rbp), %rcx
leaq 0xdf73(%rip), %rax      # 0x15980
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, 0xa0(%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x79fc
jmp 0x7a2e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xcd99(%rip), %rdi      # 0x159e8
leaq 0x7abc(%rip), %rsi      # 0x10712
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
movq 0xcd81(%rip), %rdi      # 0x159e8
callq 0x2180
movq 0xcd75(%rip), %rdi      # 0x159e8
callq 0x22f0
movb %al, -0x2(%rbp)
movq 0xcd66(%rip), %rdi      # 0x159e8
leaq 0x70aa(%rip), %rsi      # 0xfd33
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
movq 0xcd4e(%rip), %rdi      # 0x159e8
callq 0x2210
movq 0xcd42(%rip), %rdi      # 0x159e8
callq 0x2180
movsbl -0x2(%rbp), %edi
callq 0x20b0
cmpl $0x59, %eax
jne 0x8cbf
movb $0x1, -0x1(%rbp)
jmp 0x8cc3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movq 0xcbb3(%rip), %rdi      # 0x159e8
leaq 0x79aa(%rip), %rsi      # 0x107e6
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
movq 0xcb9b(%rip), %rdi      # 0x159e8
leaq 0xc64c(%rip), %rsi      # 0x154a0
movl $0x1, %edx
callq 0x24a0
leaq 0xc63b(%rip), %rdi      # 0x154a0
leaq 0x8678(%rip), %rsi      # 0x114e4
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x20a0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, -0x12(%rbp)
movswl -0x12(%rbp), %eax
cmpl $0x0, %eax
jle 0x8e9e
movb $0x0, -0x2(%rbp)
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x8f24
movsd -0x10(%rbp), %xmm0
movaps 0x6526(%rip), %xmm1     # 0xf3d0
pand %xmm1, %xmm0
movsd 0x6292(%rip), %xmm1     # 0xf148
ucomisd %xmm1, %xmm0
jbe 0x8ec7
movb $0x0, -0x2(%rbp)
callq 0x8d30
jmp 0x8f1e
movsd -0x10(%rbp), %xmm0
movaps 0x64fd(%rip), %xmm1     # 0xf3d0
pand %xmm1, %xmm0
movsd 0x6131(%rip), %xmm1     # 0xf010
ucomisd %xmm1, %xmm0
jb 0x8f03
movq 0xca94(%rip), %rax      # 0x15980
movsbl 0xc3(%rax), %eax
cmpl $0x0, %eax
je 0x8f03
movb $0x0, -0x2(%rbp)
callq 0x8d60
jmp 0x8f1c
cmpb $0x0, -0x2(%rbp)
je 0x8f1a
movsd -0x10(%rbp), %xmm0
movq 0xc6cb(%rip), %rax      # 0x155e0
movsd %xmm0, 0x8(%rax)
jmp 0x8f1c
jmp 0x8f1e
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x9, -0xc(%rbp)
jg 0x8f63
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8f43
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movq 0xca77(%rip), %rdi      # 0x159e8
leaq 0xc528(%rip), %rsi      # 0x154a0
movl $0x1, %edx
callq 0x24a0
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0xc50c(%rip), %rax      # 0x154a0
cmpb $0x0, (%rax,%rcx)
je 0x8ff5
callq 0x2160
movq (%rax), %rax
movslq -0xc(%rbp), %rdx
leaq 0xc4f3(%rip), %rcx      # 0x154a0
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x8fe8
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0xc4ca(%rip), %rax      # 0x154a0
movsbl (%rax,%rcx), %edx
subl $0x30, %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x8fea
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8f89
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x1, -0xd(%rbp)
movq 0xb245(%rip), %rdi      # 0x159e8
leaq 0x6351(%rip), %rsi      # 0x10afb
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
movq 0xb22d(%rip), %rdi      # 0x159e8
leaq 0xacde(%rip), %rsi      # 0x154a0
movl $0x1, %edx
callq 0x24a0
leaq 0xaccd(%rip), %rdi      # 0x154a0
leaq 0x6d0a(%rip), %rsi      # 0x114e4
leaq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x20a0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0xa7ff
movb $0x0, -0xd(%rbp)
jmp 0xa810
movsd -0x8(%rbp), %xmm0
movq 0xadd5(%rip), %rax      # 0x155e0
movsd %xmm0, 0x18(%rax)
movsbl -0xd(%rbp), %edi
callq 0x8e20
movb %al, -0xd(%rbp)
cmpb $0x0, -0xd(%rbp)
je 0xa850
movq 0xadb7(%rip), %rax      # 0x155e0
movw $0x0, 0x48(%rax)
movq 0xad92(%rip), %rdx      # 0x155c8
leaq 0xac63(%rip), %rdi      # 0x154a0
leaq 0x62dc(%rip), %rsi      # 0x10b20
movb $0x0, %al
callq 0x2190
callq 0x4320
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xb111(%rip), %rax      # 0x15980
cmpb $0x0, 0xc0(%rax)
je 0xa882
callq 0x8df0
jmp 0xa929
movb $0x0, -0xd(%rbp)
movq 0xb15b(%rip), %rdi      # 0x159e8
leaq 0x629b(%rip), %rsi      # 0x10b2f
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
leaq -0xd(%rbp), %rdi
leaq -0xe(%rbp), %rsi
callq 0x93b0
movl %eax, -0xc(%rbp)
movsbl -0xe(%rbp), %eax
cmpl $0x0, %eax
je 0xa8c0
movsbl -0xd(%rbp), %eax
cmpl $0x0, %eax
jne 0xa8c7
callq 0x8d30
jmp 0xa929
movsbl -0xd(%rbp), %edi
callq 0x8e20
movb %al, -0xd(%rbp)
cmpb $0x0, -0xd(%rbp)
jne 0xa8db
jmp 0xa929
movl -0xc(%rbp), %eax
addl $0x1, %eax
movw %ax, %cx
movq 0xacf5(%rip), %rax      # 0x155e0
movw %cx, 0x48(%rax)
movl -0xc(%rbp), %esi
xorl %edi, %edi
callq 0x4430
movsd %xmm0, -0x8(%rbp)
callq 0x42a0
movq 0xacbe(%rip), %rdx      # 0x155c8
movsd -0x8(%rbp), %xmm0
leaq 0xab8a(%rip), %rdi      # 0x154a0
leaq 0x6229(%rip), %rsi      # 0x10b46
movb $0x1, %al
callq 0x2190
callq 0x4320
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq 0xa82d(%rip), %rdx      # 0x155b8
movq 0xabde(%rip), %rcx      # 0x15970
leaq 0xa707(%rip), %rdi      # 0x154a0
leaq 0x6182(%rip), %rsi      # 0x10f22
movb $0x0, %al
callq 0x2190
callq 0x4320
movq 0xa815(%rip), %rdx      # 0x155c8
leaq 0xa6e6(%rip), %rdi      # 0x154a0
leaq 0x6191(%rip), %rsi      # 0x10f52
movb $0x0, %al
callq 0x2190
callq 0x4320
movq 0xa7e4(%rip), %rdx      # 0x155b8
movq 0xa7dd(%rip), %rcx      # 0x155b8
movq 0xab3e(%rip), %r8       # 0x15920
leaq 0xa6b7(%rip), %rdi      # 0x154a0
leaq 0x6172(%rip), %rsi      # 0x10f62
movb $0x0, %al
callq 0x2190
callq 0x4320
movq 0xabe5(%rip), %rdi      # 0x159e8
leaq 0x618c(%rip), %rsi      # 0x10f96
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2200
callq 0x42a0
movzbl 0xa7b7(%rip), %eax      # 0x155d7
cmpl $0x5, %eax
jne 0xae4f
movq 0xab4c(%rip), %rdx      # 0x15978
movq 0xa785(%rip), %rcx      # 0x155b8
leaq 0xa666(%rip), %rdi      # 0x154a0
leaq 0x6192(%rip), %rsi      # 0x10fd3
movb $0x0, %al
callq 0x2190
callq 0x4320
jmp 0xae82
cmpb $0x0, 0xa780(%rip)      # 0x155d6
je 0xae7b
movq 0xa769(%rip), %rdx      # 0x155c8
leaq 0xa63a(%rip), %rdi      # 0x154a0
leaq 0x61a3(%rip), %rsi      # 0x11010
movb $0x0, %al
callq 0x2190
callq 0x4320
jmp 0xae82
movb $0x1, 0xa754(%rip)      # 0x155d6
popq %rbp
retq
nopw %cs:(%rax,%rax)