LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x5c(%rdi), %r15
testq %rcx, %rcx
cmovneq %rcx, %r15
movl %esi, %ebp
movq 0x50(%rdi), %rax
cmpb %bpl, 0x8(%rax)
jbe 0xd77c
movzbl 0x59(%r14), %ecx
btl %ebp, %ecx
jae 0xd77c
movl %edx, %ebx
testb $0x2, 0x30(%r14)
je 0xd760
leaq 0xb886(%rip), %rax      # 0x18fc8
movq (%rax), %rdi
leaq 0x8(%r14), %rdx
leaq 0x5180(%rip), %rsi      # 0x128d0
movl %ebp, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x31e0
movq 0x50(%r14), %rax
movq 0x38(%rax), %rax
movzbl %bpl, %esi
movq %r14, %rdi
movl %ebx, %edx
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
leaq 0x4(%rsp), %rbx
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x474f
movl (%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x5c(%rdi), %r15
testq %rcx, %rcx
cmovneq %rcx, %r15
movl %esi, %ebp
movq 0x50(%rdi), %rax
cmpb %bpl, 0x8(%rax)
jbe 0xd810
movzbl 0x59(%r14), %ecx
btl %ebp, %ecx
jae 0xd810
movl %edx, %ebx
testb $0x2, 0x30(%r14)
je 0xd7f4
leaq 0xb7f2(%rip), %rax      # 0x18fc8
movq (%rax), %rdi
leaq 0x8(%r14), %rdx
leaq 0x5115(%rip), %rsi      # 0x128f9
movl %ebp, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x31e0
movq 0x50(%r14), %rax
movq 0x40(%rax), %rax
movzbl %bpl, %esi
movq %r14, %rdi
movl %ebx, %edx
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
leaq 0x4(%rsp), %rbx
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x47b2
movl (%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/converters/fsio/os8.c
// Function: os8UpdateFile
void os8UpdateFile(
  struct mountedFS *mount,
  uint8_t unit,
  struct os8OpenFile *file
)
{
  struct OS8data *data = &mount->os8data;
  uint16_t off = file->offset;
  uint16_t empty = off + file->extra + OS8_DI_SIZE;
  uint16_t length = file->current == 0 ? 0 : file->current - file->start;
  uint16_t left = file->length - length;
  uint16_t space;

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

  /*
   * The directory entry is complete except for the # of blocks in use
   * which we can now update.
   */
  data->buf[off + file->extra + OS8_DI_LENGTH] = htole16(os8Value(-length));

  /*
   * Update the remaining space in the following empty file descriptor.
   */
  space = os8Neg(le16toh(data->buf[empty + OS8_ED_LENGTH])) + left;
  data->buf[empty + OS8_ED_LENGTH] = htole16(os8Value(-space));

  if (space == 0)
    /*
     * Remove the empty directory entry since it now occupies 0 blocks
     */
    os8SlideUp(mount, empty, empty + OS8_ED_SIZE, file->entrysz, file->remain);

  os8WriteBlock(mount, unit, file->segment, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movzwl 0xe(%rdx), %r12d
movzwl 0x3a(%rdx), %r13d
testw %r13w, %r13w
je 0xe48c
subw 0x38(%r14), %r13w
jmp 0xe48f
xorl %r13d, %r13d
movzwl 0x12(%r14), %r15d
addw %r12w, %r15w
movzwl 0xa(%r14), %ebp
movzbl 0xc(%r14), %edx
movzbl %sil, %esi
movq %rbx, %rdi
movl %esi, 0x4(%rsp)
xorl %ecx, %ecx
callq 0xd707
testl %eax, %eax
je 0xe531
leal 0x5(%r15), %eax
subl %r13d, %ebp
negl %r13d
movl $0xfff, %ecx            # imm = 0xFFF
andl %ecx, %r13d
movzwl 0x12(%r14), %edx
addl %edx, %r12d
movw %r13w, 0x64(%rbx,%r12,2)
movzwl %ax, %esi
xorl %eax, %eax
subw 0x5e(%rbx,%rsi,2), %ax
andl %ecx, %eax
addl %ebp, %eax
movl %eax, %edx
negl %edx
andl %ecx, %edx
movw %dx, 0x5e(%rbx,%rsi,2)
testw %ax, %ax
jne 0xe510
addl $0x7, %r15d
movzwl 0x10(%r14), %ecx
movzwl 0x14(%r14), %r8d
movzwl %r15w, %edx
movq %rbx, %rdi
callq 0xe540
movzbl 0xc(%r14), %edx
movq %rbx, %rdi
movl 0x4(%rsp), %esi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd79b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %r8d, %r8d
je 0xe5a3
pushq %rbx
xorl %eax, %eax
movl $0x2, %r9d
movzwl %dx, %r10d
movzwl 0x5c(%rdi,%r10,2), %r10d
testl $0xfff, %r10d           # imm = 0xFFF
movl %ecx, %r10d
cmovel %r9d, %r10d
testw %r10w, %r10w
je 0xe590
leal 0x1(%rdx), %r11d
movzwl %dx, %edx
movzwl 0x5c(%rdi,%rdx,2), %edx
leal 0x1(%rsi), %ebx
movzwl %si, %esi
movw %dx, 0x5c(%rdi,%rsi,2)
movl %ebx, %esi
movl %r11d, %edx
decw %r10w
jne 0xe56c
jmp 0xe595
movl %edx, %r11d
movl %esi, %ebx
incl %eax
movl %ebx, %esi
movl %r11d, %edx
cmpw %r8w, %ax
jne 0xe54e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/converters/fsio/os8.c
// Function: os8OpenFileW
void *os8OpenFileW(
  struct mountedFS *mount,
  uint8_t unit,
  char *fname,
  off_t size
)
{
  struct os8OpenFile *file;
  struct os8FileSpec spec;
  uint16_t blocks = 0;

  if (size != 0)
    blocks = (size + ((OS8_BLOCKSIZE * 3) / 2) - 1) / (((OS8_BLOCKSIZE) * 3) / 2);

  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) {
        memset(file->buffer, 0, mount->blocksz);

        if (os8CreateFile(mount, unit, &spec, file, blocks) == 0) {
          ERROR("Failed to create file \"%s\"\n", fname);
          free(file->buffer);
          free(file);
          return NULL;
        } else file->mode = M_WR;
      } else {
        ERROR("Buffer allocation failure for \"%s\"\n", fname);
        free(file);
        return NULL;
      }
    } else {
      ERROR("File \"%s\" already exists\n", fname);\
      free(file);
      return NULL;
    }
  } else ERROR("Memory allocation failure\n");
  return file;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
testq %rcx, %rcx
je 0xe881
addq $0x17f, %rcx            # imm = 0x17F
movabsq $0x2aaaaaaaaaaaaaab, %rdx # imm = 0x2AAAAAAAAAAAAAAB
movq %rcx, %rax
imulq %rdx
movq %rdx, %r12
movq %rdx, %rax
shrq $0x3f, %rax
shrl $0x6, %r12d
addl %eax, %r12d
jmp 0xe884
xorl %r12d, %r12d
leaq 0x6(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xd82f
testl %eax, %eax
je 0xe915
movl $0x1, %edi
movl $0x50, %esi
callq 0x31c0
testq %rax, %rax
je 0xe935
movq %rax, %r14
movzbl %bpl, %ebp
leaq 0x6(%rsp), %rdx
movq %r15, %rdi
movl %ebp, %esi
movq %rax, %rcx
callq 0xe220
testl %eax, %eax
jne 0xe947
movq 0x28(%r15), %rsi
movl $0x1, %edi
callq 0x31c0
movq %rax, 0x30(%r14)
testq %rax, %rax
je 0xe954
movzwl %r12w, %r8d
leaq 0x6(%rsp), %rdx
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rcx
callq 0xda66
testl %eax, %eax
je 0xe961
movl $0x1, 0x18(%r14)
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x96d4(%rip), %rax      # 0x17ff0
movq (%rax), %rdi
leaq 0x34b1(%rip), %rsi      # 0x11dd7
xorl %r14d, %r14d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x31e0
jmp 0xe905
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x4a05
movq (%rbx), %r14
jmp 0xe905
movq %rbx, %rdi
movq %r14, %rsi
callq 0x48db
jmp 0xe973
movq %rbx, %rdi
movq %r14, %rsi
callq 0x49a5
jmp 0xe973
movq %r14, %rsi
addq $0x30, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x493b
xorl %r14d, %r14d
jmp 0xe905
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
leaq 0xa26b(%rip), %rax      # 0x18fd8
leaq 0xa06c(%rip), %r14      # 0x18de0
testb $0x8, 0x2(%rax)
je 0xedbc
movq 0xa04f(%rip), %rsi      # 0x18dd0
testq %rsi, %rsi
je 0xedbc
leaq 0xa253(%rip), %rax      # 0x18fe0
movq 0x98(%rax), %rbx
leaq 0xa07d(%rip), %r15      # 0x18e18
movq %rbx, %rdi
callq 0x31d0
testl %eax, %eax
je 0xedb5
movq (%r15), %rsi
addq $0x48, %r15
testq %rsi, %rsi
jne 0xed9b
jmp 0xedbc
addq $-0x38, %r15
movq %r15, %r14
movq (%r14), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/converters/fsio/os8.c
// Function: os8Set
static void os8Set(
  struct mountedFS *mount,
  uint8_t UNUSED(unit),
  uint8_t UNUSED(present)
)
{
  struct OS8data *data = &mount->os8data;
  int idx = 0;
  unsigned long year;
  char *endptr;

  while (setCmds[idx] != NULL) {
    if (strcmp(words[1], setCmds[idx]) == 0) {
      switch (idx) {
        case OS8SET_YEAR:
          if (args == 3) {
            if (strcmp(words[2], "none") == 0) {
              data->date = 0;
              return;
            }
            year = strtoul(words[2], &endptr, 10);
            if ((*endptr == '\0') && (year <= 7)) {
              struct tm tm;
              time_t now = time(NULL);

              localtime_r(&now, &tm);

              data->date = (tm.tm_mon + 1) << 8;
              data->date |= (tm.tm_mday + 1) << 3;
              data->date |= year;
              return;
            }
          }
          fprintf(stderr, "os8: Invalid syntax for \"set year\"\n");
          return;

        default:
          fprintf(stderr, "os8: \"%s\" not implemented\n", words[1]);
          return;
      }
    }
    idx++;
  }
  fprintf(stderr, "os8: Unknown set command \"%s\"\n", words[1]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0xa151(%rip), %rax      # 0x190b8
movq (%rax), %r15
movq 0x8(%r15), %r14
leaq 0x3c20(%rip), %rsi      # 0x12b95
movq %r14, %rdi
callq 0x31d0
testl %eax, %eax
jne 0xf025
leaq 0xa124(%rip), %rax      # 0x190b0
cmpl $0x3, (%rax)
jne 0xf016
movq 0x10(%r15), %r14
leaq 0x3bad(%rip), %rsi      # 0x12b4d
movq %r14, %rdi
callq 0x31d0
testl %eax, %eax
je 0xf00e
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x32a0
movq %rax, %r14
movq (%r15), %rax
cmpb $0x0, (%rax)
jne 0xf016
cmpq $0x7, %r14
ja 0xf016
xorl %edi, %edi
callq 0x3200
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x18(%rsp), %r15
movq %r15, %rsi
callq 0x30b0
movl 0xc(%r15), %eax
movl 0x10(%r15), %ecx
shll $0x8, %ecx
addl $0x100, %ecx            # imm = 0x100
leal (%r14,%rax,8), %eax
addl $0x8, %eax
orl %ecx, %eax
movw %ax, 0x5a(%rbx)
jmp 0xf01b
movw $0x0, 0x5a(%rbx)
jmp 0xf01b
callq 0x4a74
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8fc4(%rip), %rax      # 0x17ff0
movq (%rax), %rdi
leaq 0x3b40(%rip), %rsi      # 0x12b76
movq %r14, %rdx
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x31e0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %r14
testl %edx, %edx
je 0xf07c
testq %r14, %r14
je 0xf0b7
cmpb %sil, 0x8(%r14)
jbe 0xf0b7
movzbl 0x59(%rbx), %eax
movzbl %sil, %esi
btl %esi, %eax
jae 0xf0b7
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xf547
movb 0x8(%r14), %al
testb %al, %al
je 0xf0b7
xorl %ebp, %ebp
movq 0x50(%rbx), %rcx
testq %rcx, %rcx
je 0xf0ae
cmpb %bpl, 0x8(%rcx)
jbe 0xf0ae
movzbl 0x59(%rbx), %ecx
btl %ebp, %ecx
jae 0xf0ae
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0xf547
movb 0x8(%r14), %al
incl %ebp
movzbl %al, %ecx
cmpl %ecx, %ebp
jb 0xf086
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
leaq 0x6(%rsp), %rsi
movq %rdx, %rdi
xorl %edx, %edx
callq 0xd82f
testl %eax, %eax
je 0xf3f4
movl $0x1, %edi
movl $0x50, %esi
callq 0x31c0
testq %rax, %rax
je 0xf3e4
movq %rax, %rbx
movzbl %bpl, %esi
leaq 0x6(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rcx
callq 0xe220
testl %eax, %eax
je 0xf3dc
movq 0x28(%r14), %rdi
callq 0x3220
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0xf3dc
movl $0x0, 0x18(%rbx)
jmp 0xf3e6
movq %rbx, %rdi
callq 0x3050
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8bf5(%rip), %rax      # 0x17ff0
movq (%rax), %rdi
leaq 0x29d2(%rip), %rsi      # 0x11dd7
xorl %ebx, %ebx
movq %r15, %rdx
xorl %eax, %eax
callq 0x31e0
jmp 0xf3e6
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
cmpl $0x1, 0x18(%rdi)
jne 0xf460
movzwl 0x3a(%rbx), %edx
testl %edx, %edx
je 0xf450
movzbl 0x28(%rbx), %esi
leal 0x1(%rdx), %eax
movw %ax, 0x3a(%rbx)
movq 0x20(%rbx), %rdi
movq 0x30(%rbx), %rcx
callq 0xd79b
movq 0x20(%rbx), %rdi
movzbl 0x28(%rbx), %esi
movq %rbx, %rdx
callq 0xe464
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0xf46e
callq 0x3050
movq %rbx, %rdi
popq %rbx
jmp 0x3050
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movzbl 0x28(%rdi), %esi
movzbl 0xc(%rdi), %edx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xd707
testl %eax, %eax
je 0xf53f
movzwl 0xe(%rbx), %eax
movw $0x0, 0x5c(%r14,%rax,2)
movzwl 0xe(%rbx), %eax
movzwl 0x12(%rbx), %ecx
addl %eax, %ecx
movzwl 0x64(%r14,%rcx,2), %ecx
movw %cx, 0x5e(%r14,%rax,2)
movl 0x5c(%r14), %eax
incl %eax
andl $0xfff, %eax            # imm = 0xFFF
movw %ax, 0x5c(%r14)
movzwl 0xe(%rbx), %esi
movzwl 0x10(%rbx), %ecx
leal (%rcx,%rsi), %edx
addl $0x2, %esi
movzwl 0x14(%rbx), %r8d
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %esi
andl %eax, %edx
movq %r14, %rdi
callq 0xe540
movq %r14, %rdi
callq 0xf810
testl %eax, %eax
je 0xf51a
movq %r14, %rdi
callq 0xf810
movzbl 0x28(%rbx), %esi
movzbl 0xc(%rbx), %edx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xd79b
testl %eax, %eax
je 0xf53f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf426
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rsi, %rbx
testl %edi, %edi
je 0xf7f7
movzwl %di, %r8d
movl %r8d, %edx
shrl $0x3, %edx
andl $0x1f, %edx
movl %r8d, %eax
shrl $0x6, %eax
andl $0x3c, %eax
leaq 0x30be(%rip), %rsi      # 0x12890
movslq (%rax,%rsi), %rcx
addq %rsi, %rcx
andl $0x7, %r8d
addl $0x7b2, %r8d            # imm = 0x7B2
leaq 0x202a(%rip), %rsi      # 0x11815
movq %rbx, %rdi
xorl %eax, %eax
callq 0x32b0
jmp 0xf80b
movabsq $0x2020202020202020, %rax # imm = 0x2020202020202020
movq %rax, (%rbx)
movl $0x202020, 0x8(%rbx)    # imm = 0x202020
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/converters/fsio/os8.c
// Function: os8MergeEmptyRegions
static int os8MergeEmptyRegions(
  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]));

  if (entries > 1) {
    for (i = 0; i < (entries - 1); i++) {
      if (os8Word(le16toh(data->buf[off + OS8_DI_FNAME1])) == 0) {
        if (os8Word(le16toh(data->buf[off + OS8_ED_SIZE + OS8_DI_FNAME1])) == 0) {
          data->buf[off + OS8_ED_LENGTH] =
            htole16(os8Value(le16toh(data->buf[off + OS8_ED_LENGTH]) +
                             le16toh(data->buf[off + OS8_ED_SIZE + OS8_ED_LENGTH])));
          data->buf[OS8_DH_ENTRIES] = htole16(os8Value(-(entries - 1)));

          os8SlideUp(mount, off + OS8_ED_SIZE,
                     off + (2 * OS8_ED_SIZE), entrysz, entries - 2);
          return 1;
        }
      } else off += entrysz;
    }
  }
  return 0;
}

// Assembly:
movl $0xfff, %ecx            # imm = 0xFFF
movl 0x5c(%rdi), %eax
movl %eax, %edx
negl %edx
andl %ecx, %edx
cmpw $0x2, %dx
jb 0xf88a
pushq %rbp
pushq %rbx
pushq %rax
movzwl 0x64(%rdi), %esi
andl %esi, %ecx
shll $0x4, %esi
movswl %si, %esi
sarl $0xf, %esi
andl $0xfffff000, %esi       # imm = 0xFFFFF000
orl %ecx, %esi
movl $0x5, %ecx
subl %esi, %ecx
movzwl %dx, %r8d
leal -0x1(%r8), %r9d
movw $0x5, %dx
xorl %r10d, %r10d
movswl %cx, %r11d
movzwl %dx, %ebx
movzwl 0x5c(%rdi,%rbx,2), %esi
testl $0xfff, %esi            # imm = 0xFFF
je 0xf86d
addl %r11d, %edx
jmp 0xf87d
leal 0x2(%rbx), %esi
movzwl 0x5c(%rdi,%rsi,2), %ebp
testl $0xfff, %ebp            # imm = 0xFFF
je 0xf88d
incl %r10d
cmpw %r10w, %r9w
ja 0xf858
xorl %eax, %eax
jmp 0xf8d4
xorl %eax, %eax
retq
movl %ebx, %r9d
movzwl 0x62(%rdi,%r9,2), %r10d
addw 0x5e(%rdi,%r9,2), %r10w
movl $0xfff, %r11d           # imm = 0xFFF
andl %r11d, %r10d
movw %r10w, 0x5e(%rdi,%r9,2)
incl %eax
andl %r11d, %eax
movw %ax, 0x5c(%rdi)
addl $0x4, %edx
addl $-0x2, %r8d
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %esi
andl %eax, %edx
andl %eax, %r8d
movzwl %cx, %ecx
callq 0xe540
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/thegenemyers[P]DASCRUBBER/DAStrim.c
// Function: wall_detector
static Wall *wall_detector(int *ev, int b, int e, Wall *next)
{ int idx;

  { int    i, n, max;
    double ave;

    n = e-b;

    if (n < MIN_PNT) return (next);  //  Too small: done

    idx = b;
    max = -1;                        //  Find the position of the largest separation between
    for (i = b+1; i < e; i++)        //     two tips in ev[b..e)
      if (ev[i] - ev[i-1] > max)
        { max = ev[i] - ev[i-1];
          idx = i;
        }

    ave = (ev[e-1] - ev[b]) / (n-1.);        //  Check if the current interval is a wall
    if (ave <= AVE_SEP && max <= MAX_SEP)
      { if (max <= 4.*(ave+1.))              //  Max separation < 4*average separation ?
          { next->beg = b;
            next->end = e;
            next->cnt = n;
            return (next+1);
          }
      }
  }

  next = wall_detector(ev,b,idx,next);    //  If not then split on the largest separation
  next = wall_detector(ev,idx,e,next);    //    and recurse on the two parts
  return (next);
}

// Assembly:
movq %rcx, %rax
movl %edx, %ecx
subl %esi, %ecx
cmpl $0x5, %ecx
jl 0x7232
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movslq %edx, %r15
leaq 0x4(%rdi), %r12
movl %ebp, %esi
leal 0x1(%rsi), %r8d
movslq %ebp, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpl %ebx, %r8d
jge 0x71b3
leaq (%r12,%rdi,4), %r9
movl %esi, %ebp
movl (%r9), %r10d
subl -0x4(%r9), %r10d
cmpl %edx, %r10d
cmovgl %r8d, %ebp
cmovgl %r10d, %edx
addq $0x4, %r9
incl %r8d
cmpl %r8d, %ebx
jne 0x7195
movl -0x4(%r14,%r15,4), %r8d
subl (%r14,%rdi,4), %r8d
xorps %xmm0, %xmm0
cvtsi2sd %r8d, %xmm0
leal -0x1(%rcx), %edi
xorps %xmm1, %xmm1
cvtsi2sd %edi, %xmm1
divsd %xmm1, %xmm0
movsd 0x17e66(%rip), %xmm1    # 0x1f040
ucomisd %xmm0, %xmm1
jb 0x7202
cmpl $0x19, %edx
jg 0x7202
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
addsd 0x17e54(%rip), %xmm0    # 0x1f048
mulsd 0x17e54(%rip), %xmm0    # 0x1f050
ucomisd %xmm1, %xmm0
jae 0x721e
movq %r14, %rdi
movl %ebp, %edx
movq %rax, %rcx
callq 0x7156
movl %ebx, %ecx
subl %ebp, %ecx
cmpl $0x4, %ecx
jg 0x717c
jmp 0x722a
movl %esi, (%rax)
movl %ebx, 0x4(%rax)
movl %ecx, 0x8(%rax)
addq $0x10, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
cmpl $0x0, 0x48(%rdi)
je 0x4c72
xorl %ebx, %ebx
jmp 0x4cf1
movq %rsi, %r14
movq %rdi, %r15
movl $0x48, %edi
callq 0x43a0
movq %rax, %rbx
movq 0x8(%r15), %rdi
callq 0x4130
leaq 0x1(%rax), %rsi
movq %r15, %rdi
callq 0xc5d1
movq %rax, 0x28(%rbx)
movq 0x8(%r15), %rsi
movq %rax, %rdi
callq 0x40b0
movups 0x10(%r15), %xmm0
movups 0x20(%r15), %xmm1
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
movl $0x0, 0x20(%rbx)
movq $0x0, 0x38(%rbx)
movq %r14, %rdi
callq 0x4130
leaq 0x1(%rax), %rsi
movq %r15, %rdi
callq 0xc5d1
movq %rax, 0x30(%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
movb $0x20, 0x40(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x590e
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x20(%rsi)
jle 0x584e
leaq 0x278(%r14), %r15
leaq 0x8278(%r14), %r12
xorl %r13d, %r13d
movq 0x38(%rbx), %rax
movq (%rax,%r13,8), %rdi
cmpq %rdi, %r15
seta %al
cmpq %rdi, %r12
setbe %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x5835
callq 0x4580
jmp 0x5842
subq %r15, %rdi
shrq $0x6, %rdi
movb $0x0, 0x78(%r14,%rdi)
incq %r13
movslq 0x20(%rbx), %rax
cmpq %rax, %r13
jl 0x5813
movq 0x38(%rbx), %rdi
leaq 0x278(%r14), %r15
cmpq %rdi, %r15
seta %al
leaq 0x8278(%r14), %r12
cmpq %rdi, %r12
setbe %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x587a
callq 0x4580
jmp 0x5887
subq %r15, %rdi
shrq $0x6, %rdi
movb $0x0, 0x78(%r14,%rdi)
movq 0x28(%rbx), %rdi
cmpq %rdi, %r15
seta %al
cmpq %rdi, %r12
setbe %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x58a5
callq 0x4580
jmp 0x58b2
subq %r15, %rdi
shrq $0x6, %rdi
movb $0x0, 0x78(%r14,%rdi)
movq 0x30(%rbx), %rdi
cmpq %rdi, %r15
seta %al
cmpq %rdi, %r12
setbe %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x58d0
callq 0x4580
jmp 0x58dd
subq %r15, %rdi
shrq $0x6, %rdi
movb $0x0, 0x78(%r14,%rdi)
cmpq %rbx, %r15
seta %al
cmpq %rbx, %r12
setbe %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x5901
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4580
subq %r15, %rbx
shrq $0x6, %rbx
movb $0x0, 0x78(%r14,%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
xorl %ebx, %ebx
movq %rsi, %rax
orq %rdx, %rax
jne 0x5942
xorl %r13d, %r13d
jmp 0x5b71
movq %rdx, %r15
leaq 0x18(%rsp), %r12
cmpq $0x1, %rsi
movq %rdi, 0x8(%rsp)
movl $0x0, %r14d
sbbq %r14, %r14
movl $0x48, %edi
callq 0x43a0
movq %rax, %r13
addq $0x30, %rax
movq %rax, 0x30(%rsp)
testq %r15, %r15
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, (%r13)
movq $-0x1, 0x10(%r13)
movl %ebx, 0x18(%r13)
movl %ebx, 0x20(%r13)
movl $0x1, %eax
cmoveq %r14, %rax
pxor %xmm0, %xmm0
movdqu %xmm0, 0x30(%r13)
movq 0x10(%rsp,%rax,8), %rbx
movq 0x28(%rbx), %rdi
callq 0x4130
leaq 0x1(%rax), %rsi
movq 0x8(%rsp), %rdi
callq 0xc5d1
movq %rax, 0x28(%r13)
movq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0x40b0
leaq 0x10(%rsp), %rcx
movb $0x1, %al
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x59f9
movq (%rcx), %rdx
cmpq (%r13), %rdx
jle 0x59f9
movdqu (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%r13)
movdqu %xmm0, (%r13)
xorl %ebp, %ebp
movq %r12, %rcx
testb $0x1, %al
movl $0x0, %eax
jne 0x59d5
leaq 0x10(%rsp), %rdx
movb $0x1, %cl
xorl %r15d, %r15d
movq %r13, 0x28(%rsp)
movq (%rdx), %r14
testq %r14, %r14
je 0x5b0e
movq (%r14), %rax
cmpq (%r13), %rax
jl 0x5b0e
movq 0x30(%r14), %rdi
testq %rdi, %rdi
jne 0x5b21
movb 0x40(%r14), %al
movb %al, 0x40(%r13)
cmpl $0x0, 0x20(%r14)
jle 0x5b0e
movq %rdx, 0x38(%rsp)
movl %ecx, 0x24(%rsp)
xorl %ebx, %ebx
movq %r14, 0x40(%rsp)
movq 0x38(%r14), %rax
movq (%rax,%rbx,8), %r12
movq %rbp, %r14
testl %ebp, %ebp
jle 0x5a8b
movl %r14d, %r13d
xorl %ebp, %ebp
movq (%r15,%rbp,8), %rdi
movq %r12, %rsi
callq 0x42b0
testl %eax, %eax
je 0x5ae4
incq %rbp
cmpq %rbp, %r13
jne 0x5a73
movq %r14, %rbp
movslq %ebp, %r14
incl %ebp
leaq 0x8(,%r14,8), %rdx
movq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xd20a
movq %rax, %r15
movq 0x28(%rsp), %rax
movq %r15, 0x38(%rax)
movq %r12, %rdi
callq 0x4130
leaq 0x1(%rax), %rsi
movq %r13, %rdi
callq 0xc5d1
movq %rax, (%r15,%r14,8)
movq %rax, %rdi
movq %r12, %rsi
callq 0x40b0
movq 0x38(%rsp), %rax
movq (%rax), %r14
jmp 0x5aec
movq %r14, %rbp
movq 0x40(%rsp), %r14
incq %rbx
movslq 0x20(%r14), %rax
cmpq %rax, %rbx
jl 0x5a5a
movq 0x28(%rsp), %r13
movl %ebp, 0x20(%r13)
leaq 0x18(%rsp), %r12
movl 0x24(%rsp), %ecx
movq %r12, %rdx
testb $0x1, %cl
movl $0x0, %ecx
jne 0x5a16
jmp 0x5b48
callq 0x4130
leaq 0x1(%rax), %rsi
movq 0x8(%rsp), %rdi
callq 0xc5d1
movq 0x30(%rsp), %rcx
movq %rax, (%rcx)
movq 0x30(%r14), %rsi
movq %rax, %rdi
callq 0x40b0
leaq 0x10(%rsp), %rax
movb $0x1, %bl
movq 0x8(%rsp), %r14
movq (%rax), %rsi
testq %rsi, %rsi
je 0x5b64
movq %r14, %rdi
callq 0x57e4
movq %r12, %rax
testb $0x1, %bl
movl $0x0, %ebx
jne 0x5b54
movq %r13, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
callq 0x5bb6
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4090
movl %eax, %ebx
movq %r15, %rdi
callq 0x5c78
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_input_delete
static void mpc_input_delete(mpc_input_t *i) {

  free(i->filename);

  if (i->type == MPC_INPUT_STRING) { free(i->string); }
  if (i->type == MPC_INPUT_PIPE) { free(i->buffer); }

  free(i->marks);
  free(i->lasts);
  free(i);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x4580
movl (%rbx), %eax
testl %eax, %eax
jne 0x5c96
movq 0x30(%rbx), %rdi
callq 0x4580
movl (%rbx), %eax
cmpl $0x2, %eax
jne 0x5ca4
movq 0x38(%rbx), %rdi
callq 0x4580
movq 0x58(%rbx), %rdi
callq 0x4580
movq 0x60(%rbx), %rdi
callq 0x4580
movq %rbx, %rdi
popq %rbx
jmp 0x4580
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_parse_file
int mpc_parse_file(const char *filename, FILE *file, mpc_parser_t *p, mpc_result_t *r) {
  int x;
  mpc_input_t *i = mpc_input_new_file(filename, file);
  x = mpc_parse_input(i, p, r);
  mpc_input_delete(i);
  return x;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
callq 0x5de1
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4090
movl %eax, %ebx
movq %r15, %rdi
callq 0x5c78
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_parse_pipe
int mpc_parse_pipe(const char *filename, FILE *pipe, mpc_parser_t *p, mpc_result_t *r) {
  int x;
  mpc_input_t *i = mpc_input_new_pipe(filename, pipe);
  x = mpc_parse_input(i, p, r);
  mpc_input_delete(i);
  return x;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
callq 0x5ea9
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4090
movl %eax, %ebx
movq %r15, %rdi
callq 0x5c78
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_parse_contents
int mpc_parse_contents(const char *filename, mpc_parser_t *p, mpc_result_t *r) {

  FILE *f = fopen(filename, "rb");
  int res;

  if (f == NULL) {
    r->output = NULL;
    r->error = mpc_err_file(filename, "Unable to open file!");
    return 0;
  }

  res = mpc_parse_file(filename, f, p, r);
  fclose(f);
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x83ff(%rip), %rsi      # 0xe355
callq 0x4470
testq %rax, %rax
je 0x5f95
movq %rax, %r14
movq %r12, %rdi
movq %rax, %rsi
callq 0x5de1
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4090
movl %eax, %ebx
movq %r12, %rdi
callq 0x5c78
movq %r14, %rdi
callq 0x4120
movl %ebx, %eax
jmp 0x5fa9
movq $0x0, (%rbx)
movq %r12, %rdi
callq 0x5fb5
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_delete
void mpc_delete(mpc_parser_t *p) {
  if (p->retained) {

    if (p->type != MPC_TYPE_UNDEFINED) {
      mpc_undefine_unretained(p, 0);
    }

    free(p->name);
    free(p);

  } else {
    mpc_undefine_unretained(p, 0);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x31(%rdi)
je 0x6062
cmpb $0x0, 0x30(%rbx)
je 0x6051
movq %rbx, %rdi
xorl %esi, %esi
callq 0x606a
movq (%rbx), %rdi
callq 0x4580
movq %rbx, %rdi
popq %rbx
jmp 0x4580
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x606a
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_undefine_unretained
static void mpc_undefine_unretained(mpc_parser_t *p, int force) {

  if (p->retained && !force) { return; }

  switch (p->type) {

    case MPC_TYPE_FAIL: free(p->data.fail.m); break;

    case MPC_TYPE_ONEOF:
    case MPC_TYPE_NONEOF:
    case MPC_TYPE_STRING:
      free(p->data.string.x);
      break;

    case MPC_TYPE_APPLY:    mpc_undefine_unretained(p->data.apply.x, 0);    break;
    case MPC_TYPE_APPLY_TO: mpc_undefine_unretained(p->data.apply_to.x, 0); break;
    case MPC_TYPE_PREDICT:  mpc_undefine_unretained(p->data.predict.x, 0);  break;

    case MPC_TYPE_MAYBE:
    case MPC_TYPE_NOT:
      mpc_undefine_unretained(p->data.not.x, 0);
      break;

    case MPC_TYPE_EXPECT:
      mpc_undefine_unretained(p->data.expect.x, 0);
      free(p->data.expect.m);
      break;

    case MPC_TYPE_MANY:
    case MPC_TYPE_MANY1:
    case MPC_TYPE_COUNT:
      mpc_undefine_unretained(p->data.repeat.x, 0);
      break;

    case MPC_TYPE_SEPBY1:
      mpc_undefine_unretained(p->data.sepby1.x, 0);
      mpc_undefine_unretained(p->data.sepby1.sep, 0);
      break;

    case MPC_TYPE_OR:  mpc_undefine_or(p);  break;
    case MPC_TYPE_AND: mpc_undefine_and(p); break;

    case MPC_TYPE_CHECK:
      mpc_undefine_unretained(p->data.check.x, 0);
      free(p->data.check.e);
      break;

    case MPC_TYPE_CHECK_WITH:
      mpc_undefine_unretained(p->data.check_with.x, 0);
      free(p->data.check_with.e);
      break;

    default: break;
  }

  if (!force) {
    free(p->name);
    free(p);
  }

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
jne 0x6081
cmpb $0x0, 0x31(%rbx)
jne 0x615d
movzbl 0x30(%rbx), %eax
addl $-0x2, %eax
cmpl $0x1b, %eax
ja 0x6159
leaq 0x8018(%rip), %rcx      # 0xe0b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
jmp 0x6112
movq 0x8(%rbx), %rdi
jmp 0x6154
movq 0x18(%rbx), %rdi
jmp 0x6112
cmpl $0x0, 0x8(%rbx)
jle 0x60da
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
xorl %esi, %esi
callq 0x606a
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x60bf
movq 0x18(%rbx), %rdi
callq 0x4580
jmp 0x60f0
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0x606a
movq 0x20(%rbx), %rdi
jmp 0x6154
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0x606a
jmp 0x6150
movq 0x18(%rbx), %rdi
xorl %esi, %esi
callq 0x606a
movq 0x20(%rbx), %rdi
xorl %esi, %esi
callq 0x606a
jmp 0x6159
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0x606a
movq 0x28(%rbx), %rdi
jmp 0x6154
cmpl $0x0, 0x8(%rbx)
jle 0x6150
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
xorl %esi, %esi
callq 0x606a
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x6135
movq 0x10(%rbx), %rdi
callq 0x4580
testl %ebp, %ebp
je 0x6162
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rdi
callq 0x4580
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4580
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_new
mpc_parser_t *mpc_new(const char *name) {
  mpc_parser_t *p = mpc_undefined();
  p->retained = 1;
  p->name = realloc(p->name, strlen(name) + 1);
  strcpy(p->name, name);
  return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq %rax, %r14
movb $0x1, 0x31(%rax)
movq %rbx, %rdi
callq 0x4130
leaq 0x1(%rax), %rdi
callq 0x43a0
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_define
mpc_parser_t *mpc_define(mpc_parser_t *p, mpc_parser_t *a) {

  if (p->retained) {
    p->type = a->type;
    p->data = a->data;
  } else {
    mpc_parser_t *a2 = mpc_failf("Attempt to assign to Unretained Parser!");
    p->type = a2->type;
    p->data = a2->data;
    free(a2);
  }

  free(a);
  return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x31(%rdi)
je 0x645e
movb 0x30(%r14), %al
movb %al, 0x30(%rbx)
movups 0x8(%r14), %xmm0
movups 0x18(%r14), %xmm1
movups %xmm0, 0x8(%rbx)
movups %xmm1, 0x18(%rbx)
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
jmp 0x6492
leaq 0x7f08(%rip), %rdi      # 0xe36d
xorl %eax, %eax
callq 0x4240
movb 0x30(%rax), %cl
movb %cl, 0x30(%rbx)
movq 0x28(%rax), %rcx
movq %rcx, 0x28(%rbx)
movups 0x8(%rax), %xmm0
movups 0x18(%rax), %xmm1
movups %xmm1, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
movq %rax, %rdi
callq 0x4580
movq %r14, %rdi
callq 0x4580
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_failf
mpc_parser_t *mpc_failf(const char *fmt, ...) {

  va_list va;
  char *buffer;

  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_FAIL;

  va_start(va, fmt);
  buffer = malloc(2048);
  if (!buffer) {
    return NULL;
  }
  vsprintf(buffer, fmt, va);
  va_end(va);

  buffer = realloc(buffer, strlen(buffer) + 1);
  p->data.fail.m = buffer;
  return p;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x6508
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq %rax, %rbx
movb $0x2, 0x30(%rax)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movl $0x800, %edi            # imm = 0x800
callq 0x43a0
testq %rax, %rax
je 0x6578
movq %rax, %r15
movq %rsp, %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x4440
movq %r15, %rdi
callq 0x4130
leaq 0x1(%rax), %rsi
movq %r15, %rdi
callq 0x43f0
movq %rax, 0x8(%rbx)
jmp 0x657a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_cleanup
void mpc_cleanup(int n, ...) {
  int i;
  mpc_parser_t **list = malloc(sizeof(mpc_parser_t*) * n);

  va_list va;
  va_start(va, n);
  for (i = 0; i < n; i++) { list[i] = va_arg(va, mpc_parser_t*); }
  for (i = 0; i < n; i++) { mpc_undefine(list[i]); }
  for (i = 0; i < n; i++) { mpc_delete(list[i]); }
  va_end(va);

  free(list);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movl %edi, %ebp
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x65ef
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movslq %edi, %r15
leaq (,%r15,8), %rdi
callq 0x43a0
movq %rax, %rbx
movq %r14, 0x10(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
testl %r15d, %r15d
jle 0x66a6
movl (%rsp), %eax
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rsi
movl %ebp, %r15d
xorl %edx, %edx
cmpl $0x28, %eax
ja 0x664e
movq %rsi, %rdi
movl %eax, %esi
addq %rcx, %rsi
addl $0x8, %eax
movl %eax, (%rsp)
jmp 0x6657
leaq 0x8(%rsi), %rdi
movq %rdi, 0x8(%rsp)
movq (%rsi), %rsi
movq %rsi, (%rbx,%rdx,8)
incq %rdx
movq %rdi, %rsi
cmpq %rdx, %r15
jne 0x6639
testl %ebp, %ebp
jle 0x66a6
xorl %r12d, %r12d
movq (%rbx,%r12,8), %r14
movq %r14, %rdi
movl $0x1, %esi
callq 0x606a
movb $0x0, 0x30(%r14)
incq %r12
cmpq %r12, %r15
jne 0x6670
testl %ebp, %ebp
jle 0x66a6
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
callq 0x4588
incq %r14
cmpq %r14, %r15
jne 0x6695
movq %rbx, %rdi
callq 0x4580
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_fail
mpc_parser_t *mpc_fail(const char *m) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_FAIL;
  p->data.fail.m = malloc(strlen(m) + 1);
  strcpy(p->data.fail.m, m);
  return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq %rax, %r14
movb $0x2, 0x30(%rax)
movq %rbx, %rdi
callq 0x4130
leaq 0x1(%rax), %rdi
callq 0x43a0
movq %rax, 0x8(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_lift_val
mpc_parser_t *mpc_lift_val(mpc_val_t *x) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_LIFT_VAL;
  p->data.lift.x = x;
  return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movb $0x4, 0x30(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_lift
mpc_parser_t *mpc_lift(mpc_ctor_t lf) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_LIFT;
  p->data.lift.lf = lf;
  return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movb $0x3, 0x30(%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_anchor
mpc_parser_t *mpc_anchor(int(*f)(char,char)) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_ANCHOR;
  p->data.anchor.f = f;
  return mpc_expect(p, "anchor");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movb $0x6, 0x30(%rax)
movq %rbx, 0x8(%rax)
leaq 0x7c1d(%rip), %rsi      # 0xe395
movq %rax, %rdi
popq %rbx
jmp 0x4520
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_expect
mpc_parser_t *mpc_expect(mpc_parser_t *a, const char *expected) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_EXPECT;
  p->data.expect.x = a;
  p->data.expect.m = malloc(strlen(expected) + 1);
  strcpy(p->data.expect.m, expected);
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq %rax, %r15
movb $0x5, 0x30(%rax)
movq %r14, 0x8(%rax)
movq %rbx, %rdi
callq 0x4130
leaq 0x1(%rax), %rdi
callq 0x43a0
movq %rax, 0x10(%r15)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_expectf
mpc_parser_t *mpc_expectf(mpc_parser_t *a, const char *fmt, ...) {
  va_list va;
  char *buffer;

  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_EXPECT;

  va_start(va, fmt);
  buffer = malloc(2048);
  if (!buffer) {
    return NULL;
  }
  vsprintf(buffer, fmt, va);
  va_end(va);

  buffer = realloc(buffer, strlen(buffer) + 1);
  p->data.expect.x = a;
  p->data.expect.m = buffer;
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %rdx, 0x10(%r12)
movq %rcx, 0x18(%r12)
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0x684d
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq %rax, %r14
movb $0x5, 0x30(%rax)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r12, 0x10(%rsp)
movl $0x800, %edi            # imm = 0x800
callq 0x43a0
testq %rax, %rax
je 0x68c1
movq %rax, %r12
movq %rsp, %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x4440
movq %r12, %rdi
callq 0x4130
leaq 0x1(%rax), %rsi
movq %r12, %rdi
callq 0x43f0
movq %rbx, 0x8(%r14)
movq %rax, 0x10(%r14)
jmp 0x68c4
xorl %r14d, %r14d
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_char
mpc_parser_t *mpc_char(char c) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_SINGLE;
  p->data.single.x = c;
  return mpc_expectf(p, "'%c'", c);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movb $0x9, 0x30(%rax)
movb %bl, 0x8(%rax)
leaq 0x7aab(%rip), %rsi      # 0xe3c5
movq %rax, %rdi
movl %ebx, %edx
xorl %eax, %eax
popq %rbx
jmp 0x4290
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_range
mpc_parser_t *mpc_range(char s, char e) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_RANGE;
  p->data.range.x = s;
  p->data.range.y = e;
  return mpc_expectf(p, "character between '%c' and '%c'", s, e);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movb $0xc, 0x30(%rax)
movb %bpl, 0x8(%rax)
movb %bl, 0x9(%rax)
leaq 0x7a5b(%rip), %rsi      # 0xe3aa
movq %rax, %rdi
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4290
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/mpc.c
// Function: mpc_oneof
mpc_parser_t *mpc_oneof(const char *s) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_ONEOF;
  p->data.string.x = malloc(strlen(s) + 1);
  strcpy(p->data.string.x, s);
  return mpc_expectf(p, "one of '%s'", s);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq %rax, %r14
movb $0xa, 0x30(%rax)
movq %rbx, %rdi
callq 0x4130
leaq 0x1(%rax), %rdi
callq 0x43a0
movq %rax, 0x8(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
leaq 0x7a24(%rip), %rsi      # 0xe3cb
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4290