LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/pe.c
// Function: rip_binary
int rip_binary(FILE *in, char *filename, int address, int size)
{
  FILE *out;
  long marker;
  int t;

  out = fopen(filename, "wb");

  if (out == NULL)
  {
    printf("Cannot open file %s for writing.\n\n",filename);
    return -1;
  }

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

  for (t = 0; t < size; t++)
  {
    putc(getc(in), out);
  }

  fseek(in, marker, SEEK_SET);
  fclose(out);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
leaq 0x21b8(%rip), %rsi      # 0x8045
movq %r12, %rdi
callq 0x3110
testq %rax, %rax
je 0x5ee8
movq %rax, %r15
movq %r14, %rdi
callq 0x30f0
movq %rax, %r12
movslq %ebp, %rsi
xorl %ebp, %ebp
movq %r14, %rdi
xorl %edx, %edx
callq 0x3100
testl %ebx, %ebx
jle 0x5ed1
movq %r14, %rdi
callq 0x3150
movl %eax, %edi
movq %r15, %rsi
callq 0x30d0
decl %ebx
jne 0x5ebb
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3100
movq %r15, %rdi
callq 0x3070
jmp 0x5efe
leaq 0x3e61(%rip), %rdi      # 0x9d50
movq %r12, %rsi
xorl %eax, %eax
callq 0x3090
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/pe.c
// Function: read_unicode
int read_unicode(FILE *in, int address, char *s, int max_chars)
{
  long marker;
  int ch,t,len;

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

  t = 0;
  len = read_uint16(in);

  while (t < len)
  {
    getc(in);
    ch = getc(in);
    if (ch == EOF || ch == 0) { break; }
    s[t++] = ch;

    if (t == max_chars - 1) { break; }
  }

  s[t] = 0;

  fseek(in, marker, SEEK_SET);

  return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x30f0
movq %rax, (%rsp)
movslq %ebp, %rsi
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3100
movq %rbx, %rdi
callq 0x520c
movl %eax, %r13d
leal -0x2(%r12), %r15d
decl %r12d
testl %eax, %eax
cmovlel %ebp, %r13d
incq %r15
cmpq %rbp, %r13
je 0x5f84
movq %rbx, %rdi
callq 0x3150
movq %rbx, %rdi
callq 0x3150
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x5f81
movb %al, (%r14,%rbp)
incq %rbp
cmpq %rbp, %r15
jne 0x5f53
movl %r12d, %r13d
jmp 0x5f84
movl %ebp, %r13d
movslq %r13d, %r12
movb $0x0, (%r14,%r12)
movq %rbx, %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0x3100
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/pe.c
// Function: hex_dump
int hex_dump(FILE *in, int address, int size, struct section_header_t *section_header)
{
  long marker;
  uint32_t virtual_address, raw_ptr;
  int t;

  virtual_address = section_header->VirtualAddress;
  raw_ptr = section_header->PointerToRawData;

  address = (address - virtual_address) + raw_ptr;

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

  printf("-- Hex Dump address=0x%04x size=%d --\n", address, size);

  for (t = 0; t < size; t++)
  {
    if ((t % 8) == 0) { printf("\n"); }
    printf(" %02x", getc(in));
  }
  printf("\n");

  fseek(in, marker, SEEK_SET);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
subl 0x10(%rcx), %r15d
addl 0x18(%rcx), %r15d
callq 0x30f0
movq %rax, %r14
movslq %r15d, %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3100
leaq 0x3d90(%rip), %rdi      # 0x9d73
movl %r15d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3090
testl %ebp, %ebp
jle 0x6029
leaq 0x2e05(%rip), %r15      # 0x8dff
xorl %r12d, %r12d
testb $0x7, %r12b
jne 0x600d
movl $0xa, %edi
callq 0x3030
movq %rbx, %rdi
callq 0x3150
movq %r15, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x3090
incl %r12d
cmpl %r12d, %ebp
jne 0x5ffd
movl $0xa, %edi
callq 0x3030
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3100
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/resource.c
// Function: read_struct_info
static int read_struct_info(
  FILE *in,
  uint16_t *wLength,
  uint16_t *wValueLength,
  uint16_t *wType,
  char *szKey,
  int szKey_length)
{
  int len = 6;

  *wLength = read_uint16(in);
  *wValueLength = read_uint16(in);
  *wType = read_uint16(in);

  printf("   wLength=%d\n", *wLength);
  printf("   wValueLength=%d\n", *wValueLength);
  printf("   wType=%d %s\n", *wType, *wType == 0 ? "(binary)" : "(text)");
  printf("   szKey=");
  len += parse_unicode(in, szKey, szKey_length);
  len += read_padding(in, len);
  printf("\n");

  return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x520c
movw %ax, (%r13)
movq %rbx, %rdi
callq 0x520c
movw %ax, (%r12)
movq %rbx, %rdi
callq 0x520c
movw %ax, (%r15)
movzwl (%r13), %esi
leaq 0x3edb(%rip), %rdi      # 0xa2a3
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x3090
movzwl (%r12), %esi
leaq 0x3ed4(%rip), %rdi      # 0xa2b2
xorl %eax, %eax
callq 0x3090
movzwl (%r15), %esi
testl %esi, %esi
leaq 0x3ee4(%rip), %rax      # 0xa2d6
leaq 0x3ee6(%rip), %rdx      # 0xa2df
cmoveq %rax, %rdx
leaq 0x3ec2(%rip), %rdi      # 0xa2c6
xorl %eax, %eax
callq 0x3090
leaq 0x3ed4(%rip), %rdi      # 0xa2e6
xorl %eax, %eax
callq 0x3090
movq %rbx, %rdi
callq 0x3150
movl %eax, %ebp
movq %rbx, %rdi
callq 0x3150
movl %eax, %ecx
shll $0x8, %eax
orl %ebp, %eax
sete %dl
cmpl $-0x1, %ecx
sete %cl
movl $0x8, %r15d
orb %dl, %cl
jne 0x6481
movl %eax, %edi
callq 0x3030
cmpl $0x7e, %r13d
jg 0x645c
movslq %r13d, %rax
incl %r13d
movb %bpl, (%r14,%rax)
movq %rbx, %rdi
callq 0x3150
movl %eax, %ebp
movq %rbx, %rdi
callq 0x3150
addl $0x2, %r15d
cmpl $-0x1, %eax
je 0x647e
shll $0x8, %eax
orl %ebp, %eax
jne 0x6445
movslq %r13d, %r13
movb $0x0, (%r14,%r13)
movl $0xa, %edi
callq 0x3030
testb $0x3, %r15b
je 0x64ca
movl %r15d, %r14d
negb %r14b
movl %r15d, %ebp
andl $0x3, %ebp
movl $0x1, %r12d
andb $0x3, %r14b
movq %rbx, %rdi
callq 0x3150
movl %r12d, %eax
andb $0x3, %al
incl %r12d
cmpb %r14b, %al
jne 0x64ac
movl $0x4, %ebx
subl %ebp, %ebx
jmp 0x64cc
xorl %ebx, %ebx
addl %r15d, %ebx
movl $0xa, %edi
callq 0x3030
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/resource.c
// Function: read_fixed_file_info
int read_fixed_file_info(FILE *in, struct fixed_file_info_t *fixed_file_info)
{
  fixed_file_info->Signature = read_uint32(in);
  fixed_file_info->StrucVersion = read_uint32(in);
  fixed_file_info->FileVersionMS = read_uint32(in);
  fixed_file_info->FileVersionLS = read_uint32(in);
  fixed_file_info->ProductVersionMS = read_uint32(in);
  fixed_file_info->ProductVersionLS = read_uint32(in);
  fixed_file_info->FileFlagsMask = read_uint32(in);
  fixed_file_info->FileFlags = read_uint32(in);
  fixed_file_info->FileOS = read_uint32(in);
  fixed_file_info->FileType = read_uint32(in);
  fixed_file_info->FileSubtype = read_uint32(in);
  fixed_file_info->FileDateMS = read_uint32(in);
  fixed_file_info->FileDateLS = read_uint32(in);

  return 13 * sizeof(uint32_t);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x51ca
movl %eax, (%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x4(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x8(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0xc(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x10(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x14(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x18(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x1c(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x20(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x24(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x28(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x2c(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x30(%rbx)
movl $0x34, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/resource.c
// Function: read_resource_dir
int read_resource_dir(FILE *in, int addr, struct resource_dir_t *resource_dir)
{
  int marker;

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

  resource_dir->Characteristics = read_uint32(in);
  resource_dir->TimeDateStamp = read_uint32(in);
  resource_dir->MajorVersion = read_uint16(in);
  resource_dir->MinorVersion = read_uint16(in);
  resource_dir->NumberOfNamedEntries = read_uint16(in);
  resource_dir->NumberOfIdEntries = read_uint16(in);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x30f0
movq %rax, %r15
movslq %ebp, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3100
movq %rbx, %rdi
callq 0x51ca
movl %eax, (%r14)
movq %rbx, %rdi
callq 0x51ca
movl %eax, 0x4(%r14)
movq %rbx, %rdi
callq 0x520c
movw %ax, 0x8(%r14)
movq %rbx, %rdi
callq 0x520c
movw %ax, 0xa(%r14)
movq %rbx, %rdi
callq 0x520c
movw %ax, 0xc(%r14)
movq %rbx, %rdi
callq 0x520c
movw %ax, 0xe(%r14)
movslq %r15d, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3100
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/resource.c
// Function: print_resource_dir
int print_resource_dir(struct resource_dir_t *resource_dir, int level)
{
  char indent[RES_INDENT_MAX];

  memset(indent, ' ', RES_INDENT_MAX);
  if (level > RES_INDENT_LEVELS) { level = RES_INDENT_LEVELS; }
  indent[level * RES_INDENT_UNIT] = 0;

  printf("%s|_______ Resource Directory ___\n",indent);

  printf("%s|  Characteristics: 0x%x\n",indent,resource_dir->Characteristics);
  printf("%s|    TimeDateStamp: %s",indent,ctime((time_t *)&resource_dir->TimeDateStamp));
  printf("%s|     MajorVersion: %d\n",indent,resource_dir->MajorVersion);
  printf("%s|     MinorVersion: %d\n",indent,resource_dir->MinorVersion);
  printf("%s|NumOfNamedEntries: %d\n",indent,resource_dir->NumberOfNamedEntries);
  printf("%s|   NumOfIdEntries: %d\n",indent,resource_dir->NumberOfIdEntries);
  printf("\n");

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movaps 0x34bf(%rip), %xmm0     # 0x9e40
movq %rsp, %rbx
movaps %xmm0, 0x50(%rbx)
movaps %xmm0, 0x40(%rbx)
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movl $0x20202020, 0x60(%rbx) # imm = 0x20202020
cmpl $0x18, %esi
movl $0x18, %eax
cmovll %esi, %eax
cltq
movb $0x0, (%rsp,%rax,4)
leaq 0x3549(%rip), %rdi      # 0x9f03
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3090
movl (%r14), %edx
leaq 0x3558(%rip), %rdi      # 0x9f26
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3090
leaq 0x4(%r14), %rdi
callq 0x3080
leaq 0x355a(%rip), %rdi      # 0x9f42
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3090
movzwl 0x8(%r14), %edx
leaq 0x355a(%rip), %rdi      # 0x9f5b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3090
movzwl 0xa(%r14), %edx
leaq 0x355e(%rip), %rdi      # 0x9f75
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3090
movzwl 0xc(%r14), %edx
leaq 0x3562(%rip), %rdi      # 0x9f8f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3090
movzwl 0xe(%r14), %edx
leaq 0x3566(%rip), %rdi      # 0x9fa9
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3090
movl $0xa, %edi
callq 0x3030
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/resource.c
// Function: read_resource_dir_entry
int read_resource_dir_entry(
  FILE *in,
  int addr,
  struct resource_dir_entry_t *resource_dir_entry,
  int offset)
{
  long marker;

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

  resource_dir_entry->Name = read_uint32(in);
  resource_dir_entry->OffsetToData = read_uint32(in);

  if ((resource_dir_entry->Name & 0x80000000) != 0)
  {
    read_unicode(
      in,
      addr + (resource_dir_entry->Name & 0x7fffffff),
      resource_dir_entry->RealName,
      256);
  }
    else
  {
    resource_dir_entry->RealName[0] = 0;
  }

  fseek(in, marker, SEEK_SET);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
callq 0x30f0
movq %rax, %r14
addl %ebp, %r12d
movslq %r12d, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3100
movq %rbx, %rdi
callq 0x51ca
movl %eax, (%r15)
movq %rbx, %rdi
callq 0x51ca
movl %eax, 0x4(%r15)
movl (%r15), %esi
testl %esi, %esi
js 0x6ab1
movb $0x0, 0x8(%r15)
jmp 0x6acd
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
addl %ebp, %esi
addq $0x8, %r15
movq %rbx, %rdi
movq %r15, %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x5f09
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3100
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/resource.c
// Function: print_resource_dir_entry
int print_resource_dir_entry(
  struct resource_dir_entry_t *resource_dir_entry,
  int level,
  int count)
{
  char indent[RES_INDENT_MAX];

  memset(indent, ' ', RES_INDENT_MAX);
  if (level > RES_INDENT_LEVELS) level = RES_INDENT_LEVELS;
  indent[level * RES_INDENT_UNIT] = 0;

  if ((resource_dir_entry->OffsetToData & 0x80000000) == 0)
  {
    printf("%s-- Resource Dir Entry [%d] --\n", indent, count);
  }
    else
  {
    printf("%s-- Resource Dir Entry (Dir) [%d] --\n", indent, count);
  }

  printf("%s|             Name: 0x%08x", indent, resource_dir_entry->Name);

  if ((resource_dir_entry->Name&0x80000000) != 0)
  {
    printf("%s|(%s)", indent, resource_dir_entry->RealName);
  }

  printf("\n");
  printf("%s|     OffsetToData: 0x%08x\n", indent, resource_dir_entry->OffsetToData);
  printf("\n");

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movaps 0x334a(%rip), %xmm0     # 0x9e40
movq %rsp, %r14
movaps %xmm0, 0x50(%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movl $0x20202020, 0x60(%r14) # imm = 0x20202020
cmpl $0x18, %esi
movl $0x18, %eax
cmovll %esi, %eax
cltq
movb $0x0, (%rsp,%rax,4)
cmpl $0x0, 0x4(%rdi)
leaq 0x333e(%rip), %rax      # 0x9e78
leaq 0x3358(%rip), %rdi      # 0x9e99
cmovnsq %rax, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3090
movl (%rbx), %edx
leaq 0x3368(%rip), %rdi      # 0x9ec0
movq %r14, %rsi
xorl %eax, %eax
callq 0x3090
cmpl $0x0, (%rbx)
jns 0x6b7c
leaq 0x8(%rbx), %rdx
leaq 0x336b(%rip), %rdi      # 0x9edd
movq %rsp, %rsi
xorl %eax, %eax
callq 0x3090
movl $0xa, %edi
callq 0x3030
movl 0x4(%rbx), %edx
leaq 0x3355(%rip), %rdi      # 0x9ee5
movq %rsp, %rsi
xorl %eax, %eax
callq 0x3090
movl $0xa, %edi
callq 0x3030
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/resource.c
// Function: read_resource_data
int read_resource_data(
  FILE *in,
  int addr,
  struct resource_data_t *resource_data,
  int offset)
{
  long marker;

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

  resource_data->OffsetToData = read_uint32(in);
  resource_data->Size = read_uint32(in);
  resource_data->CodePage = read_uint32(in);
  resource_data->Reserved = read_uint32(in);

  fseek(in, marker, SEEK_SET);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %rbx
callq 0x30f0
movq %rax, %r15
addl %ebp, %r12d
movslq %r12d, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3100
movq %rbx, %rdi
callq 0x51ca
movl %eax, (%r14)
movq %rbx, %rdi
callq 0x51ca
movl %eax, 0x4(%r14)
movq %rbx, %rdi
callq 0x51ca
movl %eax, 0x8(%r14)
movq %rbx, %rdi
callq 0x51ca
movl %eax, 0xc(%r14)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3100
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/resource.c
// Function: print_resource_data
int print_resource_data(struct resource_data_t *resource_data, int level)
{
  char indent[RES_INDENT_MAX];

  memset(indent, ' ', RES_INDENT_MAX);
  if (level > RES_INDENT_LEVELS) { level = RES_INDENT_LEVELS; }
  indent[level * RES_INDENT_UNIT] = 0;

  printf("%s-- Resource Data --\n", indent);
  printf("%s|     OffsetToData: %d\n", indent,resource_data->OffsetToData);
  printf("%s|             Size: %d\n", indent,resource_data->Size);
  printf("%s|         CodePage: %d\n", indent,resource_data->CodePage);
  printf("%s|         Reserved: %d\n", indent,resource_data->Reserved);
  printf("\n");

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movaps 0x320f(%rip), %xmm0     # 0x9e40
movq %rsp, %rbx
movaps %xmm0, 0x50(%rbx)
movaps %xmm0, 0x40(%rbx)
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movl $0x20202020, 0x60(%rbx) # imm = 0x20202020
cmpl $0x18, %esi
movl $0x18, %eax
cmovll %esi, %eax
cltq
movb $0x0, (%rsp,%rax,4)
leaq 0x33f2(%rip), %rdi      # 0xa05c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3090
movl (%r14), %edx
leaq 0x33f5(%rip), %rdi      # 0xa073
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3090
movl 0x4(%r14), %edx
leaq 0x33fa(%rip), %rdi      # 0xa08d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3090
movl 0x8(%r14), %edx
leaq 0x33ff(%rip), %rdi      # 0xa0a7
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3090
movl 0xc(%r14), %edx
leaq 0x3404(%rip), %rdi      # 0xa0c1
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3090
movl $0xa, %edi
callq 0x3030
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/resource.c
// Function: print_resource_type
int print_resource_type(int id, int level)
{
  char indent[RES_INDENT_MAX];
  char *ids[] = {
    "", "Cursor", "Bitmap", "Icon", "Menu", "Dialog", "String",
    "Font Dir", "Font", "Accelerator", "RCData", "MessageTable",
    "", "", "", "", "Version Info", "DlgInclude", "", "PlugPlay",
    "VXD", "AniCursor", "AniIcon", "HTML", "Unknown"
  };

  memset(indent, ' ', RES_INDENT_MAX);
  if (level > RES_INDENT_LEVELS) { level = RES_INDENT_LEVELS; }
  indent[level*RES_INDENT_UNIT] = 0;

  printf("%s>> Resource Type: ", indent);

  if (id < 0x17)
  {
    printf("%s\n", ids[id]);
  }
  else
  {
    printf("???\n");
  }

  printf("\n");

  return 0;
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebx
movaps 0x3157(%rip), %xmm0     # 0x9e40
movq %rsp, %rax
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x20202020, 0x60(%rax) # imm = 0x20202020
cmpl $0x18, %esi
movl $0x18, %ecx
cmovll %esi, %ecx
movslq %ecx, %rcx
movb $0x0, (%rsp,%rcx,4)
leaq 0x3324(%rip), %rdi      # 0xa047
movq %rax, %rsi
xorl %eax, %eax
callq 0x3090
cmpl $0x16, %ebx
jg 0x6d45
movslq %ebx, %rax
leaq 0x3074(%rip), %rcx      # 0x9db0
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
jmp 0x6d4c
leaq 0x204e(%rip), %rdi      # 0x8d9a
callq 0x3060
movl $0xa, %edi
callq 0x3030
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/resource.c
// Function: save_resource
int save_resource(FILE *in, char *filename, int addr)
{
  int marker;
  unsigned OffsetToData,Size;

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

  OffsetToData = read_uint32(in);
  Size = read_uint32(in);

  printf("OffsetToData=%d\n", OffsetToData);
  printf("Size=0x%08x\n", Size);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
callq 0x30f0
movq %rax, %r14
movslq %ebp, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3100
movq %rbx, %rdi
callq 0x51ca
movl %eax, %ebp
movq %rbx, %rdi
callq 0x51ca
movl %eax, %r15d
leaq 0x30ba(%rip), %rdi      # 0x9e5a
movl %ebp, %esi
xorl %eax, %eax
callq 0x3090
leaq 0x30bb(%rip), %rdi      # 0x9e6b
movl %r15d, %esi
xorl %eax, %eax
callq 0x3090
movslq %r14d, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3100
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/section_header.c
// Function: section_header_read
int section_header_read(struct section_header_t *section_header, FILE *in)
{
  memset(section_header->name, 0, sizeof(section_header->name));
  read_chars(in, section_header->name, 8);
  section_header->VirtualSize = read_uint32(in);
  section_header->VirtualAddress = read_uint32(in);
  section_header->SizeOfRawData = read_uint32(in);
  section_header->PointerToRawData = read_uint32(in);
  section_header->PointerToRelocations = read_uint32(in);
  section_header->PointerToLinenumbers = read_uint32(in);
  section_header->NumberOfRelocations = read_uint16(in);
  section_header->NumberOfLinenumbers = read_uint16(in);
  section_header->Characteristics = read_uint32(in);

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movw $0x0, 0x8(%rdi)
movq $0x0, (%rdi)
movq %rsi, %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x5232
movq %r14, %rdi
callq 0x51ca
movl %eax, 0xc(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x10(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x14(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x18(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x1c(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x20(%rbx)
movq %r14, %rdi
callq 0x520c
movw %ax, 0x24(%rbx)
movq %r14, %rdi
callq 0x520c
movw %ax, 0x26(%rbx)
movq %r14, %rdi
callq 0x51ca
movl %eax, 0x28(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/section_header.c
// Function: section_header_print
int section_header_print(struct section_header_t *section_header, int count)
{
  printf("---------------------------------------------\n");
  printf("Section Header %d\n",count);
  printf("---------------------------------------------\n");
  printf("      Section Name: %s\n",section_header->name);
  printf("       VirtualSize: %d\n",section_header->VirtualSize);
  printf("    VirtualAddress: 0x%04x\n",section_header->VirtualAddress);
  printf("     SizeOfRawData: %d\n",section_header->SizeOfRawData);
  printf("  PointerToRawData: 0x%04x\n",section_header->PointerToRawData);
  printf("  PtrToRelocations: %d\n",section_header->PointerToRelocations);
  printf("  PtrToLinenumbers: %d\n",section_header->PointerToLinenumbers);
  printf("  NumOfRelocations: %d\n",section_header->NumberOfRelocations);
  printf("  NumOfLinenumbers: %d\n",section_header->NumberOfLinenumbers);
  printf("   Characteristics: 0x%x\n",section_header->Characteristics);
  printf("\n");

  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x13c7(%rip), %r14      # 0x8241
movq %r14, %rdi
callq 0x3060
leaq 0x3506(%rip), %rdi      # 0xa38f
movl %ebp, %esi
xorl %eax, %eax
callq 0x3090
movq %r14, %rdi
callq 0x3060
leaq 0x3501(%rip), %rdi      # 0xa3a2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3090
movl 0xc(%rbx), %esi
leaq 0x3505(%rip), %rdi      # 0xa3ba
xorl %eax, %eax
callq 0x3090
movl 0x10(%rbx), %esi
leaq 0x350c(%rip), %rdi      # 0xa3d2
xorl %eax, %eax
callq 0x3090
movl 0x14(%rbx), %esi
leaq 0x3517(%rip), %rdi      # 0xa3ee
xorl %eax, %eax
callq 0x3090
movl 0x18(%rbx), %esi
leaq 0x1eea(%rip), %rdi      # 0x8dd2
xorl %eax, %eax
callq 0x3090
movl 0x1c(%rbx), %esi
leaq 0x350d(%rip), %rdi      # 0xa406
xorl %eax, %eax
callq 0x3090
movl 0x20(%rbx), %esi
leaq 0x3514(%rip), %rdi      # 0xa41e
xorl %eax, %eax
callq 0x3090
movzwl 0x24(%rbx), %esi
leaq 0x351a(%rip), %rdi      # 0xa436
xorl %eax, %eax
callq 0x3090
movzwl 0x26(%rbx), %esi
leaq 0x3520(%rip), %rdi      # 0xa44e
xorl %eax, %eax
callq 0x3090
movl 0x28(%rbx), %esi
leaq 0x3527(%rip), %rdi      # 0xa466
xorl %eax, %eax
callq 0x3090
movl $0xa, %edi
callq 0x3030
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: function_help
const struct term *function_help(const struct term *parameters)
{
    (void)parameters;

    struct function_info *entry = function_table;
    while (entry->handler) {
        if (entry->description) {
            char buf[16];
            snprintf(buf, sizeof(buf), "%s/%d", entry->name, entry->arity);
            fprintf(stderr, "%-16s%s\n", buf, entry->description);
        }
        entry++;
    }

    fprintf(stderr, "\nType Ctrl-D to exit repl.\n");
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, 0xbd94(%rip)      # 0xe320
jne 0x25bb
movq 0xba5b(%rip), %rax      # 0xdff0
movq (%rax), %rcx
leaq 0x812a(%rip), %rdi      # 0xa6c9
pushq $0x1b
popq %rsi
pushq $0x1
popq %rdx
callq 0x24a0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbd4e(%rip), %r13      # 0xe310
leaq 0x80f1(%rip), %rbx      # 0xa6ba
movq %rsp, %r14
pushq $0x10
popq %r15
movq 0xba19(%rip), %rbp      # 0xdff0
leaq 0x80e2(%rip), %r12      # 0xa6c0
cmpq $0x0, 0x18(%r13)
jne 0x25f2
cmpq $0x0, 0x30(%r13)
leaq 0x20(%r13), %r13
jne 0x25de
jmp 0x258e
movq (%r13), %rcx
movl 0x8(%r13), %r8d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2210
movq (%rbp), %rdi
movq 0x18(%r13), %rcx
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2310
jmp 0x25e5
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/nerves_initramfs.c
// Function: cleanup_dir
void cleanup_dir(int dirfd, const char **skip_list)
{
    DIR *dir = fdopendir(dirfd);
    if (dir == NULL) {
        info("fdopendir failed");
        return;
    }

    for (struct dirent *dt = readdir(dir); dt != NULL; dt = readdir(dir)) {
        // Skip . and ..
        const char *name = dt->d_name;
        if (in_skip_list(name, skip_list))
            continue;

        if (dt->d_type & DT_DIR) {
            int fd = openat(dirfd, name, O_RDONLY);
            if (fd >= 0) {
                cleanup_dir(fd, nonroot_skip_list);
            } else {
                info("openat %s failed", name);
            }
            OK_OR_WARN(unlinkat(dirfd, name, AT_REMOVEDIR), "unlinkat directory  %s", name);
        } else {
            OK_OR_WARN(unlinkat(dirfd, name, 0), "unlinkat %s", name);
        }
    }

    closedir(dir);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, 0xc(%rsp)
callq 0x2430
testq %rax, %rax
je 0x2a87
movq %rax, %r14
movq %rax, %rdi
callq 0x2360
testq %rax, %rax
je 0x2a71
movq %rax, %r12
leaq 0x8(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x13(%r12), %r13
movq (%rbx), %rdi
testq %rdi, %rdi
setne %r15b
je 0x29de
movq %r13, %rsi
callq 0x2300
testl %eax, %eax
je 0x29de
movq 0x10(%rsp), %rbp
movq (%rbp), %rdi
testq %rdi, %rdi
setne %r15b
je 0x29de
movq %r13, %rsi
callq 0x2300
addq $0x8, %rbp
testl %eax, %eax
jne 0x29c1
testb %r15b, %r15b
jne 0x2a5d
testb $0x4, 0x12(%r12)
jne 0x2a02
movl 0xc(%rsp), %edi
movq %r13, %rsi
xorl %edx, %edx
callq 0x20e0
leaq 0x6669(%rip), %rdi      # 0x9069
jmp 0x2a4f
movl 0xc(%rsp), %edi
movq %r13, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x21b0
testl %eax, %eax
js 0x2a26
movl %eax, %edi
leaq 0xb891(%rip), %rsi      # 0xe2b0
callq 0x295c
jmp 0x2a37
leaq 0x6614(%rip), %rdi      # 0x9041
movq %r13, %rsi
xorl %eax, %eax
callq 0x3270
movl 0xc(%rsp), %edi
movq %r13, %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x20e0
leaq 0x6603(%rip), %rdi      # 0x9052
testl %eax, %eax
jns 0x2a5d
movq %r13, %rsi
xorl %eax, %eax
callq 0x3270
movq %r14, %rdi
callq 0x2360
movq %rax, %r12
testq %rax, %rax
jne 0x299f
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22a0
leaq 0x65a2(%rip), %rdi      # 0x9030
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3270
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/util.c
// Function: log_format
static void log_format(const char *fmt, va_list ap)
{
    char *line;
    int len = format_message(&line, fmt, ap);

    if (len >= 0) {
        log_write(line, len);
        free(line);
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
callq 0x2160
testl %eax, %eax
js 0x3335
movq 0x8(%rsp), %rdx
leaq 0x60ed(%rip), %rsi      # 0x940a
movq %rsp, %rdi
xorl %eax, %eax
callq 0x23b0
movl %eax, %ebx
movq 0x8(%rsp), %rdi
callq 0x2040
jmp 0x333a
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %ebx, %ebx
js 0x3352
movq (%rsp), %rdi
movl %ebx, %esi
callq 0x340d
movq (%rsp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/util.c
// Function: fatal
void fatal(const char *fmt, ...)
{
    log_write("\r\n\r\nFATAL ERROR:\r\n", 18);

    va_list ap;
    va_start(ap, fmt);
    log_format(fmt, ap);
    va_end(ap);

    log_write("\r\n\r\nCANNOT CONTINUE.\r\n", 22);

    // This will cause the kernel to panic.
    exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x33b9
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x6020(%rip), %rdi      # 0x93e0
movl $0x12, %esi
callq 0x340d
movq %rsp, %rsi
movq %r14, 0x10(%rsi)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x32f8
leaq 0x5ffa(%rip), %rdi      # 0x93f3
movl $0x16, %esi
callq 0x340d
movl $0x1, %edi
callq 0x2490
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/util.c
// Function: log_write
static void log_write(const char *str, size_t len)
{
    size_t ignore;
    int log_fd = open("/dev/kmsg", O_WRONLY | O_CLOEXEC);
    if (log_fd >= 0) {
        ignore = write(log_fd, str, len);
        close(log_fd);
    } else {
        ignore = write(STDERR_FILENO, str, len);
    }
    (void) ignore;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6003(%rip), %rdi      # 0x9421
movl $0x80001, %esi          # imm = 0x80001
xorl %eax, %eax
callq 0x2410
testl %eax, %eax
js 0x3448
movl %eax, %ebp
movl %eax, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2140
movl %ebp, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x2280
movl $0x2, %edi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x2140
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/util.c
// Function: trim_string_in_place
void trim_string_in_place(char *str)
{
    char *first = str;
    while (*first && isspace(*first))
        first++;

    char *last = first + strlen(first) - 1;
    while (last != first && isspace(*last))
        last--;

    size_t len = last - first + 1;
    memmove(str, first, len);
    str[len] = '\0';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %bpl
movq %rdi, %r14
testb %bpl, %bpl
je 0x3493
callq 0x2510
movq (%rax), %rax
movq %rbx, %r14
movsbq %bpl, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x3493
movb 0x1(%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x347c
movq %r14, %rdi
callq 0x2190
movq %rax, %r15
cmpq $0x1, %r15
je 0x34c1
callq 0x2510
movq (%rax), %rax
movsbq -0x1(%r14,%r15), %rcx
decq %r15
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x349e
addq %r14, %r15
jmp 0x34c4
movq %r14, %r15
subq %r14, %r15
leaq 0x1(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23d0
movb $0x0, 0x1(%rbx,%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/crc32.c
// Function: crc32buf
uint32_t crc32buf(const char *buf, size_t len)
{
      uint32_t crc32 = 0xFFFFFFFF;
      for ( ; len; --len, ++buf)
      {
            crc32 = UPDC32(*buf, crc32);
      }

      return ~crc32;
}

// Assembly:
testq %rsi, %rsi
je 0x3518
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
leaq 0x5f35(%rip), %rdx      # 0x9430
movb (%rdi,%rcx), %r8b
xorb %al, %r8b
movzbl %r8b, %r8d
shrl $0x8, %eax
xorl (%rdx,%r8,4), %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x34fb
notl %eax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/uboot_env.c
// Function: uboot_env_read
int uboot_env_read(struct uboot_env *env, const char *buffer)
{
    uboot_env_free(env);

    uint32_t expected_crc32 = ((uint8_t) buffer[0] | ((uint8_t) buffer[1] << 8) | ((uint8_t) buffer[2] << 16) | ((uint8_t) buffer[3] << 24));
    uint32_t actual_crc32 = crc32buf(buffer + 4, env->env_size - 4);
    if (expected_crc32 != actual_crc32)
        ERR_RETURN("U-boot environment CRC32 mismatch (expected 0x%08x; got 0x%08x)", expected_crc32, actual_crc32);

    const char *end = buffer + env->env_size;
    const char *name = buffer + 4;
    while (name != end && *name != '\0') {
        const char *endname = name + 1;
        for (;;) {
            if (endname == end || *endname == '\0')
                ERR_RETURN("Invalid U-boot environment");

            if (*endname == '=')
                break;

            endname++;
        }

        const char *value = endname + 1;
        const char *endvalue = value;
        for (;;) {
            if (endvalue == end)
                ERR_RETURN("Invalid U-boot environment");

            if (*endvalue == '\0')
                break;

            endvalue++;
        }

        struct uboot_name_value *pair = malloc(sizeof(struct uboot_name_value));
        pair->name = strndup(name, endname - name);
        pair->value = strndup(value, value - endvalue);
        pair->next = env->vars;
        env->vars = pair;

        name = endvalue + 1;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r12
callq 0x365a
movl (%rbx), %ebp
leaq 0x4(%rbx), %r14
movq (%r12), %rsi
addq $-0x4, %rsi
movq %r14, %rdi
callq 0x34e8
cmpl %eax, %ebp
jne 0x3630
addq (%r12), %rbx
leaq 0x630b(%rip), %r13      # 0x9870
movq %r12, 0x8(%rsp)
cmpq %rbx, %r14
je 0x3649
cmpb $0x0, (%r14)
je 0x3649
leaq 0x1(%r14), %rbp
xorl %r15d, %r15d
cmpq %rbx, %rbp
je 0x359c
movzbl (%rbp), %eax
incq %rbp
decq %r15
cmpl $0x3d, %eax
je 0x35a0
testl %eax, %eax
jne 0x3584
xorl %ebp, %ebp
jmp 0x35c6
cmpq %rbx, %rbp
je 0x35bd
xorl %r12d, %r12d
movq %rbp, %r13
cmpb $0x0, (%r13)
je 0x35d7
incq %r13
decq %r12
cmpq %rbx, %r13
jne 0x35ab
xorl %ebp, %ebp
leaq 0x62aa(%rip), %r13      # 0x9870
movq %r13, %rdi
xorl %eax, %eax
callq 0x3270
testb %bpl, %bpl
jne 0x356a
jmp 0x3642
movl $0x18, %edi
callq 0x2370
movq %rax, 0x10(%rsp)
negq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x22d0
movq 0x10(%rsp), %r14
movq %rax, (%r14)
movq %rbp, %rdi
movq %r12, %rsi
callq 0x22d0
movq %rax, 0x8(%r14)
movq 0x8(%rsp), %r12
movq 0x8(%r12), %rax
movq %rax, 0x10(%r14)
movq %r14, 0x8(%r12)
incq %r13
movb $0x1, %bpl
movq %r13, %r14
leaq 0x6242(%rip), %r13      # 0x9870
jmp 0x35d0
leaq 0x61f9(%rip), %rdi      # 0x9830
movl %ebp, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x3270
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x364b
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/uboot_env.c
// Function: uboot_env_free
void uboot_env_free(struct uboot_env *env)
{
    struct uboot_name_value *pair = env->vars;
    while (pair != NULL) {
        free(pair->name);
        free(pair->value);

        struct uboot_name_value *next = pair->next;
        free(pair);
        pair = next;
    }

    env->vars = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x3690
movq (%r14), %rdi
callq 0x2040
movq 0x8(%r14), %rdi
callq 0x2040
movq 0x10(%r14), %r15
movq %r14, %rdi
callq 0x2040
movq %r15, %r14
testq %r15, %r15
jne 0x366b
movq $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/uboot_env.c
// Function: uboot_env_setenv
int uboot_env_setenv(struct uboot_env *env, const char *name, const char *value)
{
    struct uboot_name_value *pair;
    for (pair = env->vars; pair != NULL; pair = pair->next) {
        if (strcmp(pair->name, name) == 0) {
            free(pair->value);
            pair->value = strdup(value);
            return 0;
        }
    }
    pair = malloc(sizeof(*pair));
    pair->name = strdup(name);
    pair->value = strdup(value);
    pair->next = env->vars;
    env->vars = pair;
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %r12
testq %r12, %r12
je 0x36cf
movq (%r12), %rdi
movq %r15, %rsi
callq 0x2300
testl %eax, %eax
je 0x3704
movq 0x10(%r12), %r12
jmp 0x36b3
movl $0x18, %edi
callq 0x2370
movq %rax, %r12
movq %r15, %rdi
callq 0x24c0
movq %rax, (%r12)
movq %rbx, %rdi
callq 0x24c0
movq %rax, 0x8(%r12)
movq 0x8(%r14), %rax
movq %rax, 0x10(%r12)
movq %r12, 0x8(%r14)
jmp 0x371b
movq 0x8(%r12), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x24c0
movq %rax, 0x8(%r12)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/uboot_env.c
// Function: uboot_env_unsetenv
int uboot_env_unsetenv(struct uboot_env *env, const char *name)
{
    struct uboot_name_value *prev = NULL;
    struct uboot_name_value *pair;
    for (pair = env->vars;
         pair != NULL;
         prev = pair, pair = pair->next) {
        if (strcmp(pair->name, name) == 0) {
            if (prev)
                prev->next = pair->next;
            else
                env->vars = pair->next;
            free(pair->name);
            free(pair->value);
            free(pair);
            break;
        }
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x37a7
movq %rsi, %r12
movq %rdi, %r14
movq (%rbx), %r15
movq %r15, %rdi
callq 0x2300
testl %eax, %eax
je 0x3776
movq %rbx, %r13
movq 0x10(%r13), %rbx
testq %rbx, %rbx
je 0x37a7
movq (%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2300
movq %r13, %rcx
movq %rbx, %r13
testl %eax, %eax
jne 0x3753
jmp 0x3778
xorl %ecx, %ecx
addq $0x8, %r14
leaq 0x10(%rcx), %rax
testq %rcx, %rcx
movq 0x10(%rbx), %rcx
cmoveq %r14, %rax
movq %rcx, (%rax)
movq %r15, %rdi
callq 0x2040
movq 0x8(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x2040
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/uboot_env.c
// Function: uboot_env_getenv
int uboot_env_getenv(struct uboot_env *env, const char *name, char **value)
{
    struct uboot_name_value *pair;
    for (pair = env->vars; pair != NULL; pair = pair->next) {
        if (strcmp(pair->name, name) == 0) {
            *value = strdup(pair->value);
            return 0;
        }
    }

    *value = NULL;
    ERR_RETURN("variable '%s' not found", name);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x37dc
movq (%r15), %rdi
movq %r14, %rsi
callq 0x2300
testl %eax, %eax
je 0x37fb
movq 0x10(%r15), %r15
jmp 0x37c2
movq $0x0, (%rbx)
leaq 0x60a1(%rip), %rdi      # 0x988b
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3809
movq 0x8(%r15), %rdi
callq 0x24c0
movq %rax, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: term_gc_heap
void term_gc_heap()
{
    struct term *old_variables;
    char *old_heap;

    if (!heap) {
        old_variables = NULL;
        old_heap = NULL;
    } else {
        old_heap = heap;
        old_variables = variables;
    }

    heap = malloc(HEAP_SIZE);
    memset(heap, 0, HEAP_SIZE);

    heap_index = 0;
    variables = NULL;

    while (old_variables) {
        set_variable(old_variables->var.name, term_dupe(old_variables->var.value));
        old_variables = old_variables->next;
    }

    if (old_heap)
        free(old_heap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x928e(%rip), %rbx      # 0xe640
testq %rbx, %rbx
sete %bpl
movq 0x9288(%rip), %r15      # 0xe648
movl $0x4098, %edi           # imm = 0x4098
callq 0x2370
movq %rax, 0x926f(%rip)      # 0xe640
movl $0x4098, %edx           # imm = 0x4098
movq %rax, %rdi
xorl %esi, %esi
callq 0x2240
movl $0x0, 0x9266(%rip)      # 0xe650
movq $0x0, 0x9253(%rip) # 0xe648
testq %r15, %r15
sete %al
orb %bpl, %al
jne 0x5421
movq 0x8(%r15), %r14
movq 0x10(%r15), %rdi
callq 0x550c
movq %r14, %rdi
movq %rax, %rsi
callq 0x5443
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x5400
testq %rbx, %rbx
je 0x5438
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2040
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: set_variable
void set_variable(const char *name, const struct term *value)
{
    struct term *var = get_variable_impl(name);
    if (var) {
        var->var.value = value;
    } else {
        struct term *rv = alloc_heap(sizeof(struct term));
        rv->kind = term_variable;
        rv->var.name = alloc_string(name);
        rv->var.value = value;
        rv->next = variables;
        variables = rv;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5b83
testq %rax, %rax
je 0x5467
movq %rbx, 0x10(%rax)
jmp 0x54fd
movslq 0x91e2(%rip), %rax      # 0xe650
addq $-0x4079, %rax          # imm = 0xBF87
cmpq $-0x409a, %rax          # imm = 0xBF66
ja 0x548a
leaq 0x4f0b(%rip), %rdi      # 0xa38e
xorl %eax, %eax
callq 0x3358
movq 0x91af(%rip), %r13      # 0xe640
movslq 0x91b8(%rip), %rbp      # 0xe650
movq %r13, %rax
addq %rbp, %rax
movq %rax, (%rsp)
leal 0x27(%rbp), %eax
andl $-0x8, %eax
movl %eax, 0x91a2(%rip)      # 0xe650
movl $0x5, (%r13,%rbp)
movq %r14, %rdi
callq 0x2190
leaq 0x1(%rax), %r15
movq %r15, %rdi
callq 0x559b
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2340
movq %r12, 0x8(%r13,%rbp)
movq %rbx, 0x10(%r13,%rbp)
movq 0x915b(%rip), %rax      # 0xe648
movq %rax, 0x18(%r13,%rbp)
movq (%rsp), %rax
movq %rax, 0x914b(%rip)      # 0xe648
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: term_dupe
struct term *term_dupe(const struct term *rv)
{
    switch (rv->kind) {
    case term_identifier:
        return term_new_identifier(rv->identifier);
    case term_string:
        return term_new_string(rv->string);
    case term_number:
        return term_new_number(rv->number);
    case term_boolean:
        return term_new_boolean(rv->boolean);
    default:
        // Not supported
        return NULL;
    }
}

// Assembly:
movl (%rdi), %eax
cmpq $0x3, %rax
ja 0x5547
leaq 0x4e19(%rip), %rcx      # 0xa334
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rdi
jmp 0x5765
movl 0x8(%rdi), %edi
jmp 0x554a
movzbl 0x8(%rdi), %edi
jmp 0x5714
movq 0x8(%rdi), %rdi
jmp 0x55e0
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: term_new_number
struct term *term_new_number(int value)
{
    struct term *rv = alloc_heap(sizeof(struct term));
    rv->kind = term_number;
    rv->number = value;
    return rv;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movslq 0x90fc(%rip), %rax      # 0xe650
addq $-0x4079, %rax          # imm = 0xBF87
cmpq $-0x409a, %rax          # imm = 0xBF66
ja 0x5570
leaq 0x4e25(%rip), %rdi      # 0xa38e
xorl %eax, %eax
callq 0x3358
movq 0x90c9(%rip), %rcx      # 0xe640
movslq 0x90d2(%rip), %rdx      # 0xe650
leaq (%rcx,%rdx), %rax
leal 0x27(%rdx), %esi
andl $-0x8, %esi
movl %esi, 0x90c2(%rip)      # 0xe650
movl $0x2, (%rcx,%rdx)
movl %ebx, 0x8(%rcx,%rdx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: alloc_heap
static void *alloc_heap(size_t num_bytes)
{
    if (heap_index + num_bytes > HEAP_SIZE)
        fatal("Program too large. Out of heap");

    void *addr = &heap[heap_index];
    heap_index = (heap_index + num_bytes + 7) & ~7;
    return addr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0x90aa(%rip), %rax      # 0xe650
addq %rdi, %rax
cmpq $0x4099, %rax           # imm = 0x4099
jb 0x55bf
leaq 0x4dd6(%rip), %rdi      # 0xa38e
xorl %eax, %eax
callq 0x3358
movslq 0x908a(%rip), %rcx      # 0xe650
movq %rcx, %rax
addq 0x9070(%rip), %rax      # 0xe640
addl %ebx, %ecx
addl $0x7, %ecx
andl $-0x8, %ecx
movl %ecx, 0x9072(%rip)      # 0xe650
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: term_new_string
struct term *term_new_string(const char *value)
{
    struct term *rv = alloc_heap(sizeof(struct term));
    rv->kind = term_string;
    rv->string = alloc_string(value);
    return rv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x905b(%rip), %rax      # 0xe650
addq $-0x4079, %rax          # imm = 0xBF87
cmpq $-0x409a, %rax          # imm = 0xBF66
ja 0x5611
leaq 0x4d84(%rip), %rdi      # 0xa38e
xorl %eax, %eax
callq 0x3358
movq 0x9028(%rip), %r13      # 0xe640
movslq 0x9031(%rip), %rbp      # 0xe650
movq %r13, %r14
addq %rbp, %r14
leal 0x27(%rbp), %eax
andl $-0x8, %eax
movl %eax, 0x901f(%rip)      # 0xe650
movl $0x1, (%r13,%rbp)
movq %rbx, %rdi
callq 0x2190
leaq 0x1(%rax), %r15
movq %r15, %rdi
callq 0x559b
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2340
movq %r12, 0x8(%r13,%rbp)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: term_new_qstring
struct term *term_new_qstring(const char *value)
{
    struct term *rv = alloc_heap(sizeof(struct term));
    rv->kind = term_string;
    rv->string = alloc_qstring(value);
    return rv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x8fc5(%rip), %rax      # 0xe650
addq $-0x4079, %rax          # imm = 0xBF87
cmpq $-0x409a, %rax          # imm = 0xBF66
ja 0x56a7
leaq 0x4cee(%rip), %rdi      # 0xa38e
xorl %eax, %eax
callq 0x3358
movq 0x8f92(%rip), %r13      # 0xe640
movslq 0x8f9b(%rip), %rbp      # 0xe650
movq %r13, %r14
addq %rbp, %r14
leal 0x27(%rbp), %eax
andl $-0x8, %eax
movl %eax, 0x8f89(%rip)      # 0xe650
movl $0x1, (%r13,%rbp)
incq %rbx
movq %rbx, %rdi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x559b
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2340
movb $0x0, -0x1(%r12,%r15)
movq %r12, 0x8(%r13,%rbp)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: term_new_boolean
struct term *term_new_boolean(bool value)
{
    struct term *rv = alloc_heap(sizeof(struct term));
    rv->kind = term_boolean;
    rv->boolean = value;
    return rv;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movslq 0x8f32(%rip), %rax      # 0xe650
addq $-0x4079, %rax          # imm = 0xBF87
cmpq $-0x409a, %rax          # imm = 0xBF66
ja 0x573a
leaq 0x4c5b(%rip), %rdi      # 0xa38e
xorl %eax, %eax
callq 0x3358
movq 0x8eff(%rip), %rcx      # 0xe640
movslq 0x8f08(%rip), %rdx      # 0xe650
leaq (%rcx,%rdx), %rax
leal 0x27(%rdx), %esi
andl $-0x8, %esi
movl %esi, 0x8ef8(%rip)      # 0xe650
movl $0x3, (%rcx,%rdx)
movb %bl, 0x8(%rcx,%rdx)
popq %rbx
retq