LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/local.c
// Function: localFileSize
static off_t localFileSize(
  void *filep
)
{
  FILE *file = filep;
  struct stat stat;

  if (!SWISSET('a'))
    if (fstat(fileno(file), &stat) == 0)
      return stat.st_size;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xd08a(%rip), %rax      # 0x1f1f8
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x121a0
movq -0x18(%rbp), %rdi
callq 0x31f0
movl %eax, %edi
leaq -0xa8(%rbp), %rsi
callq 0x32d0
cmpl $0x0, %eax
jne 0x1219e
movq -0x78(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x121a8
jmp 0x121a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/local.c
// Function: localReadFile
static size_t localReadFile(
  void *file,
  void *buf,
  size_t buflen
)
{
  if (SWISSET('a')) {
    char *bufr = buf;
    int readlen;

    if (fgets(bufr, buflen - 1, file) == NULL)
      return 0;

    /*
     * Translate terminating \n into \r\n unless it is already there
     */
    if ((readlen = strlen(bufr)) != 0) {
      if (bufr[readlen - 1] == '\n') {
        if ((readlen == 1) || (bufr[readlen - 2] != '\r'))
          strcpy(&bufr[readlen - 1], "\r\n");
      }
    }
    return strlen(bufr);
  }
  return fread(buf, sizeof(char), buflen, file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0xcffd(%rip), %rax      # 0x1f1f8
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x122ac
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
subq $0x1, %rax
movl %eax, %esi
movq -0x10(%rbp), %rdx
callq 0x31a0
cmpq $0x0, %rax
jne 0x1223b
movq $0x0, -0x8(%rbp)
jmp 0x122c6
movq -0x28(%rbp), %rdi
callq 0x3130
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1229d
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x1229b
cmpl $0x1, -0x2c(%rbp)
je 0x1227e
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
je 0x12299
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
subl $0x1, %eax
cltq
addq %rax, %rdi
leaq 0x84f7(%rip), %rsi      # 0x1a78b
callq 0x30b0
jmp 0x1229b
jmp 0x1229d
movq -0x28(%rbp), %rdi
callq 0x3130
movq %rax, -0x8(%rbp)
jmp 0x122c6
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x30f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/local.c
// Function: localWriteFile
static size_t localWriteFile(
  void *file,
  void *buf,
  size_t buflen
)
{
  if (SWISSET('a')) {
    char *bufw = buf;

    if (buflen >= 2)
      if ((bufw[buflen - 2] == '\r') && (bufw[buflen - 1] == '\n')) {
        bufw[buflen - 2] = '\n';
        buflen--;
      }
  }
  return fwrite(buf, sizeof(char), buflen, file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0xcf0d(%rip), %rax      # 0x1f1f8
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1234e
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x2, -0x18(%rbp)
jb 0x1234c
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x2, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0x1234a
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x1234a
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x2, %rcx
movb $0xa, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1234c
jmp 0x1234e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x32b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/os8.c
// Function: rk05ReadBlock
static int rk05ReadBlock(
  struct mountedFS *mount,
  uint8_t unit,
  unsigned int block,
  void *buf
)
{
  int status = 0;
  unsigned int base = unit == 0 ? 0 : OS8_RK05FS_BLKS;

  if (block >= OS8_RK05FS_BLKS) {
    ERROR("Attempt to read block (%u) outside file system \"%s%o:\"\n",
          block, mount->name, unit);
    return 0;
  }

  status = FSioReadBlock(mount, base + block, buf);

  if (status == 0)
    ERROR("I/O error on \"%s%o:\"\n", mount->name, unit);

  return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movzbl -0x11(%rbp), %edx
movl $0xcb0, %eax            # imm = 0xCB0
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x28(%rbp)
cmpl $0xcb0, -0x18(%rbp)     # imm = 0xCB0
jb 0x124cc
movq 0xbba4(%rip), %rax      # 0x1dff8
movq (%rax), %rdi
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movzbl -0x11(%rbp), %r8d
leaq 0x7b54(%rip), %rsi      # 0x19fc2
movb $0x0, %al
callq 0x31c0
leaq 0xcd6c(%rip), %rax      # 0x1f1e8
cmpq $0x0, (%rax)
je 0x124c0
leaq 0xcd5f(%rip), %rax      # 0x1f1e8
movq (%rax), %rax
movq 0xbb2d(%rip), %rcx      # 0x1dfc0
cmpq (%rcx), %rax
je 0x124c0
leaq 0xcd49(%rip), %rax      # 0x1f1e8
movq (%rax), %rdi
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movzbl -0x11(%rbp), %r8d
leaq 0x7b09(%rip), %rsi      # 0x19fc2
movb $0x0, %al
callq 0x31c0
movl $0x0, -0x4(%rbp)
jmp 0x1255b
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
addl -0x18(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x5520
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x12555
movq 0xbb09(%rip), %rax      # 0x1dff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movzbl -0x11(%rbp), %ecx
leaq 0x7b1f(%rip), %rsi      # 0x1a024
movb $0x0, %al
callq 0x31c0
leaq 0xccd5(%rip), %rax      # 0x1f1e8
cmpq $0x0, (%rax)
je 0x12553
leaq 0xccc8(%rip), %rax      # 0x1f1e8
movq (%rax), %rax
movq 0xba96(%rip), %rcx      # 0x1dfc0
cmpq (%rcx), %rax
je 0x12553
leaq 0xccb2(%rip), %rax      # 0x1f1e8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movzbl -0x11(%rbp), %ecx
leaq 0x7ad8(%rip), %rsi      # 0x1a024
movb $0x0, %al
callq 0x31c0
jmp 0x12555
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/os8.c
// Function: rk05WriteBlock
static int rk05WriteBlock(
  struct mountedFS *mount,
  uint8_t unit,
  unsigned int block,
  void *buf
)
{
  int status = 0;
  unsigned int base = unit == 0 ? 0 : OS8_RK05FS_BLKS;

  if (block >= OS8_RK05FS_BLKS) {
    ERROR("Attempt to write block (%u) outside file system \"%s%o:\"\n",
          block, mount->name, unit);
    return 0;
  }

  status = FSioWriteBlock(mount, base + block, buf);

  if (status == 0)
    ERROR("I/O error on \"%s%o:\"\n", mount->name, unit);

  return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movzbl -0x11(%rbp), %edx
movl $0xcb0, %eax            # imm = 0xCB0
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x28(%rbp)
cmpl $0xcb0, -0x18(%rbp)     # imm = 0xCB0
jb 0x1262c
movq 0xba44(%rip), %rax      # 0x1dff8
movq (%rax), %rdi
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movzbl -0x11(%rbp), %r8d
leaq 0x7a84(%rip), %rsi      # 0x1a052
movb $0x0, %al
callq 0x31c0
leaq 0xcc0c(%rip), %rax      # 0x1f1e8
cmpq $0x0, (%rax)
je 0x12620
leaq 0xcbff(%rip), %rax      # 0x1f1e8
movq (%rax), %rax
movq 0xb9cd(%rip), %rcx      # 0x1dfc0
cmpq (%rcx), %rax
je 0x12620
leaq 0xcbe9(%rip), %rax      # 0x1f1e8
movq (%rax), %rdi
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movzbl -0x11(%rbp), %r8d
leaq 0x7a39(%rip), %rsi      # 0x1a052
movb $0x0, %al
callq 0x31c0
movl $0x0, -0x4(%rbp)
jmp 0x126bb
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
addl -0x18(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x55a0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x126b5
movq 0xb9a9(%rip), %rax      # 0x1dff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movzbl -0x11(%rbp), %ecx
leaq 0x79bf(%rip), %rsi      # 0x1a024
movb $0x0, %al
callq 0x31c0
leaq 0xcb75(%rip), %rax      # 0x1f1e8
cmpq $0x0, (%rax)
je 0x126b3
leaq 0xcb68(%rip), %rax      # 0x1f1e8
movq (%rax), %rax
movq 0xb936(%rip), %rcx      # 0x1dfc0
cmpq (%rcx), %rax
je 0x126b3
leaq 0xcb52(%rip), %rax      # 0x1f1e8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movzbl -0x11(%rbp), %ecx
leaq 0x7978(%rip), %rsi      # 0x1a024
movb $0x0, %al
callq 0x31c0
jmp 0x126b5
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/os8.c
// Function: os8ReadBlock
int os8ReadBlock(
  struct mountedFS *mount,
  uint8_t unit,
  unsigned int block,
  void *buf
)
{
  struct OS8data *data = &mount->os8data;
  void *buffer = buf == NULL ? data->buf : buf;

  if ((unit >= data->device->filesys) || ((data->valid & (1 << unit)) == 0)) {
    ERROR("Invalid device \"%s%o:\"\n", mount->name, unit);
    return 0;
  }

#ifdef DEBUG
  if ((mount->flags & FS_DEBUG) != 0)
    fprintf(DEBUGout, ">> %s%o: (os8) Reading logical block %u\n",
            mount->name, unit, block);
#endif

  return (*data->device->readBlock)(mount, unit, block, buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1332a
movq -0x28(%rbp), %rax
addq $0x14, %rax
movq %rax, -0x38(%rbp)
jmp 0x13332
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movzbl -0x11(%rbp), %eax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
movzbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0x1336a
movq -0x28(%rbp), %rax
movzbl 0x11(%rax), %eax
movzbl -0x11(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x133de
movq 0xac87(%rip), %rax      # 0x1dff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movzbl -0x11(%rbp), %ecx
leaq 0x6cb3(%rip), %rsi      # 0x1a03a
movb $0x0, %al
callq 0x31c0
leaq 0xbe53(%rip), %rax      # 0x1f1e8
cmpq $0x0, (%rax)
je 0x133d5
leaq 0xbe46(%rip), %rax      # 0x1f1e8
movq (%rax), %rax
movq 0xac14(%rip), %rcx      # 0x1dfc0
cmpq (%rcx), %rax
je 0x133d5
leaq 0xbe30(%rip), %rax      # 0x1f1e8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movzbl -0x11(%rbp), %ecx
leaq 0x6c6c(%rip), %rsi      # 0x1a03a
movb $0x0, %al
callq 0x31c0
movl $0x0, -0x4(%rbp)
jmp 0x1343a
movq -0x10(%rbp), %rax
movzwl 0x30(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x13416
leaq 0xbdf3(%rip), %rax      # 0x1f1e8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movzbl -0x11(%rbp), %ecx
movl -0x18(%rbp), %r8d
leaq 0x73c1(%rip), %rsi      # 0x1a7d0
movb $0x0, %al
callq 0x31c0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %sil
movl -0x18(%rbp), %edx
movq -0x30(%rbp), %rcx
movzbl %sil, %esi
callq *%rax
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/simh[P]simtools/converters/fsio/os8.c
// Function: os8WriteBlock
int os8WriteBlock(
  struct mountedFS *mount,
  uint8_t unit,
  unsigned int block,
  void *buf
)
{
  struct OS8data *data = &mount->os8data;
  void *buffer = buf == NULL ? data->buf : buf;

  if ((unit >= data->device->filesys) || ((data->valid & (1 << unit)) == 0)) {
    ERROR("Invalid device \"%s%o:\"\n", mount->name, unit);
    return 0;
  }

#ifdef DEBUG
  if ((mount->flags & FS_DEBUG) != 0)
    fprintf(DEBUGout, ">> %s%o: (os8) Writing logical block %u\n",
            mount->name, unit, block);
#endif

  return (*data->device->writeBlock)(mount, unit, block, buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1348a
movq -0x28(%rbp), %rax
addq $0x14, %rax
movq %rax, -0x38(%rbp)
jmp 0x13492
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movzbl -0x11(%rbp), %eax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
movzbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0x134ca
movq -0x28(%rbp), %rax
movzbl 0x11(%rax), %eax
movzbl -0x11(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x1353e
movq 0xab27(%rip), %rax      # 0x1dff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movzbl -0x11(%rbp), %ecx
leaq 0x6b53(%rip), %rsi      # 0x1a03a
movb $0x0, %al
callq 0x31c0
leaq 0xbcf3(%rip), %rax      # 0x1f1e8
cmpq $0x0, (%rax)
je 0x13535
leaq 0xbce6(%rip), %rax      # 0x1f1e8
movq (%rax), %rax
movq 0xaab4(%rip), %rcx      # 0x1dfc0
cmpq (%rcx), %rax
je 0x13535
leaq 0xbcd0(%rip), %rax      # 0x1f1e8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movzbl -0x11(%rbp), %ecx
leaq 0x6b0c(%rip), %rsi      # 0x1a03a
movb $0x0, %al
callq 0x31c0
movl $0x0, -0x4(%rbp)
jmp 0x1359a
movq -0x10(%rbp), %rax
movzwl 0x30(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x13576
leaq 0xbc93(%rip), %rax      # 0x1f1e8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movzbl -0x11(%rbp), %ecx
movl -0x18(%rbp), %r8d
leaq 0x728a(%rip), %rsi      # 0x1a7f9
movb $0x0, %al
callq 0x31c0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %sil
movl -0x18(%rbp), %edx
movq -0x30(%rbp), %rcx
movzbl %sil, %esi
callq *%rax
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/simh[P]simtools/converters/fsio/os8.c
// Function: toSixbit
static void toSixbit(
  char ch,
  uint16_t *ptr,
  int which
)
{
  unsigned long i;

  for (i = 0; i < sizeof(sixbit); i++)
    if (ch == sixbit[i]) {
      if (which == 0)
        *ptr = (i << 6) | (*ptr & 0x3F);
      else *ptr = (*ptr & 0xFC0) | i;
      return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x40, -0x20(%rbp)
jae 0x1390f
movsbl -0x1(%rbp), %eax
movq -0x20(%rbp), %rdx
leaq 0xb851(%rip), %rcx      # 0x1f100
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x138ff
cmpl $0x0, -0x14(%rbp)
jne 0x138e1
movq -0x20(%rbp), %rax
shlq $0x6, %rax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
andl $0x3f, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
jmp 0x138fd
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
andl $0xfc0, %eax            # imm = 0xFC0
cltq
orq -0x20(%rbp), %rax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
jmp 0x1390f
jmp 0x13901
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x13899
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/os8.c
// Function: os8CheckDirectory
static int os8CheckDirectory(
  struct mountedFS *mount
)
{
  struct OS8data *data = &mount->os8data;
  uint16_t i, entrysz, entries, off = OS8_DH_SIZE;

  entrysz = OS8_DI_SIZE + (-os8SXT(le16toh(data->buf[OS8_DH_EXTRA])));
  entries = os8Neg(le16toh(data->buf[OS8_DH_ENTRIES]));

  for (i = 0; i < entries; i++)
    if (os8Word(le16toh(data->buf[off + OS8_DI_FNAME1])) != 0)
      off += entrysz;
    else off += OS8_ED_SIZE;

  return (off + entrysz) < OS8_BLOCKSIZE ? 1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x10(%rbp)
movw $0x5, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x1c(%rax), %edi
callq 0x14890
movzwl %ax, %edi
callq 0x148b0
movzwl %ax, %ecx
xorl %eax, %eax
subl %ecx, %eax
addl $0x5, %eax
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x14(%rax), %edi
callq 0x14890
movzwl %ax, %edi
callq 0x14860
movw %ax, -0x16(%rbp)
movw $0x0, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
movzwl -0x16(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1416f
movq -0x10(%rbp), %rax
movzwl -0x18(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movzwl 0x14(%rax,%rcx,2), %edi
callq 0x14890
movzwl %ax, %edi
callq 0x14f90
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x14154
movzwl -0x14(%rbp), %ecx
movzwl -0x18(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x18(%rbp)
jmp 0x1415f
movzwl -0x18(%rbp), %eax
addl $0x2, %eax
movw %ax, -0x18(%rbp)
jmp 0x14161
movw -0x12(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x12(%rbp)
jmp 0x14110
movzwl -0x18(%rbp), %edx
movzwl -0x14(%rbp), %eax
addl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x100, %edx            # imm = 0x100
cmovll %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/os8.c
// Function: os8UnitValid
static int os8UnitValid(
  struct OS8data *data,
  uint8_t unit
)
{
  struct OS8device *device;

  if ((device = data->device) != NULL) {
    if (unit < device->filesys)
      return (data->valid & (1 << unit)) != 0 ? 1 : 0;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x14f79
movzbl -0x11(%rbp), %eax
movq -0x20(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0x14f77
movq -0x10(%rbp), %rax
movzbl 0x11(%rax), %edx
movzbl -0x11(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
andl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x14f80
jmp 0x14f79
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/os8.c
// Function: os8SlideUp
static void os8SlideUp(
  struct mountedFS *mount,
  uint16_t dst,
  uint16_t src,
  uint16_t entrysz,
  uint16_t count
)
{
  struct OS8data *data = &mount->os8data;
  uint16_t i, j, len;

  if (count != 0) {
    for (i = 0; i < count; i++) {
      len = os8Word(le16toh(data->buf[src + OS8_DI_FNAME1])) ? entrysz : OS8_ED_SIZE;

      for (j = 0; j < len; j++)
        data->buf[dst++] = data->buf[src++];
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %r8w, %ax
movq %rdi, -0x8(%rbp)
movw %si, -0xa(%rbp)
movw %dx, -0xc(%rbp)
movw %cx, -0xe(%rbp)
movw %ax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x18(%rbp)
movzwl -0x10(%rbp), %eax
cmpl $0x0, %eax
je 0x1524c
movw $0x0, -0x1a(%rbp)
movzwl -0x1a(%rbp), %eax
movzwl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1524a
movq -0x18(%rbp), %rax
movzwl -0xc(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movzwl 0x14(%rax,%rcx,2), %edi
callq 0x14890
movzwl %ax, %edi
callq 0x14f90
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x151d0
movzwl -0xe(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x151da
movl $0x2, %eax
movl %eax, -0x24(%rbp)
jmp 0x151da
movl -0x24(%rbp), %eax
movw %ax, -0x1e(%rbp)
movw $0x0, -0x1c(%rbp)
movzwl -0x1c(%rbp), %eax
movzwl -0x1e(%rbp), %ecx
cmpl %ecx, %eax
jge 0x15237
movq -0x18(%rbp), %rax
movw -0xc(%rbp), %cx
movw %cx, %dx
addw $0x1, %dx
movw %dx, -0xc(%rbp)
movzwl %cx, %ecx
movw 0x14(%rax,%rcx,2), %dx
movq -0x18(%rbp), %rax
movw -0xa(%rbp), %cx
movw %cx, %si
addw $0x1, %si
movw %si, -0xa(%rbp)
movzwl %cx, %ecx
movw %dx, 0x14(%rax,%rcx,2)
movw -0x1c(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x1c(%rbp)
jmp 0x151e7
jmp 0x15239
movw -0x1a(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x1a(%rbp)
jmp 0x1518f
jmp 0x1524c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/os8.c
// Function: os8Size
static size_t os8Size(void)
{
  if (SWISSET('t')) {
    struct OS8device *dev = OS8Devices;
    
    while (dev->name != NULL) {
      if (strcmp(SWGETVAL('t'), dev->name) == 0)
        return dev->diskSize;
     
      dev++;
    }
  }
  return OS8Devices[0].diskSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x9399(%rip), %rax      # 0x1f1f8
movl (%rax), %eax
andl $0x80000, %eax          # imm = 0x80000
cmpl $0x0, %eax
je 0x15ebd
leaq 0x8ffe(%rip), %rax      # 0x1ee70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x15ebb
leaq 0x9379(%rip), %rax      # 0x1f200
movq 0x98(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x31b0
cmpl $0x0, %eax
jne 0x15ead
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x15ec8
movq -0x10(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x10(%rbp)
jmp 0x15e76
jmp 0x15ebd
movq 0x8fbc(%rip), %rax      # 0x1ee80
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/os8.c
// Function: os8Info
static void os8Info(
  struct mountedFS *mount,
  uint8_t unit,
  uint8_t present
)
{
  struct OS8data *data = &mount->os8data;
  struct OS8device *device = data->device;

  if (present) {
    if (os8UnitValid(data, unit))
      info(mount, unit);
  } else {
    uint16_t i;

    /*
     * Display information about all valid units
     */
    for (i = 0; i < device->filesys; i++)
      if (os8UnitValid(data, i))
        info(mount, i);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpb $0x0, -0xa(%rbp)
je 0x16386
movq -0x18(%rbp), %rdi
movzbl -0x9(%rbp), %esi
callq 0x14f20
cmpl $0x0, %eax
je 0x16384
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %esi
callq 0x16e60
jmp 0x163d3
movw $0x0, -0x22(%rbp)
movzwl -0x22(%rbp), %eax
movq -0x20(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0x163d1
movq -0x18(%rbp), %rdi
movw -0x22(%rbp), %ax
movzbl %al, %esi
callq 0x14f20
cmpl $0x0, %eax
je 0x163c1
movq -0x8(%rbp), %rdi
movw -0x22(%rbp), %ax
movzbl %al, %esi
callq 0x16e60
jmp 0x163c3
movw -0x22(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x22(%rbp)
jmp 0x1638c
jmp 0x163d3
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/os8.c
// Function: os8OpenFileR
static void *os8OpenFileR(
  struct mountedFS *mount,
  uint8_t unit,
  char *fname
)
{
  struct os8OpenFile *file;
  struct os8FileSpec spec;

  if (os8ParseFilespec(fname, &spec, OS8_M_NONE) == 0) {
    fprintf(stderr, "Failed to parse filename \"%s\"\n", fname);
    return NULL;
  }

  if ((file = malloc(sizeof(struct os8OpenFile))) != NULL) {
    memset(file, 0, sizeof(struct os8OpenFile));

    if (os8LookupFile(mount, unit, &spec, file) != 0) {
      /*
       * Allocate local buffer space for the file.
       */
      if ((file->buffer = malloc(mount->blocksz)) == NULL) {
        free(file);
        return NULL;
      }
      file->mode = M_RD;
    } else {
      free(file);
      return NULL;
    }
  }
  return file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x3a(%rbp), %rsi
xorl %edx, %edx
callq 0x135b0
cmpl $0x0, %eax
jne 0x167a3
movq 0x7877(%rip), %rax      # 0x1dff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x376d(%rip), %rsi      # 0x19efc
movb $0x0, %al
callq 0x31c0
movq $0x0, -0x8(%rbp)
jmp 0x1683b
movl $0x50, %edi
callq 0x3200
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x16833
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x3170
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movq -0x28(%rbp), %rcx
leaq -0x3a(%rbp), %rdx
movzbl %al, %esi
callq 0x14ad0
cmpl $0x0, %eax
je 0x1681e
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3200
movq -0x28(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
jne 0x16811
movq -0x28(%rbp), %rdi
callq 0x3040
movq $0x0, -0x8(%rbp)
jmp 0x1683b
movq -0x28(%rbp), %rax
movl $0x0, 0x18(%rax)
jmp 0x16831
movq -0x28(%rbp), %rdi
callq 0x3040
movq $0x0, -0x8(%rbp)
jmp 0x1683b
jmp 0x16833
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/os8.c
// Function: os8CloseFile
static void os8CloseFile(
  void *filep
)
{
  struct os8OpenFile *file = filep;

  if (file->mode == M_WR) {
    if (file->current != 0)
      /*
       * Flush the current buffer.
       */
      os8WriteBlock(file->mount, file->unit, file->current++, file->buffer);

    os8UpdateFile(file->mount, file->unit, file);
  }

  if (file->buffer != NULL)
    free(file->buffer);
  free(file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jne 0x168fb
movq -0x10(%rbp), %rax
movzwl 0x3a(%rax), %eax
cmpl $0x0, %eax
je 0x168e0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movb 0x28(%rax), %al
movq -0x10(%rbp), %rdx
movw 0x3a(%rdx), %cx
movw %cx, %si
addw $0x1, %si
movw %si, 0x3a(%rdx)
movzwl %cx, %edx
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movzbl %al, %esi
callq 0x13450
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movb 0x28(%rax), %al
movq -0x10(%rbp), %rdx
movzbl %al, %esi
callq 0x14fb0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x16913
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3040
movq -0x10(%rbp), %rdi
callq 0x3040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/os8.c
// Function: os8DeleteFile
static void os8DeleteFile(
  void *filep,
  char *UNUSED(fname)
)
{
  struct os8OpenFile *file = filep;
  struct mountedFS *mount = file->mount;
  struct OS8data *data = &mount->os8data;

  if (os8ReadBlock(mount, file->unit, file->segment, NULL) == 0)
    return;

  data->buf[file->offset + OS8_DI_FNAME1] = 0;
  data->buf[file->offset + OS8_ED_LENGTH] =
    data->buf[file->offset + file->extra + OS8_DI_LENGTH];
  data->buf[OS8_DH_ENTRIES] =
    htole16(os8Value(-(os8Neg(le16toh(data->buf[OS8_DH_ENTRIES])) - 1)));

  os8SlideUp(mount, file->offset + OS8_ED_SIZE,
             file->offset + file->entrysz, file->entrysz, file->remain);

  /*
   * Merge any adjacent empty directory entries.
   */
  if (os8MergeEmptyRegions(mount) != 0)
    os8MergeEmptyRegions(mount);

  if (os8WriteBlock(mount, file->unit, file->segment, NULL) == 0)
    return;

  os8CloseFile(file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movb 0x28(%rax), %al
movq -0x18(%rbp), %rcx
movzbl 0xc(%rcx), %edx
xorl %ecx, %ecx
movzbl %al, %esi
callq 0x132f0
cmpl $0x0, %eax
jne 0x16a07
jmp 0x16b1c
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl 0xe(%rcx), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movw $0x0, 0x14(%rax,%rcx,2)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl 0xe(%rcx), %ecx
movq -0x18(%rbp), %rdx
movzwl 0x12(%rdx), %edx
addl %edx, %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movw 0x14(%rax,%rcx,2), %dx
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl 0xe(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movw %dx, 0x14(%rax,%rcx,2)
movq -0x28(%rbp), %rax
movzwl 0x14(%rax), %edi
callq 0x14890
movzwl %ax, %edi
callq 0x14860
movzwl %ax, %ecx
subl $0x1, %ecx
xorl %eax, %eax
subl %ecx, %eax
movzwl %ax, %edi
callq 0x148e0
movzwl %ax, %edi
callq 0x14890
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0x14(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movzwl 0xe(%rax), %eax
addl $0x2, %eax
movw %ax, %si
movq -0x18(%rbp), %rax
movzwl 0xe(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x10(%rcx), %ecx
addl %ecx, %eax
movw %ax, %dx
movq -0x18(%rbp), %rax
movw 0x10(%rax), %cx
movq -0x18(%rbp), %rax
movzwl %si, %esi
movzwl %dx, %edx
movzwl %cx, %ecx
movzwl 0x14(%rax), %r8d
callq 0x15150
movq -0x20(%rbp), %rdi
callq 0x17350
cmpl $0x0, %eax
je 0x16aef
movq -0x20(%rbp), %rdi
callq 0x17350
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movb 0x28(%rax), %al
movq -0x18(%rbp), %rcx
movzbl 0xc(%rcx), %edx
xorl %ecx, %ecx
movzbl %al, %esi
callq 0x13450
cmpl $0x0, %eax
jne 0x16b13
jmp 0x16b1c
movq -0x18(%rbp), %rdi
callq 0x16880
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/os8.c
// Function: os8Date
static char *os8Date(
  uint16_t date,
  char *buf
)
{
  if (date != 0) {
    sprintf(buf, "%2d-%s-%4d",
            (date >> 3) & 0x1F,
            os8Month[(date >> 8) & 0xF],
            1970 + (date & 0x7));
  } else strcpy(buf, "           ");

  return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movzwl -0x2(%rbp), %eax
cmpl $0x0, %eax
je 0x17332
movq -0x10(%rbp), %rdi
movzwl -0x2(%rbp), %edx
sarl $0x3, %edx
andl $0x1f, %edx
movzwl -0x2(%rbp), %eax
sarl $0x8, %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0x7e42(%rip), %rax      # 0x1f150
movq (%rax,%rcx,8), %rcx
movzwl -0x2(%rbp), %r8d
andl $0x7, %r8d
addl $0x7b2, %r8d            # imm = 0x7B2
leaq 0x2549(%rip), %rsi      # 0x19872
movb $0x0, %al
callq 0x3290
jmp 0x17342
movq -0x10(%rbp), %rdi
leaq 0x305e(%rip), %rsi      # 0x1a39b
callq 0x30b0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/DAStrim.c
// Function: ESORT
static int ESORT(const void *l, const void *r)
{ Event *x = (Event *) l;
  Event *y = (Event *) r;

  if (x->pos == y->pos)
    return (x->type - y->type);
  return (x->pos - y->pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x776d
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x777e
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
subl 0x4(%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/DAStrim.c
// Function: eval_lft_anchor
static int eval_lft_anchor(int lft, Overlap *lov)
{ uint16  *tr;
  int      te;

  if (lft > lov->path.aepos)
    return (50);
  tr = (uint16 *) lov->path.trace;
  te = 2 * (((lft + (TRACE_SPACING-1)) - lov->path.abpos)/TRACE_SPACING);
  if (te <= 0)
    return (50);
  return (tr[te-2]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jle 0x98d0
movl $0x32, -0x4(%rbp)
jmp 0x991f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl 0x27bf4(%rip), %ecx     # 0x314d8
subl $0x1, %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
subl 0x10(%rcx), %eax
cltd
idivl 0x27be1(%rip)           # 0x314d8
shll %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x990b
movl $0x32, -0x4(%rbp)
jmp 0x991f
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/DAStrim.c
// Function: eval_rgt_anchor
static int eval_rgt_anchor(int rgt, Overlap *rov)
{ uint16  *tr;
  int      te;

  if (rgt < rov->path.abpos)
    return (50);
  tr = (uint16 *) rov->path.trace;
  te = 2 * (((rgt + (TRACE_SPACING-1)) - rov->path.abpos)/TRACE_SPACING);
  if (te >= rov->path.tlen)
    return (50);
  return (tr[te]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x9950
movl $0x32, -0x4(%rbp)
jmp 0x99a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl 0x27b74(%rip), %ecx     # 0x314d8
subl $0x1, %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
subl 0x10(%rcx), %eax
cltd
idivl 0x27b61(%rip)           # 0x314d8
shll %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x9991
movl $0x32, -0x4(%rbp)
jmp 0x99a0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_err_delete
void mpc_err_delete(mpc_err_t *x) {
  int i;
  for (i = 0; i < x->expected_num; i++) { free(x->expected[i]); }
  free(x->expected);
  free(x->filename);
  free(x->failure);
  free(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x498f
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4850
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4963
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x4850
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x4850
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x4850
movq -0x8(%rbp), %rdi
callq 0x4850
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_err_string_cat
static void mpc_err_string_cat(char *buffer, int *pos, int *max, char const *fmt, ...) {
  /* TODO: Error Checking on Length */
  int left = ((*max) - (*pos));
  va_list va;
  va_start(va, fmt);
  if (left < 0) { left = 0;}
  (*pos) += vsprintf(buffer + (*pos), fmt, va);
  va_end(va);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x4ccb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x24(%rbp)
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
cmpl $0x0, -0x24(%rbp)
jge 0x4d29
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x4670
movl %eax, %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl %edx, %ecx
movl %ecx, (%rax)
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_err_char_unescape
static const char *mpc_err_char_unescape(char c, char char_unescape_buffer[4]) {

  char_unescape_buffer[0] = '\'';
  char_unescape_buffer[1] = ' ';
  char_unescape_buffer[2] = '\'';
  char_unescape_buffer[3] = '\0';

  switch (c) {
    case '\a': return "bell";
    case '\b': return "backspace";
    case '\f': return "formfeed";
    case '\r': return "carriage return";
    case '\v': return "vertical tab";
    case '\0': return "end of input";
    case '\n': return "newline";
    case '\t': return "tab";
    case ' ' : return "space";
    default:
      char_unescape_buffer[1] = c;
      return char_unescape_buffer;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x9(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x27, (%rax)
movq -0x18(%rbp), %rax
movb $0x20, 0x1(%rax)
movq -0x18(%rbp), %rax
movb $0x27, 0x2(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x3(%rax)
movsbl -0x9(%rbp), %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x20, %eax
ja 0x4e29
movq -0x20(%rbp), %rax
leaq 0xd255(%rip), %rcx      # 0x12000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xda2d(%rip), %rax      # 0x127e8
movq %rax, -0x8(%rbp)
jmp 0x4e3b
leaq 0xda25(%rip), %rax      # 0x127ed
movq %rax, -0x8(%rbp)
jmp 0x4e3b
leaq 0xda22(%rip), %rax      # 0x127f7
movq %rax, -0x8(%rbp)
jmp 0x4e3b
leaq 0xda1e(%rip), %rax      # 0x12800
movq %rax, -0x8(%rbp)
jmp 0x4e3b
leaq 0xda21(%rip), %rax      # 0x12810
movq %rax, -0x8(%rbp)
jmp 0x4e3b
leaq 0xd78e(%rip), %rax      # 0x1258a
movq %rax, -0x8(%rbp)
jmp 0x4e3b
leaq 0xdadc(%rip), %rax      # 0x128e5
movq %rax, -0x8(%rbp)
jmp 0x4e3b
leaq 0xda03(%rip), %rax      # 0x12819
movq %rax, -0x8(%rbp)
jmp 0x4e3b
leaq 0xd79f(%rip), %rax      # 0x125c2
movq %rax, -0x8(%rbp)
jmp 0x4e3b
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_parse_input
int mpc_parse_input(mpc_input_t *i, mpc_parser_t *p, mpc_result_t *r) {
  int x;
  mpc_err_t *e = mpc_err_fail(i, "Unknown Error");
  e->state = mpc_state_invalid();
  x = mpc_parse_run(i, p, r, &e, 0);
  if (x) {
    mpc_err_delete_internal(i, e);
    r->output = mpc_export(i, r->output);
  } else {
    r->error = mpc_err_export(i, mpc_err_merge(i, e, r->error));
  }
  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xd656(%rip), %rsi      # 0x124c5
callq 0x4f40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5060
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rcx
xorl %r8d, %r8d
callq 0x5090
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x4ef6
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x60f0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6190
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4f28
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
callq 0x62e0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x6210
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_err_fail
static mpc_err_t *mpc_err_fail(mpc_input_t *i, const char *failure) {
  mpc_err_t *x;
  if (i->suppress) { return NULL; }
  x = mpc_malloc(i, sizeof(mpc_err_t));
  x->filename = mpc_malloc(i, strlen(i->filename) + 1);
  strcpy(x->filename, i->filename);
  x->state = i->state;
  x->expected_num = 0;
  x->expected = NULL;
  x->failure = mpc_malloc(i, strlen(failure) + 1);
  strcpy(x->failure, failure);
  x->received = ' ';
  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x48(%rax)
je 0x4f67
movq $0x0, -0x8(%rbp)
jmp 0x5049
movq -0x10(%rbp), %rdi
movl $0x48, %esi
callq 0xec40
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x41b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0xec40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x40e0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, (%rax)
movq 0x18(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x20(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x28(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0xec40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x40e0
movq -0x20(%rbp), %rax
movb $0x20, 0x40(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_state_invalid
static mpc_state_t mpc_state_invalid(void) {
  mpc_state_t s;
  s.pos = -1;
  s.row = -1;
  s.col = -1;
  s.term = 0;
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq $-0x1, (%rdi)
movq $-0x1, 0x8(%rdi)
movq $-0x1, 0x10(%rdi)
movl $0x0, 0x18(%rdi)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_err_delete_internal
static void mpc_err_delete_internal(mpc_input_t *i, mpc_err_t *x) {
  int j;
  if (x == NULL) { return; }
  for (j = 0; j < x->expected_num; j++) { mpc_free(i, x->expected[j]); }
  mpc_free(i, x->expected);
  mpc_free(i, x->filename);
  mpc_free(i, x->failure);
  mpc_free(i, x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6109
jmp 0x6180
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x6140
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xfac0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6110
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0xfac0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0xfac0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xfac0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfac0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_export
static void *mpc_export(mpc_input_t *i, void *p) {
  char *q = NULL;
  if (!mpc_mem_ptr(i, p)) { return p; }
  q = malloc(sizeof(mpc_mem_t));
  memcpy(q, p, sizeof(mpc_mem_t));
  mpc_free(i, p);
  return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10200
cmpl $0x0, %eax
jne 0x61c4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x61f9
movl $0x40, %edi
callq 0x4570
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x40, %edx
callq 0x44e0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xfac0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_err_export
static mpc_err_t *mpc_err_export(mpc_input_t *i, mpc_err_t *x) {
  int j;
  for (j = 0; j < x->expected_num; j++) {
    x->expected[j] = mpc_export(i, x->expected[j]);
  }
  x->expected = mpc_export(i, x->expected);
  x->filename = mpc_export(i, x->filename);
  x->failure = mpc_export(i, x->failure);
  return mpc_export(i, x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x626a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x6190
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6227
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x6190
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x6190
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x6190
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6190
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_err_merge
static mpc_err_t *mpc_err_merge(mpc_input_t *i, mpc_err_t *x, mpc_err_t *y) {
  mpc_err_t *errs[2];
  errs[0] = x;
  errs[1] = y;
  return mpc_err_or(i, errs, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x2, %edx
callq 0x10870
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_parse
int mpc_parse(const char *filename, const char *string, mpc_parser_t *p, mpc_result_t *r) {
  int x;
  mpc_input_t *i = mpc_input_new_string(filename, string);
  x = mpc_parse_input(i, p, r);
  mpc_input_delete(i);
  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6370
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x40b0
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rdi
callq 0x64e0
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop