LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/test-linearize.c
// Function: main
int main(int argc, char **argv)
{
	struct string_list *filelist = NULL;
	char *file;

	clean_up_symbols(sparse_initialize(argc, argv, &filelist));
	FOR_EACH_PTR(filelist, file) {
		clean_up_symbols(sparse(file));
	} END_FOR_EACH_PTR(file);

	report_stats();
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rbx, %rdx
callq 0x11574
movq %rax, %rdi
callq 0xe494
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xe483
movq %rbx, %r14
xorl %r15d, %r15d
movl (%r14), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jge 0xe47a
movq 0x18(%r14,%r15,8), %rdi
cmpw $0x100, %ax             # imm = 0x100
jb 0xe468
testq %rdi, %rdi
je 0xe475
callq 0x11898
movq %rax, %rdi
callq 0xe494
incq %r15
jmp 0xe44c
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0xe449
callq 0x26934
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/test-linearize.c
// Function: clean_up_symbols
static void clean_up_symbols(struct symbol_list *list)
{
	struct symbol *sym;

	FOR_EACH_PTR(list, sym) {
		struct entrypoint *ep;

		expand_symbol(sym);
		ep = linearize_symbol(sym);
		if (!(fdump_ir & PASS_FINAL))
			continue;
		if (ep)
			show_entry(ep);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
testq %rdi, %rdi
je 0xe50a
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x52a6c(%rip), %r15     # 0x60f18
movq %rdi, %r12
xorl %r13d, %r13d
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jge 0xe4f7
movq 0x18(%r12,%r13,8), %r14
cmpw $0x100, %ax             # imm = 0x100
jb 0xe4cf
testq %r14, %r14
je 0xe4f2
movq %r14, %rdi
callq 0xe793
movq %r14, %rdi
callq 0x12fbf
testb $0x10, (%r15)
je 0xe4f2
testq %rax, %rax
je 0xe4f2
movq %rax, %rdi
callq 0x128fd
incq %r13
jmp 0xe4b2
movq 0x10(%r12), %r12
cmpq %rbx, %r12
jne 0xe4af
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/docmaker.cc
// Function: main
int main(int argc, char **argv) {
  if (argc != 2) {
    std::cerr << "Usage: " << argv[0] << " <directory>" << std::endl;
    return -1;
  }

  Parser parser;
  parser.add("uint8", U8);
  parser.add("uint16", U16);
  parser.add("uint32", U32);
  parser.add("int8", S8);
  parser.add("int16", S16);
  parser.add("int32", S32);

  if (!parser.run(argv[1])) {
    return -1;
  }
  Compiler compiler;
  if (!compiler.run(parser.symbols)) {
    return -1;
  }
  std::string outname;
  outname = argv[1];
  outname += ".dat";

  Output output;
  output.save(parser.symbols, outname);
  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
cmpl $0x2, %edi
jne 0x26f7
leaq 0x8(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x4a47(%rip), %rsi      # 0x7019
movq %rsp, %rdi
xorl %edx, %edx
callq 0x2964
leaq 0x4a3c(%rip), %rsi      # 0x701f
movq %rsp, %rdi
pushq $0x1
popq %rdx
callq 0x2964
leaq 0x4a31(%rip), %rsi      # 0x7026
movq %rsp, %rdi
pushq $0x2
popq %rdx
callq 0x2964
leaq 0x4a13(%rip), %rsi      # 0x701a
movq %rsp, %rdi
pushq $0x3
popq %rdx
callq 0x2964
leaq 0x4a07(%rip), %rsi      # 0x7020
movq %rsp, %rdi
pushq $0x4
popq %rdx
callq 0x2964
leaq 0x49fc(%rip), %rsi      # 0x7027
movq %rsp, %rdi
pushq $0x5
popq %rdx
callq 0x2964
movq 0x8(%rbx), %rsi
leaq 0x58(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0x2788
movq %rsp, %rdi
leaq 0x58(%rsp), %rsi
callq 0x2b4e
movl %eax, %ebp
leaq 0x58(%rsp), %rdi
callq 0x2100
testb %bpl, %bpl
je 0x2731
leaq 0x34(%rsp), %rdi
movq %rsp, %rsi
callq 0x4ddc
testb %al, %al
je 0x2731
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8(%rbx), %rsi
leaq 0x38(%rsp), %rdi
callq 0x23d0
leaq 0x4987(%rip), %rsi      # 0x702d
leaq 0x38(%rsp), %rdi
callq 0x23c0
leaq 0x80(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x78(%rsp), %rdi
movq %rsp, %rsi
leaq 0x38(%rsp), %rdx
callq 0x632c
leaq 0x78(%rsp), %rdi
callq 0x27ce
leaq 0x38(%rsp), %rdi
callq 0x2100
xorl %ebx, %ebx
jmp 0x2734
movq 0x88f2(%rip), %rdi      # 0xaff0
leaq 0x48ff(%rip), %rsi      # 0x7004
callq 0x21c0
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x21c0
leaq 0x48f0(%rip), %rsi      # 0x700c
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x2110
pushq $-0x1
popq %rbx
jmp 0x273c
pushq $-0x1
popq %rbx
movq %rsp, %rdi
callq 0x2832
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x27ce
jmp 0x275a
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x276b
jmp 0x2774
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x2100
jmp 0x2777
jmp 0x2774
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2832
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::find(Token const&)
Symbol *Parser::find(const Token &t) {
  std::string key = t.asStr;
  if (symbols.count(key) == 0) {
    Symbol s;
    s.name = key;
    s.referencedLine = t.curLine;
    s.referencedFile = t.filename;
    symbols.insert(std::pair<std::string, Symbol>(key, s));
  }
  return &symbols[key];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x22a0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3d7c
testq %rax, %rax
jne 0x2af1
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
andw $0x0, 0x10(%rax)
andl $0x0, 0x14(%rax)
movb %cl, 0x18(%rax)
andl $0x0, 0x1c(%rax)
leaq 0x60(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
andl $0x0, 0x10(%rax)
leaq 0x88(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x2130
leaq 0x50(%rsp), %rdi
movl 0x50(%r14), %eax
movl %eax, -0x4(%rdi)
addq $0x30, %r14
movq %r14, %rsi
callq 0x2130
leaq 0xa8(%rsp), %rdi
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
callq 0x3ddc
leaq 0xa8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4034
leaq 0xa8(%rsp), %rdi
callq 0x3e12
leaq 0x20(%rsp), %rdi
callq 0x28ae
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3e28
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2100
movq %rbx, %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x3e12
jmp 0x2b2e
jmp 0x2b2b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x28ae
jmp 0x2b3d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::run(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Parser::run(std::string directory) {
  DIR *dir = opendir(directory.c_str());
  if (!dir) {
    std::cerr << "Couldn't open directory: " << directory << std::endl;
    return false;
  }
  struct dirent *file;
  while ((file = readdir(dir)) != nullptr) {
    if (file->d_name[0] == '.') {
      continue;
    }
    std::string filename = directory + "/" + file->d_name;
    if (!load(filename)) {
      closedir(dir);
      return false;
    }
  }
  closedir(dir);
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, (%rsp)
movq (%rsi), %rdi
callq 0x2310
testq %rax, %rax
je 0x2c05
movq %rax, %r15
leaq 0x48(%rsp), %r13
leaq 0x8(%rsp), %rbp
leaq 0x28(%rsp), %r12
movq %r15, %rdi
callq 0x2320
testq %rax, %rax
je 0x2bf9
movq %rax, %r14
cmpb $0x2e, 0x13(%rax)
je 0x2b86
addq $0x13, %r14
movq %r13, %rdi
movq %rbx, %rsi
leaq 0x44ed(%rip), %rdx      # 0x709a
callq 0x3d43
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x3d24
movq %r13, %rdi
callq 0x2100
movq %r12, %rdi
movq %rbp, %rsi
callq 0x22a0
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x2c7e
movl %eax, %r14d
movq %r12, %rdi
callq 0x2100
testb %r14b, %r14b
je 0x2c2d
movq %rbp, %rdi
callq 0x2100
jmp 0x2b86
movq %r15, %rdi
callq 0x2350
movb $0x1, %al
jmp 0x2c41
movq 0x83e4(%rip), %rdi      # 0xaff0
leaq 0x446d(%rip), %rsi      # 0x7080
callq 0x21c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
movq %rax, %rdi
callq 0x2110
jmp 0x2c3f
movq %r15, %rdi
callq 0x2350
leaq 0x8(%rsp), %rdi
callq 0x2100
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2100
jmp 0x2c62
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x2c71
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Parser::load(std::string filename) {
  std::ifstream f(filename, std::ios::in | std::ios::binary | std::ios::ate);
  if (!f.is_open()) {
    return false;
  }
  std::streamoff len = f.tellg();
  char *data = new char[len + 1];
  f.seekg(0, std::ios::beg);
  f.read(data, len);
  f.close();

  data[len] = 0;

  File file;
  file.p = data;
  file.end = data + len;
  file.name = filename;
  file.curLine = 1;

  bool okay = parse(&file);
  delete [] data;
  return okay;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
pushq $0xe
popq %rdx
callq 0x2360
leaq 0xb8(%rsp), %rdi
callq 0x2080
testb %al, %al
je 0x2d4f
leaq 0x40(%rsp), %rdi
callq 0x2390
movq %rax, %r12
leaq 0x1(%rax), %rdi
callq 0x2030
movq %rax, %r15
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2290
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2240
leaq 0x40(%rsp), %rdi
callq 0x2070
movq %r15, %rax
addq %r12, %rax
xorl %ecx, %ecx
movb %cl, (%r15,%r12)
leaq 0x28(%rsp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
leaq 0x18(%rsp), %r12
movb %cl, (%rdx)
movq %r15, -0x28(%rdx)
movq %rax, -0x18(%rdx)
movq %r12, %rdi
movq %r14, %rsi
callq 0x2130
movq %rsp, %rsi
movl $0x1, 0x38(%rsi)
movq %rbx, %rdi
callq 0x2d92
movl %eax, %ebx
movq %r15, %rdi
callq 0x2250
movq %r12, %rdi
callq 0x2100
jmp 0x2d51
xorl %ebx, %ebx
leaq 0x40(%rsp), %rdi
callq 0x20a0
movl %ebx, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2d6e
movq %rax, %rbx
movq %r12, %rdi
callq 0x2100
jmp 0x2d80
jmp 0x2d7d
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::addDefinition(Token const&, File*)
bool Parser::addDefinition(const Token &def, File *file) {
  Symbol *s = find(def);
  if (s->isKnown) {
    error(file, "Duplicate definition: '%s'\nDefined in '%s' on line %d\n",
          s->name.c_str(), s->definedFile.c_str(), s->definedLine);
    return false;
  }
  s->definedLine = def.curLine;
  s->definedFile = def.filename;
  s->isKnown = true;
  Token token = file->token();
  switch (token.type) {
    case ENUM:
      return parseEnum(s, file);
    case SYMBOL:
      switch (token.asSym) {
        case '(':
          return parseFunc(s, file);
        case '=':
          return parseAlias(s, file);
        default:
          error(file, "Expected '=' or '(', found '%c'\n", token.asSym);
          return false;
      }
    case STRUCT:
      s->kind = isStruct;
      s->asStruct = new Struct();
      return parseStruct(s->asStruct, file);
    case UNION:
      s->kind = isUnion;
      s->asStruct = new Struct();
      return parseStruct(s->asStruct, file);
    default:
      error(file, "Parser error.\n");
      return false;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0x2a12
movq %rax, %r15
cmpb $0x1, 0x28(%rax)
jne 0x2ea2
movq (%r15), %rcx
movq 0x58(%r15), %r8
movl 0x50(%r15), %r9d
leaq 0x4222(%rip), %rdx      # 0x70b3
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2fbe
jmp 0x2f99
movl 0x50(%r12), %eax
movl %eax, 0x50(%r15)
addq $0x30, %r12
movq %r15, %rdi
addq $0x58, %rdi
movq %r12, %rsi
callq 0x2130
movb $0x1, 0x28(%r15)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x54d6
movl (%r12), %eax
decl %eax
cmpl $0x5, %eax
ja 0x2f54
leaq 0x4177(%rip), %rcx      # 0x705c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3074
jmp 0x2f50
pushq $0x3
jmp 0x2f23
movzbl 0x30(%rsp), %eax
cmpl $0x3d, %eax
je 0x2f69
cmpl $0x28, %eax
jne 0x2f79
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3348
jmp 0x2f50
pushq $0x4
popq %rax
movl %eax, 0x78(%r15)
pushq $0x18
popq %rdi
callq 0x21d0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x80(%r15)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x3764
movl %eax, %ebp
jmp 0x2f8f
leaq 0x41b0(%rip), %rdx      # 0x710b
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2fbe
jmp 0x2f8f
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x36be
jmp 0x2f50
movsbl %al, %ecx
leaq 0x4167(%rip), %rdx      # 0x70ea
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2fbe
leaq 0x8(%rsp), %rdi
callq 0x3d0a
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3d0a
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::error(File*, char const*, ...)
void Parser::error(File *f, const char *format, ...) {
  va_list args;
  va_start(args, format);

  fprintf(stderr, "Error: %s:%d: ", f->name.c_str(), f->curLine);
  vfprintf(stderr, format, args);

  va_end(args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %rbx
leaq 0x20(%rsp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x3019
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)
movq %rsp, %r14
movq %rdx, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%r14)
movq 0x7f90(%rip), %r15      # 0xafd0
movq (%r15), %rdi
movq 0x18(%rsi), %rdx
movl 0x38(%rsi), %ecx
leaq 0x4120(%rip), %rsi      # 0x7171
xorl %eax, %eax
callq 0x22d0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2280
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::parseAlias(Symbol*, File*)
bool Parser::parseAlias(Symbol *s, File *f) {
  Ref *ref = new Ref();
  s->asAlias = ref;
  s->kind = isAlias;
  if (!parseRef(ref, f)) {
    return false;
  }
  return f->token().expect(';');
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x30
popq %rdi
callq 0x21d0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
leaq 0x20(%rax), %rcx
orl $-0x1, 0xc(%rax)
movq %rcx, 0x10(%rax)
movb $0x0, 0x20(%rax)
movq %rax, 0x80(%r14)
movl $0x2, 0x78(%r14)
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x39a2
testb %al, %al
je 0x3740
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x54d6
pushq $0x3b
popq %rsi
movq %r14, %rdi
callq 0x5716
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x3d0a
jmp 0x3742
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3d0a
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::parseStruct(Struct*, File*)
bool Parser::parseStruct(Struct *s, File *f) {
  if (!f->token().expect('{')) {
    return false;
  }
  Token token;
  while ((token = f->token()).type == VAR || token.type == STRUCT ||
         token.type == UNION) {
    Field field;
    if (!parseField(&field, token, f)) {
      return false;
    }
    s->fields.push_back(field);
    token = f->token();
    if (!token.expect(";}")) {
      return false;
    }
    if (token.asSym == '}') {
      break;
    }
  }
  return token.expect('}');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %rbx
movq %rsi, (%rsp)
movq %rdi, %r15
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x54d6
pushq $0x7b
popq %rsi
movq %r12, %rdi
callq 0x5716
movl %eax, %ebp
leaq 0x38(%rsp), %rdi
callq 0x3d0a
testb %bpl, %bpl
je 0x38c3
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
movb %cl, 0x10(%rax)
andl $0x0, 0x14(%rax)
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x90(%rsp), %r12
leaq 0x38(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq %r12, %rdi
movq %rbx, %rsi
callq 0x54d6
movq %r13, %rdi
movq %r12, %rsi
callq 0x3e8e
cmpl $0x7, (%rax)
sete %al
movl 0x38(%rsp), %r14d
cmpl $0x5, %r14d
sete %cl
movq %r12, %rdi
orb %al, %cl
je 0x3820
callq 0x3d0a
jmp 0x382f
callq 0x3d0a
cmpl $0x6, %r14d
jne 0x38b2
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
andl $0x0, 0x2c(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x3c04
testb %al, %al
je 0x38c7
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x3f12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x54d6
movq %r13, %rdi
movq %r12, %rsi
callq 0x3e8e
movq %r12, %rdi
callq 0x3d0a
movq %r13, %rdi
leaq 0x38a8(%rip), %rsi      # 0x713a
callq 0x57b8
testb %al, %al
je 0x38c7
movb 0x60(%rsp), %r14b
movq %rbp, %rdi
callq 0x2100
cmpb $0x7d, %r14b
jne 0x37ea
leaq 0x38(%rsp), %rdi
pushq $0x7d
popq %rsi
callq 0x5716
movl %eax, %ebx
jmp 0x38d3
xorl %ebx, %ebx
jmp 0x38dd
leaq 0x8(%rsp), %rdi
callq 0x2100
xorl %ebx, %ebx
leaq 0x38(%rsp), %rdi
callq 0x3d0a
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x38f7
jmp 0x38f7
jmp 0x38fc
movq %rax, %rbx
jmp 0x3909
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2100
leaq 0x38(%rsp), %rdi
callq 0x3d0a
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::parseArgument(Argument*, Token const&, File*)
bool Parser::parseArgument(Argument *arg, const Token &def, File *f) {
  arg->key = def.asStr;
  if (!f->token().expect(':')) {
    return false;
  }
  return parseRef(&arg->ref, f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdx), %rsi
movq %r14, %rdi
callq 0x2130
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x54d6
pushq $0x3a
popq %rsi
movq %r12, %rdi
callq 0x5716
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x3d0a
testb %bpl, %bpl
je 0x397d
addq $0x20, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x39a2
jmp 0x397f
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3d0a
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::parseField(Field*, Token const&, File*)
bool Parser::parseField(Field *field, const Token &def, File *f) {
  if (def.type == STRUCT) {
    field->kind = isStruct;
    field->theStruct = new Struct();
    return parseStruct(field->theStruct, f);
  } else if (def.type == UNION) {
    field->kind = isUnion;
    field->theStruct = new Struct();
    return parseStruct(field->theStruct, f);
  } else {
    field->kind = isRef;
    field->key = def.asStr;
    if (!f->token().expect(':')) {
      return false;
    }
    field->ref = new Ref();
    return parseRef(field->ref, f);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl (%rdx), %eax
cmpl $0x6, %eax
je 0x3c2f
cmpl $0x5, %eax
jne 0x3c68
movl $0x3, 0x20(%r15)
jmp 0x3c37
movl $0x4, 0x20(%r15)
pushq $0x18
popq %rdi
callq 0x21d0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x28(%r15)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3764
movl $0x5, 0x20(%r15)
addq $0x8, %rdx
movq %r15, %rdi
movq %rdx, %rsi
callq 0x2130
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x54d6
pushq $0x3a
popq %rsi
movq %r12, %rdi
callq 0x5716
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x3d0a
testb %bpl, %bpl
je 0x3ce5
pushq $0x30
popq %rdi
callq 0x21d0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
orl $-0x1, 0xc(%rax)
leaq 0x20(%rax), %rcx
movq %rcx, 0x10(%rax)
movb $0x0, 0x20(%rax)
movq %rax, 0x28(%r15)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x39a2
jmp 0x3ce7
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3d0a
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/compiler.cc
// Function: Compiler::refErr(Symbol*, char const*, ...)
bool Compiler::refErr(Symbol *symbol, const char *format, ...) {
  va_list args;
  va_start(args, format);

  fprintf(stderr, "Error: %s:%d: ", symbol->referencedFile.c_str(),
          symbol->referencedLine);
  vfprintf(stderr, format, args);

  va_end(args);

  numErrors++;
  return numErrors < 10;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x5006
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)
movq %rsp, %r15
movq %rdx, 0x10(%r15)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%r15)
movq 0x5fa3(%rip), %r12      # 0xafd0
movq (%r12), %rdi
movq 0x30(%rsi), %rdx
movl 0x2c(%rsi), %ecx
leaq 0x2132(%rip), %rsi      # 0x7171
xorl %eax, %eax
callq 0x22d0
movq (%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2280
movl (%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0x9, %eax
setl %al
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/compiler.cc
// Function: Compiler::calculateSizes(Symbol*)
bool Compiler::calculateSizes(Symbol *s) {
  s->isSizing = true;
  switch (s->kind) {
    case isFunction:
      s->size = 4;
      break;
    case isAlias:
    case isRef:
      s->size = calcRefSize(s->asAlias, s);
      break;
    case isStruct:
      s->size = calcStructSize(s->asStruct, s);
      if (s->size < 0) {
        return false;
      }
      break;
    case isUnion:
      s->size = calcUnionSize(s->asStruct, s);
      if (s->size < 0) {
        return false;
      }
      break;
    case isEnum:
      if (!s->asEnum->type->isKnown) {
        refErr(s->asEnum->type, "Unknown type: '%s'\n",
               s->asEnum->type->name.c_str());
        return false;
      }
      if (!s->asEnum->type->isSized) {
        if (s->asEnum->type->isSizing) {
          defErr(s, "Recurisve type found: '%s'\n", s->name.c_str());
          return false;
        }
        if (!calculateSizes(s->asEnum->type)) {
          return false;
        }
      }
      s->size = s->asEnum->type->size;
      break;
    case isIntrinsic:
      switch (s->asIntrinsic) {
        case U8:
        case S8:
          s->size = 1;
          break;
        case U16:
        case S16:
          s->size = 2;
          break;
        case U32:
        case S32:
          s->size = 4;
          break;
        default:
          defErr(s, "Unknown intrinsic\n");
          return false;
      }
      break;
    default:
      defErr(s, "Uknown symbol type\n");
      return false;
  }
  s->isSized = true;
  s->isSizing = false;
  return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb $0x1, 0x20(%rsi)
movl 0x78(%rsi), %eax
cmpq $0x6, %rax
ja 0x50a6
leaq 0x2110(%rip), %rcx      # 0x719c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x80(%rbx), %rsi
movq %rbx, %rdx
callq 0x5254
jmp 0x50f6
leaq 0x21bd(%rip), %rdx      # 0x726a
jmp 0x5123
movl 0x80(%rbx), %eax
cmpq $0x6, %rax
jae 0x511c
leaq 0x20f6(%rip), %rcx      # 0x71b8
movl (%rcx,%rax,4), %eax
jmp 0x50f6
movq 0x80(%rbx), %rax
movq (%rax), %rsi
cmpb $0x0, 0x28(%rsi)
je 0x5131
cmpb $0x0, 0x21(%rsi)
je 0x5146
movl 0x24(%rsi), %eax
jmp 0x50f6
movq 0x80(%rbx), %rsi
movq %rbx, %rdx
callq 0x536a
jmp 0x510a
pushq $0x4
popq %rax
movl %eax, 0x24(%rbx)
jmp 0x5111
movq 0x80(%rbx), %rsi
movq %rbx, %rdx
callq 0x52c6
movl %eax, 0x24(%rbx)
testl %eax, %eax
js 0x517c
movw $0x100, 0x20(%rbx)      # imm = 0x100
movb $0x1, %bpl
jmp 0x517e
leaq 0x2134(%rip), %rdx      # 0x7257
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5188
jmp 0x517e
movq (%rsi), %rcx
leaq 0x2095(%rip), %rdx      # 0x71d0
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x4fa6
jmp 0x517e
cmpb $0x1, 0x20(%rsi)
jne 0x5164
movq (%rbx), %rcx
leaq 0x20e5(%rip), %rdx      # 0x723b
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5188
jmp 0x517e
callq 0x5072
testb %al, %al
je 0x517c
movq 0x80(%rbx), %rax
movq (%rax), %rsi
jmp 0x50dd
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/compiler.cc
// Function: Compiler::defErr(Symbol*, char const*, ...)
bool Compiler::defErr(Symbol *symbol, const char *format, ...) {
  va_list args;
  va_start(args, format);

  fprintf(stderr, "Error: %s:%d: ", symbol->definedFile.c_str(),
          symbol->definedLine);
  vfprintf(stderr, format, args);

  va_end(args);

  numErrors++;
  return numErrors < 10;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x51e8
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)
movq %rsp, %r15
movq %rdx, 0x10(%r15)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%r15)
movq 0x5dc1(%rip), %r12      # 0xafd0
movq (%r12), %rdi
movq 0x58(%rsi), %rdx
movl 0x50(%rsi), %ecx
leaq 0x1f50(%rip), %rsi      # 0x7171
xorl %eax, %eax
callq 0x22d0
movq (%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2280
movl (%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0x9, %eax
setl %al
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/compiler.cc
// Function: Compiler::calcRefSize(Ref*, Symbol*)
int32_t Compiler::calcRefSize(Ref *ref, Symbol *parent) {
  if (!ref->symbol->isKnown) {
    refErr(ref->symbol, "Unknown type: %s'\n", ref->symbol->name.c_str());
    return -1;
  }
  // prevent recursion errors
  if (ref->pointer > 0) {
    return 4;
  }
  if (!ref->symbol->isSized) {
    if (ref->symbol->isSizing) {
      defErr(parent, "Recursive type found: '%s'\n", parent->name.c_str());
      return -1;
    }
    if (!calculateSizes(ref->symbol)) {
      return -1;
    }
  }
  int32_t size = ref->symbol->size;
  if (ref->array >= 0) {
    size *= ref->array;
  }
  return size;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rsi
cmpb $0x0, 0x28(%rsi)
je 0x526b
cmpl $0x0, 0x8(%rbx)
jle 0x5281
pushq $0x4
jmp 0x527e
movq (%rsi), %rcx
leaq 0x2009(%rip), %rdx      # 0x727e
xorl %eax, %eax
callq 0x4fa6
pushq $-0x1
popq %rax
popq %rbx
retq
cmpb $0x0, 0x21(%rsi)
je 0x5298
movl 0xc(%rbx), %ecx
testl %ecx, %ecx
pushq $0x1
popq %rax
cmovnsl %ecx, %eax
imull 0x24(%rsi), %eax
jmp 0x527f
cmpb $0x1, 0x20(%rsi)
jne 0x52b7
movq (%rdx), %rcx
leaq 0x1fe9(%rip), %rax      # 0x7291
movq %rdx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x5188
jmp 0x527c
callq 0x5072
testb %al, %al
je 0x527c
movq (%rbx), %rsi
jmp 0x5287
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/compiler.cc
// Function: Compiler::calcStructSize(Struct*, Symbol*)
int32_t Compiler::calcStructSize(Struct *s, Symbol *parent) {
  int32_t size = 0;
  for (auto it = s->fields.begin(); it != s->fields.end(); it++) {
    switch (it->kind) {
      case isRef:
        it->size = calcRefSize(it->ref, parent);
        break;
      case isStruct:
        it->size = calcStructSize(it->theStruct, parent);
        break;
      case isUnion:
        it->size = calcUnionSize(it->theStruct, parent);
        break;
      default:
        defErr(parent, "Unknown field type: '%s'\n", it->key.c_str());
        return -1;
    }
    if (it->size < 0) {
      return -1;
    }
    size += it->size;
  }
  return size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq (%rsi), %r13
xorl %ebp, %ebp
pushq $-0x1
popq %rbx
cmpq 0x8(%r12), %r13
je 0x533d
movl 0x20(%r13), %eax
cmpl $0x3, %eax
je 0x531e
cmpl $0x4, %eax
je 0x530d
cmpl $0x5, %eax
jne 0x5341
movq 0x28(%r13), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x5254
jmp 0x532d
movq 0x28(%r13), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x536a
jmp 0x532d
movq 0x28(%r13), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x52c6
movl %eax, 0x24(%r13)
testl %eax, %eax
js 0x5359
addl %eax, %ebp
addq $0x30, %r13
jmp 0x52e2
movl %ebp, %ebx
jmp 0x5359
movq (%r13), %rcx
leaq 0x1f61(%rip), %rdx      # 0x72ad
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x5188
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_O2/mrkite[P]regs/docmaker/file.cc
// Function: File::skipWhitespace()
void File::skipWhitespace() {
  while (p < end && isspace(*p)) {
    if (*p == '\n') {
      curLine++;
    }
    p++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x10(%rdi), %r15
movl 0x38(%rdi), %ebp
cmpq %r15, %r14
jae 0x54cd
movb (%r14), %r12b
movsbl %r12b, %edi
callq 0x2050
testl %eax, %eax
je 0x54cd
cmpb $0xa, %r12b
jne 0x54c5
incl %ebp
movl %ebp, 0x38(%rbx)
incq %r14
movq %r14, (%rbx)
jmp 0x54a5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/file.cc
// Function: File::checkKeywords(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
TokenType File::checkKeywords(std::string keyword) {
  if (keyword == "enum") {
    return ENUM;
  } else if (keyword == "struct") {
    return STRUCT;
  } else if (keyword == "union") {
    return UNION;
  }
  return VAR;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x1bf8(%rip), %rsi      # 0x72c7
movq %rbx, %rdi
callq 0x58a8
testb %al, %al
je 0x56df
pushq $0x1
jmp 0x56f4
leaq 0x1be6(%rip), %rsi      # 0x72cc
movq %rbx, %rdi
callq 0x58a8
testb %al, %al
je 0x56f7
pushq $0x5
popq %rax
jmp 0x570c
leaq 0x1bd5(%rip), %rsi      # 0x72d3
movq %rbx, %rdi
callq 0x58a8
movzbl %al, %eax
xorl $0x7, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/file.cc
// Function: Token::expect(char)
bool Token::expect(char ch) {
  if (type != SYMBOL) {
    fprintf(stderr, "Error: %s:%d: ", filename.c_str(), curLine);
    fprintf(stderr, "'%c' expected\n", ch);
    return false;
  }
  if (asSym != ch) {
    fprintf(stderr, "Error: %s:%d: ", filename.c_str(), curLine);
    fprintf(stderr, "'%c' expected, found '%c' instead.\n", ch, asSym);
    return false;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
cmpl $0x3, (%rdi)
jne 0x573c
movb $0x1, %bl
cmpb %bpl, 0x28(%r14)
jne 0x5775
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x588d(%rip), %r15      # 0xafd0
movq (%r15), %rdi
movq 0x30(%r14), %rdx
movl 0x50(%r14), %ecx
leaq 0x1a1c(%rip), %rsi      # 0x7171
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22d0
movq (%r15), %rdi
movsbl %bpl, %edx
leaq 0x1b6d(%rip), %rsi      # 0x72d9
xorl %eax, %eax
callq 0x22d0
jmp 0x572f
movsbl %bpl, %ebp
movq 0x5850(%rip), %r15      # 0xafd0
movq (%r15), %rdi
movq 0x30(%r14), %rdx
movl 0x50(%r14), %ecx
leaq 0x19df(%rip), %rsi      # 0x7171
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22d0
movq (%r15), %rdi
movsbl 0x28(%r14), %ecx
leaq 0x1b3e(%rip), %rsi      # 0x72e8
movl %ebp, %edx
xorl %eax, %eax
callq 0x22d0
jmp 0x572f
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/file.cc
// Function: Token::expect(char const*)
bool Token::expect(const char *str) {
  if (type == SYMBOL) {
    for (const char *s = str; *s; s++) {
      if (*s == asSym) {
        return true;
      }
    }
  }
  fprintf(stderr, "Error: %s:%d: ", filename.c_str(), curLine);
  bool comma = false;
  for (const char *s = str; *s; s++) {
    fprintf(stderr, "%s'%c'", comma ? " or " : "", *s);
    comma = true;
  }
  if (type == SYMBOL) {
    fprintf(stderr, " expected, found '%c' instead\n", asSym);
  } else {
    fprintf(stderr, " expected\n");
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x3, (%rdi)
jne 0x57ed
movb 0x28(%rbx), %al
movq %r14, %rcx
movb (%rcx), %dl
testb %dl, %dl
je 0x57ed
incq %rcx
cmpb %al, %dl
jne 0x57d2
movb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x57dc(%rip), %r12      # 0xafd0
movq (%r12), %rdi
movq 0x30(%rbx), %rdx
movl 0x50(%rbx), %ecx
leaq 0x196b(%rip), %rsi      # 0x7171
xorl %eax, %eax
callq 0x22d0
leaq 0x18f6(%rip), %rdx      # 0x710a
leaq 0x1af1(%rip), %r15      # 0x730c
leaq 0x1af1(%rip), %r13      # 0x7313
movsbl (%r14), %ecx
testl %ecx, %ecx
je 0x5840
movq (%r12), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x22d0
incq %r14
movq %r13, %rdx
jmp 0x5822
cmpl $0x3, (%rbx)
movq (%r12), %rcx
jne 0x5865
movsbl 0x28(%rbx), %edx
leaq 0x1ac4(%rip), %rsi      # 0x7318
xorl %ebx, %ebx
movq %rcx, %rdi
xorl %eax, %eax
callq 0x22d0
jmp 0x57e1
leaq 0x1a71(%rip), %rdi      # 0x72dd
pushq $0xa
popq %rsi
pushq $0x1
popq %rdx
callq 0x23f0
xorl %ebx, %ebx
jmp 0x57e1
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/avl.cc
// Function: rotateRight(std::shared_ptr<AVLNode_>)
static AVLNode rotateRight(AVLNode y) {
  auto x = y->left;
  auto t = x->right;
  x->right = y;
  y->left = t;
  y->height = max(Height(y->left), Height(y->right)) + 1;
  x->height = max(Height(x->left), Height(x->right)) + 1;
  return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
addq $0x8, %rsi
callq 0x60da
movq (%rbx), %rsi
addq $0x18, %rsi
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x60da
movq (%rbx), %rdi
addq $0x18, %rdi
movq %r14, %rsi
callq 0x610e
movq (%r14), %rdi
addq $0x8, %rdi
movq %r15, %rsi
callq 0x610e
movq (%r14), %rsi
addq $0x8, %rsi
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x60da
movq (%r15), %rax
xorl %ebp, %ebp
movl $0x0, %r12d
testq %rax, %rax
je 0x5d37
movl 0x38(%rax), %r12d
movq (%r14), %rsi
addq $0x18, %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x60da
movq (%r15), %rax
testq %rax, %rax
je 0x5d56
movl 0x38(%rax), %ebp
cmpl %ebp, %r12d
cmovgl %r12d, %ebp
incl %ebp
movq (%r14), %rax
movl %ebp, 0x38(%rax)
leaq 0x28(%rsp), %rdi
callq 0x5412
leaq 0x38(%rsp), %rdi
callq 0x5412
movq (%rbx), %rsi
addq $0x8, %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x60da
movq (%r14), %rax
xorl %ebp, %ebp
movl $0x0, %r15d
testq %rax, %rax
je 0x5da1
movl 0x38(%rax), %r15d
movq (%rbx), %rsi
addq $0x18, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x60da
movq (%r14), %rax
testq %rax, %rax
je 0x5dbe
movl 0x38(%rax), %ebp
cmpl %ebp, %r15d
cmovgl %r15d, %ebp
incl %ebp
movq (%rbx), %rax
movl %ebp, 0x38(%rax)
leaq 0x8(%rsp), %rdi
callq 0x5412
leaq 0x18(%rsp), %rdi
callq 0x5412
leaq 0x48(%rsp), %rdi
callq 0x5412
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/avl.cc
// Function: rotateLeft(std::shared_ptr<AVLNode_>)
static AVLNode rotateLeft(AVLNode x) {
  auto y = x->right;
  auto t = y->left;
  y->left = x;
  x->right = t;
  x->height = max(Height(x->left), Height(x->right)) + 1;
  y->height = max(Height(y->left), Height(y->right)) + 1;
  return y;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
addq $0x18, %rsi
callq 0x60da
movq (%rbx), %rsi
addq $0x8, %rsi
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x60da
movq (%rbx), %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x610e
movq (%r14), %rdi
addq $0x18, %rdi
movq %r15, %rsi
callq 0x610e
movq (%r14), %rsi
addq $0x8, %rsi
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x60da
movq (%r15), %rax
xorl %ebp, %ebp
movl $0x0, %r12d
testq %rax, %rax
je 0x5e73
movl 0x38(%rax), %r12d
movq (%r14), %rsi
addq $0x18, %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x60da
movq (%r15), %rax
testq %rax, %rax
je 0x5e92
movl 0x38(%rax), %ebp
cmpl %ebp, %r12d
cmovgl %r12d, %ebp
incl %ebp
movq (%r14), %rax
movl %ebp, 0x38(%rax)
leaq 0x28(%rsp), %rdi
callq 0x5412
leaq 0x38(%rsp), %rdi
callq 0x5412
movq (%rbx), %rsi
addq $0x8, %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x60da
movq (%r14), %rax
xorl %ebp, %ebp
movl $0x0, %r15d
testq %rax, %rax
je 0x5edd
movl 0x38(%rax), %r15d
movq (%rbx), %rsi
addq $0x18, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x60da
movq (%r14), %rax
testq %rax, %rax
je 0x5efa
movl 0x38(%rax), %ebp
cmpl %ebp, %r15d
cmovgl %r15d, %ebp
incl %ebp
movq (%rbx), %rax
movl %ebp, 0x38(%rax)
leaq 0x8(%rsp), %rdi
callq 0x5412
leaq 0x18(%rsp), %rdi
callq 0x5412
leaq 0x48(%rsp), %rdi
callq 0x5412
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/avl.cc
// Function: AVL::walk(std::shared_ptr<AVLNode_>, unsigned int) const
AVLNode AVL::walk(AVLNode root, uint32_t key) const {
  AVLNode node = root;
  if (node == nullptr) {
    node = this->root;
  }
  while (node != nullptr && node->key != key) {
    if (key < node->key) {
      node = node->left;
    } else {
      node = node->right;
    }
  }
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rsi
callq 0x60da
cmpq $0x0, (%r14)
jne 0x5f5e
movq %r14, %rdi
movq %r15, %rsi
callq 0x610e
movq (%r14), %rax
testq %rax, %rax
je 0x5f7d
cmpl %ebx, (%rax)
je 0x5f7d
setbe %cl
movzbl %cl, %ecx
shll $0x4, %ecx
leaq (%rax,%rcx), %r15
addq $0x8, %r15
jmp 0x5f53
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/avl.cc
// Function: AVL::insert(std::vector<unsigned int, std::allocator<unsigned int>> const&)
bool AVL::insert(const std::vector<uint32_t> &keys) {
  AVLNode *parent = &root;
  for (int i = 0; i < keys.size(); i++) {
    *parent = insertOnce(*parent, keys[i]);
    auto node = walk(*parent, keys[i]);
    if (i == keys.size() - 1) {
      if (node->matched) {  // duplicate
        return false;
      }
      node->matched = true;
    }
    parent = &node->down;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rdi, %r15
movq %rax, %rbp
movq 0x8(%r14), %r13
subq (%r14), %r13
sarq $0x2, %r13
cmpq %rax, %r13
jbe 0x6095
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x60da
movq (%r14), %rax
movl (%rax,%rbp,4), %ecx
movq %rbx, %rsi
movq %rbp, %rbx
movq %rsp, %rdi
movq %rdi, %r12
movq %rsi, %rbp
leaq 0x18(%rsp), %rdx
callq 0x58b8
movq %r15, %rdi
movq %r12, %rsi
callq 0x62fc
leaq 0x8(%rsp), %rdi
callq 0x5412
leaq 0x20(%rsp), %rdi
callq 0x5412
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, 0x10(%rsp)
movq %r15, %rsi
callq 0x60da
movq (%r14), %rax
movl (%rax,%rbx,4), %ecx
movq %rsp, %rdi
movq %rbp, %r15
movq %rbp, %rsi
movq %r12, %rdx
callq 0x5f38
leaq 0x30(%rsp), %rdi
callq 0x5412
movq 0x8(%r14), %rcx
movq %r14, %rbp
subq (%r14), %rcx
sarq $0x2, %rcx
decq %rcx
movq (%rsp), %rax
movq %rbx, %r14
cmpq %rcx, %rbx
movq %r15, %rbx
jne 0x606b
cmpb $0x0, 0x3c(%rax)
je 0x6067
xorl %r12d, %r12d
movq 0x10(%rsp), %r15
jmp 0x6075
movb $0x1, 0x3c(%rax)
addq $0x28, %rax
movb $0x1, %r12b
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x5412
movq %r14, %rcx
leaq 0x1(%r14), %rax
testb %r12b, %r12b
movq %rbp, %r14
movq %rcx, %rbp
jne 0x5f9f
cmpq %rbp, %r13
setbe %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5412
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/output.cc
// Function: Output::ws(std::ostream*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Output::ws(std::ostream *f, const std::string &val) {
  uint8_t len = val.length() > 255 ? 255 : val.length();
  char v = len;
  f->write(&v, 1);
  f->write(val.c_str(), len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdx), %rax
movl $0xff, %r15d
cmpq %r15, %rax
cmovbq %rax, %r15
leaq 0xf(%rsp), %rsi
movb %r15b, (%rsi)
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x2270
movq (%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x2270
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/output.cc
// Function: Output::setEnum(std::ostream*, Enum const*)
void Output::setEnum(std::ostream *f, const Enum *e) {
  w32(f, lookup(e->type->name));
  w32(f, e->entries.size());
  for (auto it = e->entries.begin(); it != e->entries.end(); it++) {
    w32(f, it->second);
    ws(f, it->first);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdx), %rsi
callq 0x65ee
movq %r14, %rsi
movl %eax, %edx
callq 0x6576
movl 0x30(%rbx), %edx
movq %r14, %rsi
callq 0x6576
movq 0x20(%rbx), %r15
addq $0x10, %rbx
cmpq %rbx, %r15
je 0x6660
leaq 0x20(%r15), %r12
movl 0x40(%r15), %edx
movq %r14, %rsi
callq 0x6576
movq %r14, %rsi
movq %r12, %rdx
callq 0x65a2
movq %r15, %rdi
callq 0x2210
movq %rax, %r15
jmp 0x6633
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/output.cc
// Function: Output::setRef(std::ostream*, Ref const*)
void Output::setRef(std::ostream *f, const Ref *r) {
  if (r->symbol == nullptr) {
    w32(f, 0);
  } else {
    w32(f, lookup(r->symbol->name));
    w32(f, r->pointer);
    w32(f, r->array);
    ws(f, r->reg);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x66b9
movq %rdx, %rbx
callq 0x65ee
movq %r14, %rsi
movl %eax, %edx
callq 0x6576
movl 0x8(%rbx), %edx
movq %r14, %rsi
callq 0x6576
movl 0xc(%rbx), %edx
movq %r14, %rsi
callq 0x6576
addq $0x10, %rbx
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x65a2
movq %r14, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6576
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/output.cc
// Function: Output::setFunction(std::ostream*, Function const*)
void Output::setFunction(std::ostream *f, const Function *func) {
  w32(f, func->arguments.size());
  for (auto &arg : func->arguments) {
    setArgument(f, arg);
  }
  setRef(f, &func->retType);
  w32(f, func->signature.size());
  for (auto sig : func->signature) {
    w32(f, sig);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdx), %rax
subq (%rdx), %rax
pushq $0x50
popq %rcx
cqto
idivq %rcx
movl %eax, %edx
callq 0x6576
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r13, %r12
je 0x6768
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x683e
addq $0x50, %r12
jmp 0x674f
leaq 0x18(%r14), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x666c
movq 0x50(%r14), %rdx
subq 0x48(%r14), %rdx
shrq $0x2, %rdx
movq %rbx, %rsi
callq 0x6576
movq 0x48(%r14), %r15
movq 0x50(%r14), %r14
cmpq %r14, %r15
je 0x67a9
movl (%r15), %edx
movq %rbx, %rsi
callq 0x6576
addq $0x4, %r15
jmp 0x6793
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/docmaker/output.cc
// Function: Output::setField(std::ostream*, Field const&)
void Output::setField(std::ostream *f, const Field &field) {
  ws(f, field.key);
  w8(f, field.kind);
  w32(f, field.size);
  switch (field.kind) {
    case isRef:
      setRef(f, field.ref);
      break;
    case isStruct:
      setStruct(f, field.theStruct);
      break;
    case isUnion:
      setStruct(f, field.theStruct);
      break;
    default:
      std::cerr << "Unknown field type" << std::endl;
      exit(-1);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x65a2
movzbl 0x20(%r15), %edx
movq %rbx, %rsi
callq 0x658c
movl 0x24(%r15), %edx
movq %rbx, %rsi
callq 0x6576
movl 0x20(%r15), %eax
cmpl $0x3, %eax
je 0x6807
cmpl $0x4, %eax
je 0x6807
cmpl $0x5, %eax
jne 0x681b
movq 0x28(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x666c
movq 0x28(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x66ca
movq 0x47ce(%rip), %rdi      # 0xaff0
leaq 0xc41(%rip), %rsi       # 0x746a
callq 0x21c0
movq %rax, %rdi
callq 0x2110
pushq $-0x1
popq %rdi
callq 0x2220
// File: /workspace/github_c_makefile_star2_O2/eric-lo[P]3150/5-Signal/many_signal.c
// Function: main
int main(void) {
	int i;
	if(fork() == 0) {
		printf("Press Enter...\n");
		getchar();
		for(i = 0; i < 100000; i++)
			kill(getppid(), SIGQUIT);
	}
	else {
		signal(SIGQUIT, handler);
		sleep(1000);
		wait(NULL);
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x10b0
testl %eax, %eax
je 0x120d
leaq -0x2f(%rip), %rsi       # 0x11bc
pushq $0x3
popq %rdi
callq 0x1060
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x1090
xorl %edi, %edi
callq 0x10a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xdfc(%rip), %rdi       # 0x2010
callq 0x1030
callq 0x1050
movl $0x186a0, %ebp          # imm = 0x186A0
pushq $0x3
popq %rbx
subl $0x1, %ebp
jb 0x1204
callq 0x1080
movl %eax, %edi
movl %ebx, %esi
callq 0x1070
jmp 0x1226
// File: /workspace/github_c_makefile_star2_O2/ryancdotorg[P]bloomslice/bfstool.c
// Function: hash_file_type
char hash_file_type(FILE *stream) {
  int u, c = fgetc(stream);
  if (c < 0) return -1;
  u = ungetc(c, stream);
  if (u != c) return -1;
  if (c == '0') {
    return 'H'; // type is hex
  } else if (c == 0) {
    return 'B'; // type is binary
  } else {
    return 0; // cannot determine type
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x10f0
movb $-0x1, %bl
testl %eax, %eax
js 0x13c1
movl %eax, %ebp
movl %eax, %edi
movq %r14, %rsi
callq 0x1180
cmpl %ebp, %eax
jne 0x13c1
xorl %eax, %eax
testl %ebp, %ebp
pushq $0x42
popq %rcx
cmovnel %eax, %ecx
cmpl $0x30, %ebp
pushq $0x48
popq %rbx
cmovnel %ecx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ryancdotorg[P]bloomslice/bloomutl.c
// Function: bloom_size_to_mask
uint64_t bloom_size_to_mask(size_t sz) {
  size_t bz = sz - FOOTER_BYTES;
  if (sz == LEGACY_BYTES) {
    return 1;
  } else if (sz == SINGLE_BYTES) {
    return 1;
  } else if (bz & (bz - 1)) {
    return 0;
  } else {
    return (bz<<3) - 1;
  }
}

// Assembly:
pushq $0x1
popq %rax
cmpq $0x1d, %rdi
je 0x55d4
cmpq $0x20000000, %rdi       # imm = 0x20000000
je 0x55d4
leaq -0x9(%rdi), %rax
addq $-0xa, %rdi
testq %rdi, %rax
je 0x55cc
xorl %eax, %eax
retq
leaq -0x1(,%rax,8), %rax
retq