LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/print_lib.c
// Function: print_public_symbols
int print_public_symbols(FILE *in, uint32_t size)
{
  long marker = ftell(in);
  int offset_count = read_uint32(in);
  int n;

  printf(" --- offset_count: %d ---\n", offset_count);

  for (n = 0; n < offset_count; n++)
  {
    printf("  %02x %06x\n", n, read_uint32(in));
  }

  printf("\n");

  int symbol_count = read_uint32(in);
  uint16_t *offsets = (uint16_t *)malloc(symbol_count * sizeof(uint16_t));

  printf(" --- symbol_count: %d ---\n", symbol_count);

  for (n = 0; n < symbol_count; n++)
  {
    offsets[n] = read_uint16(in);
  }

  for (n = 0; n < symbol_count; n++)
  {
    printf("   0x%04x  ", offsets[n]);
	    print_symbol(in);
	    printf("\n");
	  }

	  printf("\n");

	  long total = ftell(in) - marker;

	  if (total != size)
	  {
	    printf("Error: Bad archive members size %ld vs %d.\n", total, size);
	    return -1;
	  }

	  return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2df0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
leaq 0x47ab(%rip), %rdi      # 0x649d
movb $0x0, %al
callq 0x1070
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1d35
movl -0x28(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2df0
movl -0x44(%rbp), %esi
movl %eax, %edx
leaq 0x4795(%rip), %rdi      # 0x64b8
movb $0x0, %al
callq 0x1070
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1d00
leaq 0x489f(%rip), %rdi      # 0x65db
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rdi
callq 0x2df0
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rdi
shlq %rdi
callq 0x10c0
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %esi
leaq 0x467d(%rip), %rdi      # 0x63e6
movb $0x0, %al
callq 0x1070
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x1da2
movq -0x10(%rbp), %rdi
callq 0x2e50
movw %ax, %dx
movq -0x38(%rbp), %rax
movslq -0x28(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1d77
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x1ded
movq -0x38(%rbp), %rax
movslq -0x28(%rbp), %rcx
movzwl (%rax,%rcx,2), %esi
leaq 0x4701(%rip), %rdi      # 0x64c5
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rdi
callq 0x1a00
leaq 0x4800(%rip), %rdi      # 0x65db
movb $0x0, %al
callq 0x1070
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1da9
leaq 0x47e7(%rip), %rdi      # 0x65db
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rdi
callq 0x10a0
subq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
je 0x1e36
movq -0x40(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x45e7(%rip), %rdi      # 0x640d
movb $0x0, %al
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e3d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/print_lib.c
// Function: print_name
int print_name(FILE *in, uint32_t size)
	{
	  long marker = ftell(in);

	  printf("   name: ");
	  print_symbol(in);
  printf("\n\n");

  long total = ftell(in) - marker;

  if (total != size)
  {
    printf("Error: Bad archive members size %ld vs %d.\n", total, size);
    return -1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movq %rax, -0x20(%rbp)
leaq 0x460e(%rip), %rdi      # 0x6481
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rdi
callq 0x1a00
leaq 0x4750(%rip), %rdi      # 0x65da
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rdi
callq 0x10a0
subq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
je 0x1ecc
movq -0x28(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x4551(%rip), %rdi      # 0x640d
movb $0x0, %al
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1ed3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/print_lib.c
// Function: print_raw
int print_raw(FILE *in, long offset, uint32_t size)
{
  long marker = ftell(in);
  fseek(in, offset, SEEK_SET);
  int n, i;

  uint8_t data[16];
  int total = 0;

  for (n = 0; n < size; n += 16)
  {
    int length = fread(data, 1, 16, in);
    printf("  %06x: ", n);

    total += length;
    if (total > size) { length -= total - size; }

    for (i = 0; i < length; i++)
    {
      printf("%02x ", data[i]);
    }

    for (i = length; i < 16; i++) { printf("   "); }

    for (i = 0; i < length; i++)
    {
      printf("%c", data[i] >= 32 && data[i] < 126 ? data[i] : '.');
    }

    printf("\n");
  }

  printf("\n");

  fseek(in, marker, SEEK_SET);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
movl $0x0, -0x44(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x2044
leaq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x1, %esi
movl $0x10, %edx
callq 0x1050
movl %eax, -0x48(%rbp)
movl -0x24(%rbp), %esi
leaq 0x4584(%rip), %rdi      # 0x64d1
movb $0x0, %al
callq 0x1070
movl -0x48(%rbp), %eax
addl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x1f73
movl -0x44(%rbp), %ecx
subl -0x14(%rbp), %ecx
movl -0x48(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x48(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x1fa4
movslq -0x28(%rbp), %rax
movzbl -0x40(%rbp,%rax), %esi
leaq 0x4548(%rip), %rdi      # 0x64da
movb $0x0, %al
callq 0x1070
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1f7a
movl -0x48(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x10, -0x28(%rbp)
jge 0x1fc9
leaq 0x4573(%rip), %rdi      # 0x652a
movb $0x0, %al
callq 0x1070
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1faa
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x2028
movslq -0x28(%rbp), %rax
movzbl -0x40(%rbp,%rax), %eax
cmpl $0x20, %eax
jl 0x2002
movslq -0x28(%rbp), %rax
movzbl -0x40(%rbp,%rax), %eax
cmpl $0x7e, %eax
jge 0x2002
movslq -0x28(%rbp), %rax
movzbl -0x40(%rbp,%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0x200c
movl $0x2e, %eax
movl %eax, -0x4c(%rbp)
jmp 0x200c
movl -0x4c(%rbp), %esi
leaq 0x54a6(%rip), %rdi      # 0x74bc
movb $0x0, %al
callq 0x1070
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1fd0
leaq 0x45ac(%rip), %rdi      # 0x65db
movb $0x0, %al
callq 0x1070
movl -0x24(%rbp), %eax
addl $0x10, %eax
movl %eax, -0x24(%rbp)
jmp 0x1f1d
leaq 0x4590(%rip), %rdi      # 0x65db
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/print_lib.c
// Function: print_section
int print_section(FILE *in, uint32_t size)
{
  struct coff_header_t coff_header;
  struct coff_optional_header_t optional_header;
  struct coff_section_header_t section_header;
  long marker = ftell(in);
  int n;

  int result = read_coff_header(in, &coff_header);

  if (result != 0)
  {
    return result;
  }

  print_coff_header(&coff_header);

  if (coff_header.optional_header_size != 0)
  {
    read_coff_optional_header(in, &optional_header);
    print_coff_optional_header(&optional_header);
  }

  for (n = 0; n < coff_header.section_count; n++)
  {
    read_coff_section_header(in, &section_header);
    print_coff_section_header(&section_header);
    print_raw(in, marker + section_header.file_offset_section_data, section_header.size);
  }

#if 0
  long total = ftell(in) - marker;

  if (total != size)
  {
    printf("Error: Bad archive members size %ld vs %d.\n", total, size);
    return -1;
  }
#endif

  fseek(in, marker + size, SEEK_SET);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x13d0
movl %eax, -0xa0(%rbp)
cmpl $0x0, -0xa0(%rbp)
je 0x20bc
movl -0xa0(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2161
leaq -0x38(%rbp), %rdi
callq 0x1750
movzwl -0x20(%rbp), %eax
cmpl $0x0, %eax
je 0x20e4
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x14b0
leaq -0x60(%rbp), %rdi
callq 0x1820
movl $0x0, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
movzwl -0x2e(%rbp), %ecx
cmpl %ecx, %eax
jge 0x2142
movq -0x10(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1570
leaq -0x90(%rbp), %rdi
callq 0x1900
movq -0x10(%rbp), %rdi
movq -0x98(%rbp), %rsi
movl -0x74(%rbp), %eax
addq %rax, %rsi
movl -0x78(%rbp), %edx
callq 0x1ee0
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x20ee
movq -0x10(%rbp), %rdi
movq -0x98(%rbp), %rsi
movl -0x14(%rbp), %eax
addq %rax, %rsi
xorl %edx, %edx
callq 0x10d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/print_lib.c
// Function: main
int main(int argc, char *argv[])
{
  FILE *in;

  printf("\nprint_lib (March 24, 2023)\n");
  printf("Copyright 2023 - Michael Kohn  http://www.mikekohn.net/\n\n");

  if (argc != 2)
  {
    printf("Usage: print_lib <filename>\n");
    exit(0);
  }

  in = fopen(argv[1], "rb");

  if (in == NULL)
  {
    printf("Could not open input file %s for reading.\n", argv[1]);
    exit(1);
  }

  read_lib(in);

  fclose(in);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x41a9(%rip), %rdi      # 0x6586
movb $0x0, %al
callq 0x1070
leaq 0x41b8(%rip), %rdi      # 0x65a3
movb $0x0, %al
callq 0x1070
cmpl $0x2, -0x8(%rbp)
je 0x240d
leaq 0x41de(%rip), %rdi      # 0x65dd
movb $0x0, %al
callq 0x1070
xorl %edi, %edi
callq 0x1110
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x41de(%rip), %rsi      # 0x65fa
callq 0x10e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x244c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x41c2(%rip), %rdi      # 0x65fd
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x1110
movq -0x18(%rbp), %rdi
callq 0x2170
movq -0x18(%rbp), %rdi
callq 0x1060
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/demangle.c
// Function: demangle
int demangle(const char *name, char *demangled, int length)
{
  if (name[0] != '?')
  {
    snprintf(demangled, length, "%s", name);
    return -1;
  }

  char temp[length];
  char params[length];
  char return_type[length];

  temp[0] = 0;
  params[0] = 0;
  return_type[0] = 0;

  int offset = demangle_name(name + 1, temp, params, return_type, 0, length);
  demangled[length - 1] = 0;
  if (offset < length) { demangled[offset] = 0; }

  snprintf(demangled, length, "%s %s%s", return_type, temp, params);

  return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3f, %eax
je 0x24b5
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
movq -0x10(%rbp), %rcx
leaq 0x42d7(%rip), %rdx      # 0x6779
movb $0x0, %al
callq 0x1080
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x258d
movl -0x1c(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x28(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rsi
subq %rcx, %rsi
movq %rsi, -0x60(%rbp)
movq %rsi, %rsp
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rdx
subq %rcx, %rdx
movq %rdx, -0x58(%rbp)
movq %rdx, %rsp
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, %rdi
addq $0xf, %rdi
andq $-0x10, %rdi
movq %rsp, %rcx
subq %rdi, %rcx
movq %rcx, -0x50(%rbp)
movq %rcx, %rsp
movq %rax, -0x40(%rbp)
movb $0x0, (%rsi)
movb $0x0, (%rdx)
movb $0x0, (%rcx)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl -0x1c(%rbp), %r9d
xorl %r8d, %r8d
callq 0x25a0
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x44(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x255e
movq -0x18(%rbp), %rax
movslq -0x44(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x58(%rbp), %r9
movq -0x60(%rbp), %r8
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
leaq 0x41fb(%rip), %rdx      # 0x6774
movb $0x0, %al
callq 0x1080
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/demangle.c
// Function: demangle_name
static int demangle_name(
  const char *name,
  char *demangled,
  char *params,
  char *return_type,
  int offset,
  int length)
{
  const char *s = name;
  int ptr = 0;

  while (s[ptr] != 0)
  {
    if (s[ptr] == '@')
    {
      if (s[ptr + 1] == '@')
      {
        offset = demangle_insert_name(name, demangled, offset, length);
        demangle_params(s + ptr + 2, params, return_type, 0, length);
        return offset;
      }
        else
      {
        offset = demangle_name(s + ptr + 1, demangled, params, return_type, offset, length);
        if (offset < length) { demangled[offset++] = ':'; }
        if (offset < length) { demangled[offset++] = ':'; }
        offset = demangle_insert_name(name, demangled, offset, length);
        return offset;
      }
    }

    ptr++;
  }

  if (offset < length) { demangled[offset] = 0; }

  return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x26e5
movq -0x38(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x40, %eax
jne 0x26d7
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x40, %eax
jne 0x2652
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
callq 0x2710
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
addq $0x2, %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x30(%rbp), %r8d
xorl %ecx, %ecx
callq 0x2840
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x26ff
movq -0x38(%rbp), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
movl -0x30(%rbp), %r9d
callq 0x25a0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x269b
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x2c(%rbp)
movslq %ecx, %rcx
movb $0x3a, (%rax,%rcx)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x26b9
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x2c(%rbp)
movslq %ecx, %rcx
movb $0x3a, (%rax,%rcx)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
callq 0x2710
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x26ff
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x25cf
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x26f9
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/demangle.c
// Function: demangle_insert_name
static int demangle_insert_name(
  const char *name,
  char *demangled,
  int offset,
  int length)
{
  while (offset < length)
  {
    if (*name == 0 || *name == '@') { break; }

    if (*name == '?')
    {
      switch (name[1])
      {
        case '0': break;
        case '1': demangled[offset++] = '~'; break;
        case '2':
          offset = demangle_append("operator new ", demangled, offset, length);
          break;
        case '3':
          offset = demangle_append("operator delete ", demangled, offset, length);
          break;
        // FIXME: Add the rest of these.
        default: break;
      }

      name += 2;
      continue;
    }

    demangled[offset++] = *name;
    name++;
  }

  if (offset < length) { demangled[offset] = 0; }

  return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x2818
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x274a
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x40, %eax
jne 0x274f
jmp 0x2818
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3f, %eax
jne 0x27ec
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
addl $-0x30, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x27d9
movq -0x20(%rbp), %rax
leaq 0x3ea8(%rip), %rcx      # 0x6628
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x27db
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x7e, (%rax,%rcx)
jmp 0x27db
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq 0x3fc8(%rip), %rdi      # 0x677c
callq 0x2cb0
movl %eax, -0x14(%rbp)
jmp 0x27db
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq 0x3fbb(%rip), %rdi      # 0x678a
callq 0x2cb0
movl %eax, -0x14(%rbp)
jmp 0x27db
jmp 0x27db
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x2726
movq -0x8(%rbp), %rax
movb (%rax), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2726
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x282c
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/demangle.c
// Function: demangle_append
static int demangle_append(
  const char *name,
  char *demangled,
  int offset,
  int length)
{
  while (*name != 0)
  {
    if (offset >= length -1) { return offset; }
    demangled[offset++] = *name;
    name++;
  }

  return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2d0c
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jl 0x2ce3
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2d12
movq -0x10(%rbp), %rax
movb (%rax), %dl
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2cc2
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/fileio.c
// Function: read_uint64
uint64_t read_uint64(FILE *in)
{
  uint64_t c;

  c = (uint64_t)getc(in);
  c |= (uint64_t)getc(in) << 8;
  c |= (uint64_t)getc(in) << 16;
  c |= (uint64_t)getc(in) << 24;
  c |= (uint64_t)getc(in) << 32;
  c |= (uint64_t)getc(in) << 40;
  c |= (uint64_t)getc(in) << 48;
  c |= (uint64_t)getc(in) << 56;

  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
cltq
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
cltq
shlq $0x8, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
cltq
shlq $0x10, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
cltq
shlq $0x18, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
cltq
shlq $0x20, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
cltq
shlq $0x28, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
cltq
shlq $0x30, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
cltq
shlq $0x38, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/fileio.c
// Function: read_uint32
int read_uint32(FILE *in)
{
  int c;

  c = getc(in);
  c |= getc(in) << 8;
  c |= getc(in) << 16;
  c |= getc(in) << 24;

  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
shll $0x8, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
shll $0x10, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
shll $0x18, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/fileio.c
// Function: read_chars
int read_chars(FILE *in, char *s, int count)
{
  int t;

  for (t = 0; t < count; t++)
  {
    s[t] = getc(in);
  }

  s[t] = 0;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2f03
movq -0x8(%rbp), %rdi
callq 0x1130
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2eda
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/fileio.c
// Function: read_chars_bin
int read_chars_bin(FILE *in, uint8_t *s, int count)
{
  int t;

  for (t = 0; t < count; t++)
  {
    s[t] = getc(in);
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2f63
movq -0x8(%rbp), %rdi
callq 0x1130
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2f3a
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/fileio.c
// Function: read_uint32_be
int read_uint32_be(FILE *in)
{
  int c;

  c = getc(in) << 24;
  c |= getc(in) << 16;
  c |= getc(in) << 8;
  c |= getc(in);

  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
shll $0x18, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
shll $0x10, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
shll $0x8, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/fileio.c
// Function: print_string
int print_string(FILE *in, int addr)
{
  int marker;
  int ch;

  marker = ftell(in);
  fseek(in, addr, SEEK_SET);

  while (1)
  {
    ch = getc(in);
    if (ch == EOF || ch == 0) { break; }

    printf("%c",ch);
  }

  fseek(in, marker, SEEK_SET);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10a0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
movq -0x8(%rbp), %rdi
callq 0x1130
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x3052
cmpl $0x0, -0x14(%rbp)
jne 0x3054
jmp 0x3067
movl -0x14(%rbp), %esi
leaq 0x445e(%rip), %rdi      # 0x74bc
movb $0x0, %al
callq 0x1070
jmp 0x303a
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/fileio.c
// Function: get_string
int get_string(FILE *in, char *s, int addr)
{
  int marker;
  int ch;
  int t;

  marker = ftell(in);
  fseek(in, addr, SEEK_SET);

  t = 0;

  while (1)
  {
    ch = getc(in);
    if (ch == EOF || ch == 0) { break; }

    s[t++] = ch;
  }

  s[t] = 0;

  fseek(in, marker, SEEK_SET);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10a0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x30cd
cmpl $0x0, -0x1c(%rbp)
jne 0x30cf
jmp 0x30eb
movl -0x1c(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x30b5
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/fileio.c
// Function: get_ptr
int get_ptr(FILE *in, int addr)
{
  int marker;
  int i;

  marker = ftell(in);
  fseek(in, addr, SEEK_SET);

  i = read_uint32(in);

  fseek(in, marker, SEEK_SET);
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10a0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
movq -0x8(%rbp), %rdi
callq 0x2df0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/fileio.c
// Function: get_ushort
int get_ushort(FILE *in, int addr)
{
  int marker;
  int i;

  marker = ftell(in);
  fseek(in, addr, SEEK_SET);

  i = read_uint16(in);

  fseek(in, marker, SEEK_SET);
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10a0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
movq -0x8(%rbp), %rdi
callq 0x2e50
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/pdb.c
// Function: read_pdb_header
int read_pdb_header(struct pdb_header_t *pdb_header, FILE *in)
{
  uint8_t magic_2[] = { 0x1a, 0x44, 0x53, 0x00, 0x00, 0x00 };
  int n;

  for (n = 0; n < sizeof(pdb_header->magic); n++)
  {
    pdb_header->magic[n] = getc(in);

    if (pdb_header->magic[n] == '\r') { pdb_header->magic[n] = 0; }
    if (pdb_header->magic[n] == '\n') { break; }
  }

  if (n == sizeof(pdb_header->magic)) { return -1; }

  for (n = 0; n < 6; n++)
  {
    pdb_header->magic_2[n] = getc(in);
    if (pdb_header->magic_2[n] != magic_2[n]) { return -1; }
  }

  pdb_header->block_size = read_uint32(in);
  pdb_header->free_block_map = read_uint32(in);
  pdb_header->number_of_blocks = read_uint32(in);
  pdb_header->number_of_dir_bytes = read_uint32(in);
  pdb_header->reserved = read_uint32(in);
  pdb_header->block_map_address = read_uint32(in);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl 0x370a(%rip), %eax      # 0x68d0
movl %eax, -0x1e(%rbp)
movw 0x3704(%rip), %ax       # 0x68d4
movw %ax, -0x1a(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq $0x50, %rax
jae 0x3238
movq -0x18(%rbp), %rdi
callq 0x1130
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0x3218
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x322b
jmp 0x3238
jmp 0x322d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x31db
movslq -0x24(%rbp), %rax
cmpq $0x50, %rax
jne 0x324e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3318
movl $0x0, -0x24(%rbp)
cmpl $0x6, -0x24(%rbp)
jge 0x32a5
movq -0x18(%rbp), %rdi
callq 0x1130
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, 0x50(%rax,%rcx)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl 0x50(%rax,%rcx), %eax
movslq -0x24(%rbp), %rcx
movzbl -0x1e(%rbp,%rcx), %ecx
cmpl %ecx, %eax
je 0x3298
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3318
jmp 0x329a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3255
movq -0x18(%rbp), %rdi
callq 0x2df0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x18(%rbp), %rdi
callq 0x2df0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x5c(%rax)
movq -0x18(%rbp), %rdi
callq 0x2df0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x18(%rbp), %rdi
callq 0x2df0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x18(%rbp), %rdi
callq 0x2df0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x18(%rbp), %rdi
callq 0x2df0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x6c(%rax)
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/mikeakohn[P]print_pe/build/../src/pdb.c
// Function: read_pdb_names
int read_pdb_names(
  struct pdb_dir_t *pdb_dir,
  struct pdb_header_t *pdb_header,
  FILE *in)
{
  const int index = pdb_dir->names_index;
  const int length = pdb_dir->stream_sizes[index];

  if (index == 0)
  {
    printf("Error: No /names stream found.\n");
    return -1;
  }

  read_data(pdb_dir, index, pdb_header->block_size, in);
  pdb_dir->names = (uint8_t *)malloc(length);
  memcpy(pdb_dir->names, pdb_dir->heap, length);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x364d
leaq 0x3299(%rip), %rdi      # 0x68d6
movb $0x0, %al
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3698
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x18(%rbp), %rax
movl 0x58(%rax), %edx
movq -0x20(%rbp), %rcx
callq 0x36b0
movslq -0x28(%rbp), %rdi
callq 0x10c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movslq -0x28(%rbp), %rdx
callq 0x10b0
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/mikeakohn[P]print_pe/build/../src/pdb.c
// Function: read_data
static void read_data(
  struct pdb_dir_t *pdb_dir,
  int index,
  int block_size,
  FILE *in)
{
  long marker = ftell(in);
  uint32_t *blocks = get_blocks(pdb_dir, index);
  int block_count = calc_block_count(pdb_dir->stream_sizes[index]);
  int n, offset = 0, length;

  for (n = 0; n < block_count; n++)
  {
    fseek(in, *blocks * block_size, SEEK_SET);
    length = fread(pdb_dir->heap + offset, 4096, 1, in);

    if (length == 0) { printf("Error: fread() 0 bytes.\n"); }

    offset += 4096;
    blocks++;
  }

  fseek(in, marker, SEEK_SET);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x5b30
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x35e0
movl %eax, -0x2c(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x3784
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %eax
imull -0x10(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movslq -0x34(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rcx
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %edx
callq 0x1050
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jne 0x3762
leaq 0x434f(%rip), %rdi      # 0x7aaa
movb $0x0, %al
callq 0x1070
movl -0x34(%rbp), %eax
addl $0x1000, %eax           # imm = 0x1000
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3708
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/pdb.c
// Function: print_pdb_header
void print_pdb_header(struct pdb_header_t *pdb_header)
{
  printf(" -------- PDB header -------\n");
  printf("              magic: %s\n", pdb_header->magic);
  printf("             magic2: %02x %02x %02x %02x %02x %02x\n",
    pdb_header->magic_2[0],
    pdb_header->magic_2[1],
    pdb_header->magic_2[2],
    pdb_header->magic_2[3],
    pdb_header->magic_2[4],
    pdb_header->magic_2[5]);
  printf("         block_size: %d\n", pdb_header->block_size);
  printf("     free_block_map: %d\n", pdb_header->free_block_map);
  printf("         num_blocks: %d\n", pdb_header->number_of_blocks);
  printf("      num_dir_bytes: %d\n", pdb_header->number_of_dir_bytes);
  printf("           reserved: %d\n", pdb_header->reserved);
  printf("  block_map_address: %d\n", pdb_header->block_map_address);
  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x3143(%rip), %rdi      # 0x68f6
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rsi
leaq 0x314f(%rip), %rdi      # 0x6914
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movsbl 0x50(%rax), %esi
movq -0x8(%rbp), %rax
movsbl 0x51(%rax), %edx
movq -0x8(%rbp), %rax
movsbl 0x52(%rax), %ecx
movq -0x8(%rbp), %rax
movsbl 0x53(%rax), %r8d
movq -0x8(%rbp), %rax
movsbl 0x54(%rax), %r9d
movq -0x8(%rbp), %rax
movsbl 0x55(%rax), %eax
leaq 0x3128(%rip), %rdi      # 0x692d
movl %eax, (%rsp)
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movl 0x58(%rax), %esi
leaq 0x3144(%rip), %rdi      # 0x6961
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %esi
leaq 0x3148(%rip), %rdi      # 0x697a
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movl 0x60(%rax), %esi
leaq 0x314c(%rip), %rdi      # 0x6993
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movl 0x64(%rax), %esi
leaq 0x3150(%rip), %rdi      # 0x69ac
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movl 0x68(%rax), %esi
leaq 0x3154(%rip), %rdi      # 0x69c5
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %esi
leaq 0x3158(%rip), %rdi      # 0x69de
movb $0x0, %al
callq 0x1070
leaq 0x2d47(%rip), %rdi      # 0x65db
movb $0x0, %al
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/pdb.c
// Function: print_pdb_dir
void print_pdb_dir(struct pdb_dir_t *pdb_dir)
{
  int ptr = 0;
  int n, i;

  printf(" -- PDB Directory --\n");
  printf("   stream_count: %d\n", pdb_dir->stream_count);
  printf("  stream_blocks:\n");

  for (n = 0; n < pdb_dir->stream_count; n++)
  {
    int count = calc_block_count(pdb_dir->stream_sizes[n]);

    printf("    %d: %6d {", n, pdb_dir->stream_sizes[n]);

    for (i = 0; i < count; i++)
    {
      printf(" %d", pdb_dir->stream_blocks[ptr++]);
    }

    printf(" }\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0x312d(%rip), %rdi      # 0x69f7
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0x312f(%rip), %rdi      # 0x6a0d
movb $0x0, %al
callq 0x1070
leaq 0x3136(%rip), %rdi      # 0x6a22
movb $0x0, %al
callq 0x1070
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x399d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x35e0
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x30fb(%rip), %rdi      # 0x6a34
movb $0x0, %al
callq 0x1070
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x3981
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %esi
leaq 0x30d3(%rip), %rdi      # 0x6a42
movb $0x0, %al
callq 0x1070
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3947
leaq 0x30be(%rip), %rdi      # 0x6a46
movb $0x0, %al
callq 0x1070
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x38fa
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/pdb.c
// Function: dump_pdb_stream
void dump_pdb_stream(
  struct pdb_dir_t *pdb_dir,
  struct pdb_header_t *pdb_header,
  FILE *in,
  int index,
  const char *filename)
{
  read_data(pdb_dir, index, pdb_header->block_size, in);

  uint8_t *data = pdb_dir->heap;

  FILE *fp = fopen(filename, "wb");
  fwrite(data, pdb_dir->stream_sizes[index], 1, fp);
  fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
movl 0x58(%rax), %edx
movq -0x18(%rbp), %rcx
callq 0x36b0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x1fbe(%rip), %rsi      # 0x7aa7
callq 0x10e0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %esi
movq -0x38(%rbp), %rcx
movl $0x1, %edx
callq 0x1120
movq -0x38(%rbp), %rdi
callq 0x1060
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/pdb.c
// Function: get_blocks
static uint32_t *get_blocks(struct pdb_dir_t *pdb_dir, int index)
{
  int n, ptr = 0;

  for (n = 0; n < index; n++)
  {
    ptr += calc_block_count(pdb_dir->stream_sizes[n]);
  }

  return &pdb_dir->stream_blocks[ptr];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5b7a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x35e0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5b4d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cirocosta[P]stress/src/file-watcher.c
// Function: main
int
main(int argc, char** argv)
{
	stress_args_t args = { 0 };
	int fd;

	setbuf(stdout, NULL);
	stress_parse_args(argc, argv, &args);

	_STRESS_MUST_P((fd = inotify_init()) >= 0,
	               "inotify_init",
	               "couldn't initialize inotify");

	create_files_and_watch(args.n, fd);
	stress_wait_until_signalized();
}

// Assembly:
subq $0x2028, %rsp           # imm = 0x2028
movl %edi, 0x2024(%rsp)
movq %rsi, 0x2018(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x2008, %edx           # imm = 0x2008
callq 0x10e0
movq 0x2efa(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10c0
movl 0x2024(%rsp), %edi
movq 0x2018(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x1350
callq 0x1120
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
jge 0x2217
movq 0x2eec(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x10be(%rip), %rsi      # 0x31d4
movb $0x0, %al
callq 0x1100
movq 0x2ed4(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x10ac(%rip), %rsi      # 0x31da
movb $0x0, %al
callq 0x1100
movq 0x2ebc(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1153(%rip), %rsi      # 0x3299
movb $0x0, %al
callq 0x1100
movq 0x2ea4(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xf0c(%rip), %rsi       # 0x306a
movb $0x0, %al
callq 0x1100
movq 0x2e8c(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xef7(%rip), %rsi       # 0x306d
leaq 0xfd3(%rip), %rdx       # 0x3150
movb $0x0, %al
callq 0x1100
movq 0x2e6d(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xef4(%rip), %rsi       # 0x3089
movl $0x56, %edx
movb $0x0, %al
callq 0x1100
movq 0x2e50(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xeb9(%rip), %rsi       # 0x306b
movb $0x0, %al
callq 0x1100
movq 0x2e38(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1003(%rip), %rsi      # 0x31cd
movb $0x0, %al
callq 0x1100
leaq 0x10dd(%rip), %rdi      # 0x32b5
callq 0x1160
movq 0x2e14(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xfec(%rip), %rsi       # 0x31da
movb $0x0, %al
callq 0x1100
movq 0x2dfc(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xe90(%rip), %rsi       # 0x3096
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1190
jmp 0x2219
movl 0x10(%rsp), %edi
movl 0xc(%rsp), %esi
callq 0x1b50
callq 0x1750
xorl %eax, %eax
addq $0x2028, %rsp           # imm = 0x2028
retq
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/kd11b.c
// Function: reset
void
reset(KD11B *cpu)
{
	Busdev *bd;

	cpu->rcd_busy = 0;
	cpu->rcd_rdr_enab = 0;
	cpu->rcd_int_enab = 0;
	cpu->rcd_int = 0;
	cpu->rcd_da = 0;
	cpu->rcd_b = 0;

	cpu->xmit_int_enab = 0;
	cpu->xmit_maint = 0;
	cpu->xmit_int = 1;
	cpu->xmit_tbmt = 1;
	cpu->xmit_b = 0;

	cpu->lc_int_enab = 0;
	// TODO: 1?
	cpu->lc_clock = 0;
	cpu->lc_int = 0;

	cpu->traps = 0;

	for(bd = cpu->bus->devs; bd; bd = bd->next)
		bd->reset(bd->dev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x90(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x94(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x98(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x9c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xa0(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xa4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xa8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xac(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xb0(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xb4(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xb8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x84(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1eaa
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1e84
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/kd11b.c
// Function: fetchop
static int
fetchop(KD11B *cpu, int t, int m, int b, int pse)
{
	int r;
	r = m&7;
	if((m&070) == 0)
		cpu->r[t] = cpu->r[r];
	else{
		if(dati(cpu, b, pse)) return 1;
		cpu->r[t] = cpu->bus->data;
		if(b && cpu->ba&1) cpu->r[t] = cpu->r[t]>>8;
	}
	if(b) cpu->r[t] = sxt(cpu->r[t]);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl -0x18(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
andl $0x38, %eax
cmpl $0x0, %eax
jne 0x47e7
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movw (%rax,%rcx,2), %dx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x4852
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x1eb0
cmpl $0x0, %eax
je 0x4804
movl $0x1, -0x4(%rbp)
jmp 0x4882
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movw 0xc(%rax), %dx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
cmpl $0x0, -0x1c(%rbp)
je 0x4850
movq -0x10(%rbp), %rax
movzwl 0x22(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4850
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
sarl $0x8, %eax
movw %ax, %dx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x4852
cmpl $0x0, -0x1c(%rbp)
je 0x487b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movw (%rax,%rcx,2), %ax
movzbl %al, %edi
callq 0x1570
movw %ax, %dx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/asc16.c
// Function: asc16_load
int asc16_load(asc16_t *asc16, const char *filename)
{
	FILE *pf;
	int size;

	pf = fopen(filename, "rb");
	if (pf == NULL)
		return -1;

	size = file_readall(pf, &asc16->data);
	
	fclose(pf);

	if (size == -1)
		return -1;

	asc16->size = size;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x4ca9(%rip), %rsi      # 0x7004
callq 0x1130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2374
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x23ad
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23c0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1070
cmpl $-0x1, -0x24(%rbp)
jne 0x239c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x23ad
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
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/GangZhuo[P]rbtree/test/asc16.c
// Function: file_readall
static inline int file_readall(FILE *pf, char **pbuf)
{
	int size;
	char *buf;

	size = file_size(pf);
	if (size == -1)
		return -1;

	buf = malloc(size);
	if (buf == NULL)
		return -1;

	if (fread(buf, 1, size, pf) != size) {
		free(buf);
		return -1;
	}

	*pbuf = buf;

	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2500
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x23eb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x244a
movslq -0x1c(%rbp), %rdi
callq 0x10f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2408
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x244a
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x1060
movslq -0x1c(%rbp), %rcx
cmpq %rcx, %rax
je 0x2439
movq -0x28(%rbp), %rdi
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x244a
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)