LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/fsio.c
// Function: FSioWriteSector
int FSioWriteSector(
  struct mountedFS *mount,
  unsigned int sector,
  unsigned int size,
  void *buf
)
{
  off_t offset = sector * size;

  if (fseeko(mount->container, offset + mount->skip, SEEK_SET) == 0)
    return fwrite(buf, size, 1, mount->container);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
addq 0x40(%rax), %rsi
xorl %edx, %edx
callq 0x3250
cmpl $0x0, %eax
jne 0x5703
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movl $0x1, %edx
callq 0x32b0
movl %eax, -0x4(%rbp)
jmp 0x570a
movl $0x0, -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/fsio.c
// Function: checkDev
static int checkDev(
  char *dev
)
{
  unsigned int i;

  /*
   * Remove any trailing ':' characters
   */
  while ((strlen(dev) != 0) && (dev[strlen(dev) - 1] == ':'))
    dev[strlen(dev) - 1] = '\0';

  for (i = 0; i < strlen(dev); i++)
    if (!isalpha(dev[i])) {
      fprintf(stderr,
              "%s: Device name contains non-alpha character\n", wds[0]);
      return 0;
    }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3130
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x15(%rbp)
je 0x576c
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3130
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x5775
jmp 0x5797
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3130
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x572c
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3130
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x5813
callq 0x32e0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x5806
movq 0x18813(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
movq 0x19af1(%rip), %rdx     # 0x1f2e0
leaq 0x12a49(%rip), %rsi     # 0x1823f
movb $0x0, %al
callq 0x31c0
movl $0x0, -0x4(%rbp)
jmp 0x581a
jmp 0x5808
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x579e
movl $0x1, -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/fsio.c
// Function: lookupDev
static struct mountedFS *lookupDev(
  char *dev
)
{
  struct mountedFS *fs;

  for (fs = mounts; fs != NULL; fs = fs->next)
    if (strcmp(dev, fs->name) == 0)
      return fs;

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x1aa9d(%rip), %rax     # 0x202e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x587d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x31b0
cmpl $0x0, %eax
jne 0x586e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5885
jmp 0x5870
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5847
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/fsio.c
// Function: lookupFS
static struct FSdef *lookupFS(
  char *fs
)
{
  struct FSdef *filesys;

  for (filesys = fileSystems; filesys != NULL; filesys = filesys->next)
    if (strcmp(fs, filesys->fstype) == 0)
      return filesys;

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x1994d(%rip), %rax     # 0x1f1f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x58dd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x31b0
cmpl $0x0, %eax
jne 0x58ce
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x58e5
jmp 0x58d0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x58a7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/declib.c
// Function: r50Asc
void r50Asc(
  uint16_t value,
  char *outbuf
)
{
  outbuf[2] = rad50[value % 050];
  value /= 050;
  outbuf[1] = rad50[value % 050];
  outbuf[0] = rad50[value / 050];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movzwl -0x2(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x189fb(%rip), %rax     # 0x1e610
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movzwl -0x2(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x189cb(%rip), %rax     # 0x1e610
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movzwl -0x2(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movslq %eax, %rcx
leaq 0x189ab(%rip), %rax     # 0x1e610
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/declib.c
// Function: r50AscNoSpace
void r50AscNoSpace(
  uint16_t value,
  char *outbuf
)
{
  uint16_t value2 = value / 050;

  /*
   * The rad50 representation of ' ' is zero.
   */
  if ((value2 / 050) != 0)
    *outbuf++ = rad50[value2 / 050];
  if ((value2 % 050) != 0)
    *outbuf++ = rad50[value2 % 050];
  if ((value % 050) != 0)
    *outbuf++ = rad50[value % 050];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movzwl -0x2(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
cmpl $0x0, %eax
je 0x5cca
movzwl -0x12(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movslq %eax, %rcx
leaq 0x1895a(%rip), %rax     # 0x1e610
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movzwl -0x12(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x5d05
movzwl -0x12(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x1891f(%rip), %rax     # 0x1e610
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movzwl -0x2(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x5d40
movzwl -0x2(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x188e4(%rip), %rax     # 0x1e610
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/declib.c
// Function: ascR50
uint16_t ascR50(
  char *inbuf
)
{
  uint16_t value;
  char *ptr;

  if ((ptr = strchr(rad50, toupper(*inbuf++))) == NULL)
    ptr = strchr(rad50, '%');

  value = (ptr - rad50) * 03100;

  if ((ptr = strchr(rad50, toupper(*inbuf++))) == NULL)
    ptr = strchr(rad50, '%');

  value += (ptr - rad50) * 050;

  if ((ptr = strchr(rad50, toupper(*inbuf++))) == NULL)
    ptr = strchr(rad50, '%');

  value += ptr - rad50;

  return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %edi
callq 0x30d0
movl %eax, %esi
leaq 0x18894(%rip), %rdi     # 0x1e610
callq 0x3150
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x5da0
leaq 0x1887e(%rip), %rdi     # 0x1e610
movl $0x25, %esi
callq 0x3150
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x18865(%rip), %rcx     # 0x1e610
subq %rcx, %rax
imulq $0x640, %rax, %rax      # imm = 0x640
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %edi
callq 0x30d0
movl %eax, %esi
leaq 0x18837(%rip), %rdi     # 0x1e610
callq 0x3150
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x5dfd
leaq 0x18821(%rip), %rdi     # 0x1e610
movl $0x25, %esi
callq 0x3150
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x18808(%rip), %rcx     # 0x1e610
subq %rcx, %rax
imulq $0x28, %rax, %rcx
movzwl -0xa(%rbp), %eax
addq %rcx, %rax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %edi
callq 0x30d0
movl %eax, %esi
leaq 0x187d6(%rip), %rdi     # 0x1e610
callq 0x3150
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x5e5e
leaq 0x187c0(%rip), %rdi     # 0x1e610
movl $0x25, %esi
callq 0x3150
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
leaq 0x187a7(%rip), %rax     # 0x1e610
subq %rax, %rcx
movzwl -0xa(%rbp), %eax
addq %rcx, %rax
movw %ax, -0xa(%rbp)
movw -0xa(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/declib.c
// Function: dos11Date
char *dos11Date(
  uint16_t value,
  char *buf
)
{
  unsigned short year, doyr, leapyr;
  unsigned short *table;

  /*
   * The DOS/BATCH-11 date format is documented as having 3 reserved bit.
   * Version 9.20C (and later?) makes use of these bits to allow dates up
   * to 2035. Unfortunately, the date input routine only allows up to 1999!
   */
  year = 1970 + value / 1000;
  doyr = value % 1000;
  leapyr = ((year % 4) == 0) && (year != 2000);

  table = leapyr ? mnthl : mnth;

  /*
   * Check for valid day of year.
   */
  if (doyr < (leapyr ? 366 : 365)) {
    int i = 0;

    while (doyr > table[i])
      doyr -= table[i++];

    sprintf(buf, "%2d-%s-%4d", doyr, month[i], year);
  } else strcpy(buf, "xx-yyy-xxxx");
  return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movzwl -0x2(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
addl $0x7b2, %eax            # imm = 0x7B2
movw %ax, -0x12(%rbp)
movzwl -0x2(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movw %dx, %ax
movw %ax, -0x14(%rbp)
movzwl -0x12(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl $0x0, %edx
movb %al, -0x25(%rbp)
jne 0x5ef0
movzwl -0x12(%rbp), %eax
cmpl $0x7d0, %eax            # imm = 0x7D0
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, -0x16(%rbp)
movzwl -0x16(%rbp), %edx
leaq 0x18799(%rip), %rax     # 0x1e6a0
leaq 0x187b2(%rip), %rcx     # 0x1e6c0
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x20(%rbp)
movzwl -0x14(%rbp), %eax
movzwl -0x16(%rbp), %esi
movl $0x16d, %ecx            # imm = 0x16D
movl $0x16e, %edx            # imm = 0x16E
cmpl $0x0, %esi
cmovnel %edx, %ecx
cmpl %ecx, %eax
jge 0x5f9e
movl $0x0, -0x24(%rbp)
movzwl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jle 0x5f72
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
movzwl -0x14(%rbp), %eax
subl %ecx, %eax
movw %ax, -0x14(%rbp)
jmp 0x5f3c
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %edx
movslq -0x24(%rbp), %rcx
leaq 0x186bb(%rip), %rax     # 0x1e640
movq (%rax,%rcx,8), %rcx
movzwl -0x12(%rbp), %r8d
leaq 0x138dd(%rip), %rsi     # 0x19872
movb $0x0, %al
callq 0x3290
jmp 0x5fae
movq -0x10(%rbp), %rdi
leaq 0x138d4(%rip), %rsi     # 0x1987d
callq 0x30b0
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/tape.c
// Function: tapeReadRecordLength
uint32_t tapeReadRecordLength(
  FILE *container
)
{
  off_t pos = ftello(container);
  uint32_t meta, bc, erflag;

  if (fread(&meta, sizeof(meta), 1, container) != 1)
    return ST_FAIL;

  bc = le32toh(meta);

  switch (bc) {
    case ST_EOM:
    case ST_TM:
      return bc;

    default:
      erflag = bc & ST_ERROR;
      bc &= ST_LENGTH;

      /*
       * Now position the file after this record.
       */
      pos += RECLEN(bc) + (2 * sizeof(meta));
      if (fseeko(container, pos, SEEK_SET) != 0)
        return ST_FAIL;

      return erflag | bc;
  }
  return ST_FAIL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x1c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x30f0
cmpq $0x1, %rax
je 0x62cf
movl $0xfefefefe, -0x4(%rbp) # imm = 0xFEFEFEFE
jmp 0x6341
movl -0x1c(%rbp), %edi
callq 0x6200
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
incl %eax
subl $0x1, %eax
ja 0x62ee
jmp 0x62e6
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6341
movl -0x20(%rbp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
andl $-0x2, %eax
movl %eax, %eax
addq $0x8, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3250
cmpl $0x0, %eax
je 0x6338
movl $0xfefefefe, -0x4(%rbp) # imm = 0xFEFEFEFE
jmp 0x6341
movl -0x24(%rbp), %eax
orl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/tape.c
// Function: tapeReadRecordLengthReverse
uint32_t tapeReadRecordLengthReverse(
  FILE *container
)
{
  uint32_t meta, bc, erflag;
  off_t delta;

  if ((fseeko(container, -sizeof(meta), SEEK_CUR) != 0) ||
      (fread(&meta, sizeof(meta), 1, container) != 1))
    return ST_FAIL;

  bc = le32toh(meta);

  switch (bc) {
    case ST_EOM:
    case ST_TM:
      if (fseeko(container, -sizeof(meta), SEEK_CUR) != 0)
        return ST_FAIL;
      return bc;

    default:
      erflag = bc & ST_ERROR;
      bc &= ST_LENGTH;

      /*
       * Now position the file before this record.
       */
      delta = RECLEN(bc) + (2 * sizeof(meta));
      if (fseeko(container, -delta, SEEK_CUR) != 0)
        return ST_FAIL;

      return erflag | bc;
  }
  return ST_FAIL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq $-0x4, %rsi
movl $0x1, %edx
callq 0x3250
cmpl $0x0, %eax
jne 0x63b3
movq -0x10(%rbp), %rcx
leaq -0x14(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x30f0
cmpq $0x1, %rax
je 0x63bf
movl $0xfefefefe, -0x4(%rbp) # imm = 0xFEFEFEFE
jmp 0x6457
movl -0x14(%rbp), %edi
callq 0x6200
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
incl %eax
subl $0x1, %eax
ja 0x6401
jmp 0x63d6
movq -0x10(%rbp), %rdi
movq $-0x4, %rsi
movl $0x1, %edx
callq 0x3250
cmpl $0x0, %eax
je 0x63f9
movl $0xfefefefe, -0x4(%rbp) # imm = 0xFEFEFEFE
jmp 0x6457
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6457
movl -0x18(%rbp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
andl $-0x2, %eax
movl %eax, %eax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
subq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x3250
cmpl $0x0, %eax
je 0x644e
movl $0xfefefefe, -0x4(%rbp) # imm = 0xFEFEFEFE
jmp 0x6457
movl -0x1c(%rbp), %eax
orl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/tape.c
// Function: tapePeekRecordLength
uint32_t tapePeekRecordLength(
  FILE *container
)
{
  off_t pos = ftello(container);
  uint32_t meta;

  if ((fread(&meta, sizeof(meta), 1, container) != 1) ||
      (fseeko(container, pos, SEEK_SET) != 0))
    return ST_FAIL;

  return le32toh(meta);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x1c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x30f0
cmpq $0x1, %rax
jne 0x64aa
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3250
cmpl $0x0, %eax
je 0x64b3
movl $0xfefefefe, -0x4(%rbp) # imm = 0xFEFEFEFE
jmp 0x64be
movl -0x1c(%rbp), %edi
callq 0x6200
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/tape.c
// Function: tapeReadRecord
uint32_t tapeReadRecord(
  FILE *container,
  void *buf,
  int len
)
{
  off_t pos = ftello(container);
  uint32_t meta, bc, erflag, length;

  if (fread(&meta, sizeof(meta), 1, container) != 1)
    return ST_FAIL;

  bc = le32toh(meta);

  switch (bc) {
    case ST_EOM:
    case ST_TM:
      return bc;

    default:
      erflag = bc & ST_ERROR;
      bc &= ST_LENGTH;

      length = (uint32_t)len;
      if (bc < length)
        length = bc;

      if (fread(buf, sizeof(uint8_t), length, container) != length)
        return ST_FAIL;

      /*
       * Now position the file after this record.
       */
      pos += RECLEN(bc) + (2 * sizeof(meta));
      if (fseeko(container, pos, SEEK_SET) != 0)
        return ST_FAIL;

      return erflag | length;
  }
  return ST_FAIL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30c0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x2c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x30f0
cmpq $0x1, %rax
je 0x6519
movl $0xfefefefe, -0x4(%rbp) # imm = 0xFEFEFEFE
jmp 0x65ca
movl -0x2c(%rbp), %edi
callq 0x6200
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
incl %eax
subl $0x1, %eax
ja 0x653b
jmp 0x6530
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x65ca
movl -0x30(%rbp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x38(%rbp), %eax
jae 0x6565
movl -0x30(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl -0x38(%rbp), %eax
movl %eax, %edx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x30f0
movl -0x38(%rbp), %ecx
cmpq %rcx, %rax
je 0x658d
movl $0xfefefefe, -0x4(%rbp) # imm = 0xFEFEFEFE
jmp 0x65ca
movl -0x30(%rbp), %eax
addl $0x1, %eax
andl $-0x2, %eax
movl %eax, %eax
addq $0x8, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x3250
cmpl $0x0, %eax
je 0x65c1
movl $0xfefefefe, -0x4(%rbp) # imm = 0xFEFEFEFE
jmp 0x65ca
movl -0x34(%rbp), %eax
orl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/tape.c
// Function: tapeWriteRecord
int tapeWriteRecord(
  FILE *container,
  void *buf,
  int len
)
{
  uint32_t meta = htole16(len);
  int datalen = (len + 1) & ~1;

  if ((fwrite(&meta, sizeof(meta), 1, container) != 1) ||
      (fwrite(buf, datalen, 1, container) != 1) ||
      (fwrite(&meta, sizeof(meta), 1, container) != 1))
    return 0;

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movzwl %ax, %edi
callq 0x6680
movzwl %ax, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
andl $-0x2, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x20(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x32b0
cmpq $0x1, %rax
jne 0x6666
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
movq -0x10(%rbp), %rcx
movl $0x1, %edx
callq 0x32b0
cmpq $0x1, %rax
jne 0x6666
movq -0x10(%rbp), %rcx
leaq -0x20(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x32b0
cmpq $0x1, %rax
je 0x666f
movl $0x0, -0x4(%rbp)
jmp 0x6676
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/tape.c
// Function: tapeWriteEOM
int tapeWriteEOM(
  FILE *container,
  int backup
)
{
  uint32_t eom = htole32(ST_EOM);

  if (fwrite(&eom, sizeof(eom), 1, container) != 1)
    return 0;

  if (backup)
    if (fseeko(container, -sizeof(eom), SEEK_CUR) != 0)
      return 0;

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x6200
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x32b0
cmpq $0x1, %rax
je 0x66e2
movl $0x0, -0x4(%rbp)
jmp 0x6714
cmpl $0x0, -0x14(%rbp)
je 0x670d
movq -0x10(%rbp), %rdi
movq $-0x4, %rsi
movl $0x1, %edx
callq 0x3250
cmpl $0x0, %eax
je 0x670b
movl $0x0, -0x4(%rbp)
jmp 0x6714
jmp 0x670d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/tape.c
// Function: tapeWriteTM
int tapeWriteTM(
  FILE *container
)
{
  uint32_t tm = htole32(ST_TM);

  if (fwrite(&tm, sizeof(tm), 1, container) != 1)
    return 0;

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
xorl %edi, %edi
callq 0x6200
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x14(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x32b0
cmpq $0x1, %rax
je 0x675c
movl $0x0, -0x4(%rbp)
jmp 0x6763
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/tape.c
// Function: tapeSkipForward
int tapeSkipForward(
  FILE *container,
  unsigned long count
)
{
  unsigned long i;
  uint32_t bc;

  for (i = 0; i < count; i++) {
    /*
     * Peek at the next record. If it's a tape mark or end-of-media there
     * are not more files to skip.
     */
    switch (tapePeekRecordLength(container)) {
      case ST_FAIL:
        return 0;

      case ST_TM:
      case ST_EOM:
        return 1;
    }
    /*
     * Skip forward over 1 file.
     */
    do {
      switch (bc = tapeReadRecordLength(container)) {
        case ST_FAIL:
          return 0;

        case ST_EOM:
          if (fseeko(container, -sizeof(uint32_t), SEEK_CUR) != 0)
            return 0;
          break;
      }
    } while ((bc != ST_TM) && (bc != ST_EOM));
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x69e6
movq -0x10(%rbp), %rdi
callq 0x6460
movl %eax, %ecx
movl %ecx, -0x28(%rbp)
subl $0xfefefefe, %eax       # imm = 0xFEFEFEFE
je 0x6949
jmp 0x693d
movl -0x28(%rbp), %eax
incl %eax
subl $0x2, %eax
jb 0x6955
jmp 0x6961
movl $0x0, -0x4(%rbp)
jmp 0x69ed
movl $0x1, -0x4(%rbp)
jmp 0x69ed
jmp 0x6963
movq -0x10(%rbp), %rdi
callq 0x6290
movl %eax, -0x24(%rbp)
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
subl $0xfefefefe, %eax       # imm = 0xFEFEFEFE
je 0x6987
jmp 0x697d
movl -0x2c(%rbp), %eax
subl $-0x1, %eax
je 0x6990
jmp 0x69b5
movl $0x0, -0x4(%rbp)
jmp 0x69ed
movq -0x10(%rbp), %rdi
movq $-0x4, %rsi
movl $0x1, %edx
callq 0x3250
cmpl $0x0, %eax
je 0x69b3
movl $0x0, -0x4(%rbp)
jmp 0x69ed
jmp 0x69b5
jmp 0x69b7
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0x2d(%rbp)
je 0x69cc
cmpl $-0x1, -0x24(%rbp)
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x6963
jmp 0x69d5
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6918
movl $0x1, -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/tape.c
// Function: tapeSkipReverse
int tapeSkipReverse(
  FILE *container,
  unsigned long count
)
{
  unsigned long i;
  uint32_t bc;

  for (i = 0; i < count; i++) {
    /*
     * If we are at beginning-of-tape, there are no more files to skip.
     */
    if (ftello(container) == 0)
      return 1;

    /*
     * If we are not at the beginning of tape, the previous record should
     * be a tape mark.
     */
    if (tapeReadRecordLengthReverse(container) != ST_TM)
      return 0;

    /*
     * Now skip over the remainder of the file.
     */
    do {
      if ((bc = tapeReadRecordLengthReverse(container)) == ST_FAIL)
        return 0;
    } while ((bc != ST_TM) && (ftello(container) != 0));

    /*
     * Skip over the tape mark since it marks the end of the previous file.
     */
    if (bc == ST_TM) {
      if (fseeko(container, sizeof(uint32_t), SEEK_CUR) != 0)
        return 0;
    }
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x6adc
movq -0x10(%rbp), %rdi
callq 0x30c0
cmpq $0x0, %rax
jne 0x6a41
movl $0x1, -0x4(%rbp)
jmp 0x6ae3
movq -0x10(%rbp), %rdi
callq 0x6370
cmpl $0x0, %eax
je 0x6a5b
movl $0x0, -0x4(%rbp)
jmp 0x6ae3
jmp 0x6a5d
movq -0x10(%rbp), %rdi
callq 0x6370
movl %eax, -0x24(%rbp)
cmpl $0xfefefefe, %eax       # imm = 0xFEFEFEFE
jne 0x6a79
movl $0x0, -0x4(%rbp)
jmp 0x6ae3
jmp 0x6a7b
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0x25(%rbp)
je 0x6a99
movq -0x10(%rbp), %rdi
callq 0x30c0
cmpq $0x0, %rax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x6a5d
cmpl $0x0, -0x24(%rbp)
jne 0x6ac9
movq -0x10(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x3250
cmpl $0x0, %eax
je 0x6ac7
movl $0x0, -0x4(%rbp)
jmp 0x6ae3
jmp 0x6ac9
jmp 0x6acb
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6a18
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/dos11.c
// Function: dos11DisplayDir
void dos11DisplayDir(
  uint16_t *dir,
  int full
)
{
  char temp[64], creation[16];

  r50Asc(le16toh(dir[UFD_FILENAME]), &temp[0]);
  r50Asc(le16toh(dir[UFD_FILENAME + 1]), &temp[3]);
  if (le16toh(dir[UFD_EXTENSION]) != 0) {
    temp[6] = '.';
    r50Asc(le16toh(dir[UFD_EXTENSION]), &temp[7]);
  } else {
    temp[6] = ' ';
    temp[7] = ' ';
    temp[8] = ' ';
    temp[9] = ' ';
  }

  if (full) {
    sprintf(&temp[10], "  %5u%c    %s   <%03o>",
            le16toh(dir[UFD_FILELENGTH]),
            (le16toh(dir[UFD_CREATION]) & UFD_TYPE) ? 'C' : ' ',
            dos11Date(le16toh(dir[UFD_CREATION]) & UFD_DATE, creation),
            le16toh(dir[UFD_LUP]) & UFD_PROT);
  } else temp[10] ='\0';
  puts(temp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %edi
callq 0x6c50
leaq -0x50(%rbp), %rsi
movzwl %ax, %edi
callq 0x5bf0
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x6c50
leaq -0x50(%rbp), %rsi
addq $0x3, %rsi
movzwl %ax, %edi
callq 0x5bf0
movq -0x8(%rbp), %rax
movzwl 0x4(%rax), %edi
callq 0x6c50
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x6b6f
movb $0x2e, -0x4a(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x4(%rax), %edi
callq 0x6c50
leaq -0x50(%rbp), %rsi
addq $0x7, %rsi
movzwl %ax, %edi
callq 0x5bf0
jmp 0x6b7f
movb $0x20, -0x4a(%rbp)
movb $0x20, -0x49(%rbp)
movb $0x20, -0x48(%rbp)
movb $0x20, -0x47(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x6c2c
leaq -0x50(%rbp), %rax
addq $0xa, %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rax
movzwl 0xc(%rax), %edi
callq 0x6c50
movzwl %ax, %eax
movl %eax, -0x70(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x6(%rax), %edi
callq 0x6c50
movzwl %ax, %edx
andl $0x8000, %edx           # imm = 0x8000
movl $0x20, %eax
movl $0x43, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x6c(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x6(%rax), %edi
callq 0x6c50
movzwl %ax, %eax
andl $0x7fff, %eax           # imm = 0x7FFF
leaq -0x60(%rbp), %rsi
movzwl %ax, %edi
callq 0x5e90
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x10(%rax), %edi
callq 0x6c50
movq -0x78(%rbp), %rdi
movl -0x70(%rbp), %edx
movl -0x6c(%rbp), %ecx
movq -0x68(%rbp), %r8
movzwl %ax, %r9d
andl $0xff, %r9d
leaq 0x12ca7(%rip), %rsi     # 0x198ca
movb $0x0, %al
callq 0x3290
jmp 0x6c30
movb $0x0, -0x46(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x30e0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/dos11.c
// Function: dos11ReadBlock
int dos11ReadBlock(
  struct mountedFS *mount,
  unsigned int block,
  void *buf
)
{
  struct DOS11data *data = &mount->dos11data;
  void *buffer = buf == NULL ? data->buf : buf;
  int status;

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

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

  status = FSioReadBlock(mount, block, buffer);

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

  return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x73b6
movq -0x28(%rbp), %rax
addq $0x50c, %rax            # imm = 0x50C
movq %rax, -0x40(%rbp)
jmp 0x73be
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x7446
movq 0x16c20(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
leaq 0x1256e(%rip), %rsi     # 0x1995b
movb $0x0, %al
callq 0x31c0
leaq 0x17ded(%rip), %rax     # 0x1f1e8
cmpq $0x0, (%rax)
je 0x743a
leaq 0x17de0(%rip), %rax     # 0x1f1e8
movq (%rax), %rax
movq 0x16bae(%rip), %rcx     # 0x1dfc0
cmpq (%rcx), %rax
je 0x743a
leaq 0x17dca(%rip), %rax     # 0x1f1e8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
leaq 0x12528(%rip), %rsi     # 0x1995b
movb $0x0, %al
callq 0x31c0
movl $0x0, -0x4(%rbp)
jmp 0x74fd
movq -0x10(%rbp), %rax
movzwl 0x30(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x7479
leaq 0x17d8b(%rip), %rax     # 0x1f1e8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movl -0x14(%rbp), %ecx
leaq 0x1251e(%rip), %rsi     # 0x19990
movb $0x0, %al
callq 0x31c0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x5520
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x74f7
movq 0x16b5f(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
leaq 0x1250e(%rip), %rsi     # 0x199b9
movb $0x0, %al
callq 0x31c0
leaq 0x17d2f(%rip), %rax     # 0x1f1e8
cmpq $0x0, (%rax)
je 0x74f5
leaq 0x17d22(%rip), %rax     # 0x1f1e8
movq (%rax), %rax
movq 0x16af0(%rip), %rcx     # 0x1dfc0
cmpq (%rcx), %rax
je 0x74f5
leaq 0x17d0c(%rip), %rax     # 0x1f1e8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
leaq 0x124cb(%rip), %rsi     # 0x199b9
movb $0x0, %al
callq 0x31c0
jmp 0x74f7
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/dos11.c
// Function: dos11XtndDirectory
uint16_t dos11XtndDirectory(
  struct mountedFS *mount
)
{
  uint16_t buf[512], ufdblk;

  memset(buf, 0, sizeof(buf));

  if ((ufdblk = bitmapAllocBlock(mount)) != 0) {
    if (dos11WriteBlock(mount, ufdblk, buf) == 0)
      return 0;

    if (bitmapFlush(mount) == 0)
      return 0;
  }
  return ufdblk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x10(%rbp)
leaq -0x410(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x3170
movq -0x10(%rbp), %rdi
callq 0x80a0
movw %ax, -0x412(%rbp)
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x7586
movq -0x10(%rbp), %rdi
movzwl -0x412(%rbp), %esi
leaq -0x410(%rbp), %rdx
callq 0x75a0
cmpl $0x0, %eax
jne 0x756e
movw $0x0, -0x2(%rbp)
jmp 0x7591
movq -0x10(%rbp), %rdi
callq 0x8280
cmpl $0x0, %eax
jne 0x7584
movw $0x0, -0x2(%rbp)
jmp 0x7591
jmp 0x7586
movw -0x412(%rbp), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/dos11.c
// Function: dos11WriteBlock
int dos11WriteBlock(
  struct mountedFS *mount,
  unsigned int block,
  void *buf
)
{
  struct DOS11data *data = &mount->dos11data;
  void *buffer = buf == NULL ? data->buf : buf;
  int status;

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

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

  status = FSioWriteBlock(mount, block, buffer);

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

  return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x75d6
movq -0x28(%rbp), %rax
addq $0x50c, %rax            # imm = 0x50C
movq %rax, -0x40(%rbp)
jmp 0x75de
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x7666
movq 0x16a00(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
leaq 0x123bf(%rip), %rsi     # 0x199cc
movb $0x0, %al
callq 0x31c0
leaq 0x17bcd(%rip), %rax     # 0x1f1e8
cmpq $0x0, (%rax)
je 0x765a
leaq 0x17bc0(%rip), %rax     # 0x1f1e8
movq (%rax), %rax
movq 0x1698e(%rip), %rcx     # 0x1dfc0
cmpq (%rcx), %rax
je 0x765a
leaq 0x17baa(%rip), %rax     # 0x1f1e8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
leaq 0x12379(%rip), %rsi     # 0x199cc
movb $0x0, %al
callq 0x31c0
movl $0x0, -0x4(%rbp)
jmp 0x771d
movq -0x10(%rbp), %rax
movzwl 0x30(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x7699
leaq 0x17b6b(%rip), %rax     # 0x1f1e8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movl -0x14(%rbp), %ecx
leaq 0x12370(%rip), %rsi     # 0x19a02
movb $0x0, %al
callq 0x31c0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x55a0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x7717
movq 0x1693f(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
leaq 0x122ee(%rip), %rsi     # 0x199b9
movb $0x0, %al
callq 0x31c0
leaq 0x17b0f(%rip), %rax     # 0x1f1e8
cmpq $0x0, (%rax)
je 0x7715
leaq 0x17b02(%rip), %rax     # 0x1f1e8
movq (%rax), %rax
movq 0x168d0(%rip), %rcx     # 0x1dfc0
cmpq (%rcx), %rax
je 0x7715
leaq 0x17aec(%rip), %rax     # 0x1f1e8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
leaq 0x122ab(%rip), %rsi     # 0x199b9
movb $0x0, %al
callq 0x31c0
jmp 0x7717
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/dos11.c
// Function: bitmapFlush
static int bitmapFlush(
  struct mountedFS *mount
)
{
  struct DOS11data *data = &mount->dos11data;

  if (data->bmdirty != 0) {
    if (dos11WriteBlock(mount, data->bmblk[data->bmindex], data->bmbuf) == 0)
      return 0;
    data->bmdirty = 0;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x10a(%rax), %eax
cmpl $0x0, %eax
je 0x82e9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl 0x106(%rcx), %ecx
movzwl 0x6(%rax,%rcx,2), %esi
movq -0x18(%rbp), %rdx
addq $0x10c, %rdx            # imm = 0x10C
callq 0x75a0
cmpl $0x0, %eax
jne 0x82de
movl $0x0, -0x4(%rbp)
jmp 0x82f0
movq -0x18(%rbp), %rax
movb $0x0, 0x10a(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/dos11.c
// Function: dos11WriteFile
size_t dos11WriteFile(
  void *filep,
  void *buf,
  size_t buflen
)
{
  struct dos11OpenFile *file = filep;
  char *bufw = buf;

  if (SWISSET('a')) {
    size_t count = 0;

    /*
     * Write a line, terminated by <CRLF>, to the open file.
     */
    while (buflen != 0) {
      char ch;

      ch = bufw[count++] & 0177;
      buflen--;
      if (dos11WriteBytes(file, &ch, 1) == 0)
        break;
    }
    return count;
  }
  return dos11WriteBytes(file, bufw, buflen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x162ed(%rip), %rax     # 0x1f1f8
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x8f72
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8f68
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movsbl (%rax,%rcx), %eax
andl $0x7f, %eax
movb %al, -0x39(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x39(%rbp), %rsi
movl $0x1, %edx
callq 0x8ad0
cmpl $0x0, %eax
jne 0x8f66
jmp 0x8f68
jmp 0x8f1d
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f8b
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
movl %eax, %edx
callq 0x8ad0
cltq
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/dos11.c
// Function: dos11OpenFileR
static void *dos11OpenFileR(
  struct mountedFS *mount,
  uint8_t UNUSED(unit),
  char *fname
)
{
  struct DOS11data *data = &mount->dos11data;
  struct dos11OpenFile *file;
  struct dos11FileSpec spec;
  uint8_t user = data->user;
  uint8_t group = data->group;

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

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

    if (dos11LookupFile(mount, &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 -0x10(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb 0x90d(%rax), %al
movb %al, -0x3b(%rbp)
movq -0x28(%rbp), %rax
movb 0x90c(%rax), %al
movb %al, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
movb -0x3b(%rbp), %al
leaq -0x3a(%rbp), %rsi
xorl %r8d, %r8d
movzbl %al, %edx
movzbl -0x3c(%rbp), %ecx
callq 0x8300
cmpl $0x0, %eax
jne 0xa954
movq 0x136c6(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0xf5bc(%rip), %rsi      # 0x19efc
movb $0x0, %al
callq 0x31c0
movq $0x0, -0x8(%rbp)
jmp 0xa9e6
movl $0x38, %edi
callq 0x3200
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xa9de
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x3170
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq -0x3a(%rbp), %rsi
callq 0x7a70
cmpl $0x0, %eax
je 0xa9c9
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3200
movq -0x30(%rbp), %rcx
movq %rax, 0x28(%rcx)
cmpq $0x0, %rax
jne 0xa9bc
movq -0x30(%rbp), %rdi
callq 0x3040
movq $0x0, -0x8(%rbp)
jmp 0xa9e6
movq -0x30(%rbp), %rax
movl $0x0, 0x18(%rax)
jmp 0xa9dc
movq -0x30(%rbp), %rdi
callq 0x3040
movq $0x0, -0x8(%rbp)
jmp 0xa9e6
jmp 0xa9de
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/dos11.c
// Function: dos11CloseFile
static void dos11CloseFile(
  void *filep
)
{
  struct dos11OpenFile *file = filep;
  struct mountedFS *mount = file->mount;

  if (file->mode == M_WR) {
    uint16_t start = (le16toh(file->creation) & UFD_TYPE) == 0 ? 2 : 0;

    /*
     * Flush any partial buffer, pending bitmap updates and update the
     * directory entry.
     */
    if (((le16toh(file->creation) & UFD_TYPE) == 0) ||
        (file->current == le16toh(file->last)))
      file->nfb = htole16(file->nab);
    else file->nfb = htole16(mount->blocksz);

    if (file->nab != start)
      dos11WriteBlock(mount, file->current, file->buffer);
    bitmapFlush(mount);
    dos11UpdateFile(mount, file);
  }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jne 0xae38
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %edi
callq 0x6c50
movzwl %ax, %edx
andl $0x8000, %edx           # imm = 0x8000
xorl %eax, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %edi
callq 0x6c50
movzwl %ax, %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0xadc4
movq -0x10(%rbp), %rax
movzwl 0x30(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzwl 0xe(%rax), %edi
callq 0x6c50
movw %ax, %cx
movl -0x20(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jne 0xadde
movq -0x10(%rbp), %rax
movzwl 0x32(%rax), %edi
callq 0x6c50
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x8(%rax)
jmp 0xadf9
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movzwl %ax, %edi
callq 0x6c50
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rax
movzwl 0x32(%rax), %eax
movzwl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
je 0xae22
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl 0x30(%rax), %esi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0x75a0
movq -0x18(%rbp), %rdi
callq 0x8280
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7e90
cmpq $0x0, -0x10(%rbp)
je 0xae60
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xae57
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3040
movq -0x10(%rbp), %rdi
callq 0x3040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/dos11.c
// Function: dos11ReadFile
static size_t dos11ReadFile(
  void *filep,
  void *buf,
  size_t buflen
)
{
  struct dos11OpenFile *file = filep;
  char *bufr = buf;

  if (SWISSET('a')) {
    char ch;
    size_t count = 0;

    /*
     * Read a full or partial line from the open file.
     */
    while ((buflen != 0) && (dos11ReadBytes(file, &ch, 1) == 1)) {
      ch &= 0177;
      bufr[count++] = ch;
      buflen--;
      if (ch == '\n')
        break;
    }
    return count;
  }

  return dos11ReadBytes(file, bufr, buflen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x1435d(%rip), %rax     # 0x1f1f8
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xaf23
movq $0x0, -0x40(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x41(%rbp)
je 0xaed4
movq -0x28(%rbp), %rdi
leaq -0x31(%rbp), %rsi
movl $0x1, %edx
callq 0x8820
cmpl $0x1, %eax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xaedd
jmp 0xaf19
movsbl -0x31(%rbp), %eax
andl $0x7f, %eax
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %dl
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x40(%rbp)
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0xa, %eax
jne 0xaf17
jmp 0xaf19
jmp 0xaead
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xaf3c
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
movl %eax, %edx
callq 0x8820
cltq
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/fsio/dos11.c
// Function: dos11DeleteFile
static void dos11DeleteFile(
  void *filep,
  char *UNUSED(fname)
)
{
  struct dos11OpenFile *file = filep;
  struct mountedFS *mount = file->mount;
  struct DOS11data *data = &mount->dos11data;
  uint16_t i, block;

  file->name[0] = 0;
  file->name[1] = 0;
  file->ext = 0;

  dos11UpdateFile(mount, file);

  /*
   * The file has been removed from its UFD, release all disk blocks
   * allocated to the file.
   */
  block = le16toh(file->start);

  if ((le16toh(file->creation) & UFD_TYPE) != 0) {
    /*
     * Contiguous file
     */
    for (i = 0; i < le16toh(file->length); i++)
      if (bitmapReleaseBlock(mount, block + i) == 0)
        return;
  } else {
    /*
     * Linked file
     */
    while (block != 0) {
      if (dos11ReadBlock(mount, block, NULL) == 0)
        return;
      if (bitmapReleaseBlock(mount, block) == 0)
        return;

      block = le16toh(data->buf[FILE_LINK]);
    }
  }
  /*
   * Make sure the bitmaps on disk are up to date.
   */
  bitmapFlush(mount);

  dos11CloseFile(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 -0x18(%rbp), %rax
movw $0x0, (%rax)
movq -0x18(%rbp), %rax
movw $0x0, 0x2(%rax)
movq -0x18(%rbp), %rax
movw $0x0, 0x4(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7e90
movq -0x18(%rbp), %rax
movzwl 0xa(%rax), %edi
callq 0x6c50
movw %ax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x6(%rax), %edi
callq 0x6c50
movzwl %ax, %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0xb02b
movw $0x0, -0x2a(%rbp)
movzwl -0x2a(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movzwl 0xc(%rax), %edi
callq 0x6c50
movw %ax, %cx
movl -0x30(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jge 0xb029
movq -0x20(%rbp), %rdi
movzwl -0x2c(%rbp), %eax
movzwl -0x2a(%rbp), %ecx
addl %ecx, %eax
movzwl %ax, %esi
callq 0xb810
cmpl $0x0, %eax
jne 0xb019
jmp 0xb08c
jmp 0xb01b
movw -0x2a(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x2a(%rbp)
jmp 0xafdb
jmp 0xb07a
jmp 0xb02d
movzwl -0x2c(%rbp), %eax
cmpl $0x0, %eax
je 0xb078
movq -0x20(%rbp), %rdi
movzwl -0x2c(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x7380
cmpl $0x0, %eax
jne 0xb04e
jmp 0xb08c
movq -0x20(%rbp), %rdi
movzwl -0x2c(%rbp), %esi
callq 0xb810
cmpl $0x0, %eax
jne 0xb062
jmp 0xb08c
movq -0x28(%rbp), %rax
movzwl 0x50c(%rax), %edi
callq 0x6c50
movw %ax, -0x2c(%rbp)
jmp 0xb02d
jmp 0xb07a
movq -0x20(%rbp), %rdi
callq 0x8280
movq -0x18(%rbp), %rdi
callq 0xad30
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)