LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/vdedios[P]minishell/libft/ft_strcmp.c
// Function: ft_strcmp
size_t	ft_strcmp(char *s1, char *s2)
{
	while (*s2)
	{
		if (*s1 != *s2)
			return (0);
		s1++;
		s2++;
	}
	if (*s1 != *s2)
		return (0);
	return (1);
}

// Assembly:
movb (%rsi), %cl
testb %cl, %cl
je 0x5493
incq %rsi
xorl %eax, %eax
cmpb %cl, (%rdi)
jne 0x549b
incq %rdi
movb (%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0x5483
xorl %eax, %eax
cmpb $0x0, (%rdi)
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/vdedios[P]minishell/libft/ft_strnstr.c
// Function: ft_strnstr
char	*ft_strnstr(const char *haystack, const char *needle, size_t len)
{
	int i;
	int j;

	i = 0;
	while (haystack[i] != '\0' && i < (int)len)
	{
		j = 0;
		while (needle[j] && haystack[i + j] == needle[j] && (i + j) < (int)len)
			j++;
		if (!needle[j])
			return ((char *)&haystack[i]);
		j = 0;
		i++;
	}
	if (!needle[0])
		return ((char *)haystack);
	return (NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rax
testl %edx, %edx
jle 0x5521
cmpb $0x0, (%rax)
je 0x5521
movb (%rsi), %cl
testb %cl, %cl
sete %dil
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
leaq 0x1(%rsi), %r9
movl $0x1, %r10d
xorl %r8d, %r8d
testb %cl, %cl
je 0x552f
movl %edi, %r11d
cmpq %rdx, %r8
jae 0x5505
movl %edi, %r11d
cmpb %cl, (%rax,%r8)
jne 0x5505
movq %r9, %rbx
movq %r10, %r14
movb (%rbx), %bpl
testb %bpl, %bpl
sete %r11b
je 0x552c
cmpq %rdx, %r14
jae 0x5505
leaq 0x1(%r14), %r15
incq %rbx
cmpb %bpl, (%rax,%r14)
movq %r15, %r14
je 0x54e4
testb %r11b, %r11b
jne 0x552c
leaq 0x1(%r8), %r11
cmpq %rdx, %r11
jae 0x5521
incq %r10
cmpb $0x0, 0x1(%rax,%r8)
movq %r11, %r8
jne 0x54c9
xorl %ecx, %ecx
cmpb $0x0, (%rsi)
cmovneq %rcx, %rax
jmp 0x552f
addq %r8, %rax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq $0x0, (%rbx)
movq %rbx, %rdx
callq 0x129f2
movq %rax, %rdi
callq 0xf671
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xf660
movq %rbx, %r14
movzwl (%r14), %eax
testb %al, %al
jle 0xf657
xorl %r15d, %r15d
movq 0x18(%r14,%r15,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xf63b
testq %rdi, %rdi
je 0xf648
callq 0x12d32
movq %rax, %rdi
callq 0xf671
incq %r15
movl (%r14), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jl 0xf627
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0xf61c
callq 0x2c15c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xf6f2
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x5988f(%rip), %r15     # 0x68f18
movq %rdi, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0xf6df
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %r14
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xf6ac
testq %r14, %r14
je 0xf6cf
movq %r14, %rdi
callq 0xf98c
movq %r14, %rdi
callq 0x14707
testb $0x10, (%r15)
je 0xf6cf
testq %rax, %rax
je 0xf6cf
movq %rax, %rdi
callq 0x13e9c
incq %r13
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jl 0xf698
movq 0x10(%r12), %r12
cmpq %rbx, %r12
jne 0xf68c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x349b
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 0xab0e(%rip), %r15      # 0xdfd0
movq (%r15), %rdi
movq 0x18(%rsi), %rdx
movl 0x38(%rsi), %ecx
leaq 0x6c9e(%rip), %rsi      # 0xa171
xorl %eax, %eax
callq 0x32f0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x32b0
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x359a
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 0xaa0f(%rip), %r12      # 0xdfd0
movq (%r12), %rdi
movq 0x30(%rsi), %rdx
movl 0x2c(%rsi), %ecx
leaq 0x6b9e(%rip), %rsi      # 0xa171
xorl %eax, %eax
callq 0x32f0
movq (%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x32b0
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_O1/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 0x3666
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 0xa943(%rip), %r12      # 0xdfd0
movq (%r12), %rdi
movq 0x58(%rsi), %rdx
movl 0x50(%rsi), %ecx
leaq 0x6ad2(%rip), %rsi      # 0xa171
xorl %eax, %eax
callq 0x32f0
movq (%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x32b0
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
// File: /workspace/github_c_makefile_star2_O1/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::add(char const*, Intrinsic)
void Parser::add(const char *token, Intrinsic value) {
  Token t;
  t.asStr = token;
  t.filename = "(intrinsic)";
  t.curLine = 0;
  Symbol *symbol = find(t);
  symbol->isKnown = true;
  symbol->definedLine = symbol->referencedLine;
  symbol->definedFile = symbol->referencedFile;
  symbol->kind = isIntrinsic;
  symbol->asIntrinsic = value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
xorl %eax, %eax
movq %rax, -0x8(%r13)
movb %al, (%r13)
movb %al, 0x10(%r13)
movl $0x0, 0x14(%r13)
leaq 0x40(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb %al, (%rbp)
movq %rsi, %rdi
callq 0x3110
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
movq %rax, %r8
callq 0x3360
leaq 0x30(%rsp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x6174(%rip), %rcx      # 0xa074
movl $0xb, %r8d
xorl %esi, %esi
callq 0x3360
movq %rsp, %rsi
movl $0x0, 0x50(%rsi)
movq %r14, %rdi
callq 0x3f9e
movq %rax, %r14
movb $0x1, 0x28(%rax)
movl 0x2c(%rax), %eax
movl %eax, 0x50(%r14)
leaq 0x30(%r14), %rsi
movq %r14, %rdi
addq $0x58, %rdi
callq 0x3140
movl $0x0, 0x78(%r14)
movl %ebx, 0x80(%r14)
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3f63
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3210
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3f7a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3f8b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x603a
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6368
movq %rbx, %rdi
movq %r15, %rsi
callq 0x63f8
leaq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jne 0x4159
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
movw $0x0, 0x10(%r15)
movl %eax, 0x14(%r15)
movb %al, 0x18(%r15)
movl %eax, 0x1c(%r15)
leaq 0x68(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
movl %eax, 0x10(%r13)
leaq 0x90(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb %al, (%rbp)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3140
leaq 0x58(%rsp), %rdi
movl 0x50(%r14), %eax
movl %eax, -0x4(%rdi)
addq $0x30, %r14
movq %r14, %rsi
callq 0x3140
leaq 0xb0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x6072
leaq 0xb0(%rsp), %rsi
movq %rbx, %rdi
callq 0x6482
leaq 0x138(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40ab
movq 0x138(%rsp), %rsi
incq %rsi
callq 0x3210
leaq 0x110(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40cc
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x3210
leaq 0xe0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40ed
movq 0xe0(%rsp), %rsi
incq %rsi
callq 0x3210
leaq 0xc0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x410e
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x3210
movq 0x80(%rsp), %rdi
cmpq %rbp, %rdi
je 0x412b
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x3210
movq 0x58(%rsp), %rdi
cmpq %r13, %rdi
je 0x4142
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x3210
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x4159
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3210
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6236
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4180
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x617e
jmp 0x41ac
jmp 0x41a9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x61e8
jmp 0x41bb
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x41d2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xe, %edx
callq 0x3390
leaq 0xb8(%rsp), %rdi
callq 0x3090
testb %al, %al
je 0x452c
leaq 0x40(%rsp), %rdi
callq 0x33d0
movq %rax, %r12
leaq 0x1(%rax), %rdi
callq 0x3030
movq %rax, %r15
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x32c0
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3280
leaq 0x40(%rsp), %rdi
callq 0x3080
movq %r15, %rax
addq %r12, %rax
xorl %ecx, %ecx
movb %cl, (%r15,%r12)
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb %cl, (%r12)
movq %r15, -0x28(%r12)
movq %rax, -0x18(%r12)
movq %r14, %rsi
callq 0x3140
movq %rsp, %rsi
movl $0x1, 0x38(%rsi)
movq %rbx, %rdi
callq 0x457e
movl %eax, %ebx
movq %r15, %rdi
callq 0x3290
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x452e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x452e
xorl %ebx, %ebx
leaq 0x40(%rsp), %rdi
callq 0x30b0
movl %ebx, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x454b
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x456c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x456c
jmp 0x4569
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_c_makefile_star2_O1/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::parse(File*)
bool Parser::parse(File *file) {
  Token token;
  while ((token = file->token()).type != END) {
    switch (token.type) {
      case VAR:
        if (!addDefinition(token, file)) {
          return false;
        }
        break;
      default:
        error(file, "Expected a definition\n");
        return false;
    }
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
movb %al, 0x10(%rcx)
movl $0x0, 0x14(%rcx)
leaq 0x48(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x78(%rsp), %rbp
leaq 0x60(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x78ce
movl 0x60(%rsp), %eax
movl %eax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x3270
movq 0x88(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x3270
movl 0xb0(%rsp), %eax
movl %eax, 0x58(%rsp)
movl 0x8(%rsp), %r13d
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x4644
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x3210
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x465b
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x3210
testl %r13d, %r13d
je 0x467d
cmpl $0x7, 0x8(%rsp)
jne 0x46cd
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x46f8
testb %al, %al
jne 0x45ce
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x4699
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3210
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x46b5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3210
testl %r13d, %r13d
sete %al
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x59c8(%rip), %rdx      # 0xa09c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3440
jmp 0x467d
jmp 0x46e2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x603a
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x3f9e
movq %rax, %r15
cmpb $0x1, 0x28(%rax)
je 0x4832
movl 0x50(%r12), %eax
movl %eax, 0x50(%r15)
addq $0x30, %r12
movq %r15, %rdi
addq $0x58, %rdi
movq %r12, %rsi
callq 0x3140
movb $0x1, 0x28(%r15)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x78ce
movl (%r12), %eax
decl %eax
cmpl $0x5, %eax
ja 0x4852
leaq 0x58f6(%rip), %rcx      # 0xa05c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x489a
jmp 0x47bc
movl $0x3, %eax
jmp 0x478b
movl $0x4, %eax
movl %eax, 0x78(%r15)
movl $0x18, %edi
callq 0x3200
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x80(%r15)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x55a8
movl %eax, %ebp
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x47d9
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3210
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x47f4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3210
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movzbl 0x30(%rsp), %eax
cmpl $0x3d, %eax
je 0x4822
cmpl $0x28, %eax
jne 0x486a
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4e2a
jmp 0x47bc
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x54c8
jmp 0x47bc
movq (%r15), %rcx
movq 0x58(%r15), %r8
movl 0x50(%r15), %r9d
leaq 0x586f(%rip), %rdx      # 0xa0b3
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3440
jmp 0x47f4
leaq 0x58b2(%rip), %rdx      # 0xa10b
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3440
jmp 0x47be
movsbl %al, %ecx
leaq 0x5876(%rip), %rdx      # 0xa0ea
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3440
jmp 0x47be
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x603a
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x30, %edi
callq 0x3200
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
leaq 0x20(%rax), %rcx
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movb $0x0, 0x20(%rax)
movq %rax, 0x80(%r14)
movl $0x2, 0x78(%r14)
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x59ca
testb %al, %al
je 0x5585
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x78ce
movq %r14, %rdi
movl $0x3b, %esi
callq 0x7b5e
movl %eax, %ebx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5568
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3210
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5587
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x5587
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x603a
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_c_makefile_star2_O1/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 0x3140
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x78ce
movq %r12, %rdi
movl $0x3a, %esi
callq 0x7b5e
movl %eax, %ebp
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5971
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3210
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x598c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3210
testb %bpl, %bpl
je 0x59a5
addq $0x20, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x59ca
jmp 0x59a7
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 0x603a
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x5f1f
cmpl $0x5, %eax
jne 0x5f5d
movl $0x3, 0x20(%r15)
jmp 0x5f27
movl $0x4, 0x20(%r15)
movl $0x18, %edi
callq 0x3200
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $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 0x55a8
movl $0x5, 0x20(%r15)
addq $0x8, %rdx
movq %r15, %rdi
movq %rdx, %rsi
callq 0x3140
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x78ce
movq %r12, %rdi
movl $0x3a, %esi
callq 0x7b5e
movl %eax, %ebp
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5fae
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3210
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5fc9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3210
testb %bpl, %bpl
je 0x6015
movl $0x30, %edi
callq 0x3200
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
leaq 0x20(%rax), %rcx
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movb $0x0, 0x20(%rax)
movq %rax, 0x28(%r15)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x59ca
jmp 0x6017
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 0x603a
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x75fb
leaq 0x2c5a(%rip), %rcx      # 0xa19c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x80(%rbx), %rsi
movq %rbx, %rdx
callq 0x7646
jmp 0x75ca
movl 0x80(%rbx), %eax
cmpq $0x6, %rax
jae 0x7604
leaq 0x2c45(%rip), %rcx      # 0xa1b8
movl (%rcx,%rax,4), %eax
jmp 0x75ca
movq 0x80(%rbx), %rax
movq (%rax), %rsi
cmpb $0x0, 0x28(%rsi)
je 0x7619
cmpb $0x0, 0x21(%rsi)
jne 0x75a5
cmpb $0x1, 0x20(%rsi)
je 0x762e
callq 0x7524
testb %al, %al
je 0x75f7
movq 0x80(%rbx), %rax
movq (%rax), %rax
movl 0x24(%rax), %eax
jmp 0x75ca
movq 0x80(%rbx), %rsi
movq %rbx, %rdx
callq 0x776a
jmp 0x75de
movl $0x4, %eax
movl %eax, 0x24(%rbx)
jmp 0x75e5
movq 0x80(%rbx), %rsi
movq %rbx, %rdx
callq 0x76c2
movl %eax, 0x24(%rbx)
testl %eax, %eax
js 0x75f7
movw $0x100, 0x20(%rbx)      # imm = 0x100
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x75ee
leaq 0x2c68(%rip), %rdx      # 0xa26a
jmp 0x760b
leaq 0x2c4c(%rip), %rdx      # 0xa257
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3606
jmp 0x75ee
movq (%rsi), %rcx
leaq 0x2bad(%rip), %rdx      # 0xa1d0
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x353a
jmp 0x75ee
movq (%rbx), %rcx
leaq 0x2c03(%rip), %rdx      # 0xa23b
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3606
jmp 0x75ee
// File: /workspace/github_c_makefile_star2_O1/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 0x7690
movl $0x4, %eax
cmpl $0x0, 0x8(%rbx)
jg 0x76a6
cmpb $0x0, 0x21(%rsi)
jne 0x767a
cmpb $0x1, 0x20(%rsi)
je 0x76a8
callq 0x7524
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %cl, %cl
je 0x76a6
movq (%rbx), %rcx
movl 0xc(%rbx), %edx
testl %edx, %edx
movl $0x1, %eax
cmovnsl %edx, %eax
imull 0x24(%rcx), %eax
jmp 0x76a6
movq (%rsi), %rcx
leaq 0x2be4(%rip), %rdx      # 0xa27e
xorl %eax, %eax
callq 0x353a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
movq (%rdx), %rcx
leaq 0x2bdf(%rip), %rax      # 0xa291
movq %rdx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3606
jmp 0x76a1
nop
// File: /workspace/github_c_makefile_star2_O1/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), %r14
movq 0x10(%rdi), %r15
cmpq %r15, %r14
jae 0x78c4
movq %rdi, %rbx
movl 0x38(%rdi), %ebp
movb (%r14), %r12b
movsbl %r12b, %edi
callq 0x3060
testl %eax, %eax
je 0x78c4
cmpb $0xa, %r12b
jne 0x78b9
incl %ebp
movl %ebp, 0x38(%rbx)
incq %r14
movq %r14, (%rbx)
cmpq %r15, %r14
jne 0x789e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x27ba(%rip), %rsi      # 0xa2c7
movq %rbx, %rdi
callq 0x30d0
testl %eax, %eax
je 0x7b48
leaq 0x27ac(%rip), %rsi      # 0xa2cc
movq %rbx, %rdi
callq 0x30d0
testl %eax, %eax
je 0x7b4f
leaq 0x27a0(%rip), %rsi      # 0xa2d3
movq %rbx, %rdi
callq 0x30d0
cmpl $0x1, %eax
movl $0x7, %eax
sbbl $0x0, %eax
jmp 0x7b54
movl $0x1, %eax
jmp 0x7b54
movl $0x5, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movq %rdi, %rcx
cmpl $0x3, (%rdi)
jne 0x7b71
movb $0x1, %al
cmpb %sil, 0x28(%rcx)
jne 0x7b7f
popq %rcx
retq
movzbl %sil, %esi
movq %rcx, %rdi
callq 0x36d1
jmp 0x7b8f
leaq 0x28(%rcx), %rdx
movzbl %sil, %edi
movq %rcx, %rsi
callq 0x3714
xorl %eax, %eax
jmp 0x7b6f
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
cmpl $0x3, (%rdi)
jne 0x7bbf
movb 0x28(%rdi), %al
movq %rsi, %rcx
movb (%rcx), %dl
testb %dl, %dl
je 0x7bb1
incq %rcx
cmpb %al, %dl
jne 0x7ba4
movb $0x1, %al
testb %dl, %dl
je 0x7bbf
andb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
leaq 0xf(%rsp), %rbx
movq %rbx, %rdx
callq 0x3758
movb (%rbx), %al
jmp 0x7bb7
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rax), %rcx
movq %rcx, (%rdi)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x81dd
movq 0x5df9(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x81d9
incl 0x8(%rax)
jmp 0x81dd
lock
incl 0x8(%rax)
movq (%rbx), %rax
movq 0x18(%rax), %rcx
leaq 0x8(%rsp), %r15
movq %rcx, -0x8(%r15)
movq 0x20(%rax), %rax
movq %rax, (%r15)
testq %rax, %rax
je 0x820e
movq 0x5dc8(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x820a
incl 0x8(%rax)
jmp 0x820e
lock
incl 0x8(%rax)
movq (%rbx), %rdi
movq (%r14), %rax
movq %rax, 0x18(%rdi)
addq $0x20, %rdi
leaq 0x8(%r14), %rsi
callq 0x873a
movq (%r14), %rdi
movq (%rsp), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq %r15, %rsi
callq 0x873a
movq (%r14), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %r15
testq %r15, %r15
je 0x8263
movq 0x5d75(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x825e
incl 0x8(%r15)
jmp 0x8263
lock
incl 0x8(%r15)
testq %rax, %rax
je 0x826d
movl 0x38(%rax), %eax
jmp 0x826f
xorl %eax, %eax
movq (%r14), %rdx
movq 0x18(%rdx), %rcx
movq 0x20(%rdx), %rdi
testq %rdi, %rdi
je 0x8294
movq 0x5d42(%rip), %rdx      # 0xdfc8
cmpb $0x0, (%rdx)
je 0x8290
incl 0x8(%rdi)
jmp 0x8294
lock
incl 0x8(%rdi)
testq %rcx, %rcx
je 0x829e
movl 0x38(%rcx), %ecx
jmp 0x82a0
xorl %ecx, %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
incl %ecx
movq (%r14), %rax
movl %ecx, 0x38(%rax)
testq %rdi, %rdi
je 0x82b7
callq 0x7814
testq %r15, %r15
je 0x82c4
movq %r15, %rdi
callq 0x7814
movq (%rbx), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %r14
testq %r14, %r14
je 0x82eb
movq 0x5ced(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x82e6
incl 0x8(%r14)
jmp 0x82eb
lock
incl 0x8(%r14)
testq %rax, %rax
je 0x82f5
movl 0x38(%rax), %eax
jmp 0x82f7
xorl %eax, %eax
movq (%rbx), %rdx
movq 0x18(%rdx), %rcx
movq 0x20(%rdx), %rdi
testq %rdi, %rdi
je 0x831c
movq 0x5cba(%rip), %rdx      # 0xdfc8
cmpb $0x0, (%rdx)
je 0x8318
incl 0x8(%rdi)
jmp 0x831c
lock
incl 0x8(%rdi)
testq %rcx, %rcx
je 0x8326
movl 0x38(%rcx), %ecx
jmp 0x8328
xorl %ecx, %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
incl %ecx
movq (%rbx), %rax
movl %ecx, 0x38(%rax)
testq %rdi, %rdi
je 0x833f
callq 0x7814
testq %r14, %r14
je 0x834c
movq %r14, %rdi
callq 0x7814
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x835b
callq 0x7814
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x18(%rax), %rcx
movq %rcx, (%rdi)
movq 0x20(%rax), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x83a3
movq 0x5c33(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x839f
incl 0x8(%rax)
jmp 0x83a3
lock
incl 0x8(%rax)
movq (%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x8(%rsp), %r15
movq %rcx, -0x8(%r15)
movq 0x10(%rax), %rax
movq %rax, (%r15)
testq %rax, %rax
je 0x83d4
movq 0x5c02(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x83d0
incl 0x8(%rax)
jmp 0x83d4
lock
incl 0x8(%rax)
movq (%rbx), %rdi
movq (%r14), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
leaq 0x8(%r14), %rsi
callq 0x873a
movq (%r14), %rdi
movq (%rsp), %rax
movq %rax, 0x18(%rdi)
addq $0x20, %rdi
movq %r15, %rsi
callq 0x873a
movq (%r14), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %r15
testq %r15, %r15
je 0x8429
movq 0x5baf(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x8424
incl 0x8(%r15)
jmp 0x8429
lock
incl 0x8(%r15)
testq %rax, %rax
je 0x8433
movl 0x38(%rax), %eax
jmp 0x8435
xorl %eax, %eax
movq (%r14), %rdx
movq 0x18(%rdx), %rcx
movq 0x20(%rdx), %rdi
testq %rdi, %rdi
je 0x845a
movq 0x5b7c(%rip), %rdx      # 0xdfc8
cmpb $0x0, (%rdx)
je 0x8456
incl 0x8(%rdi)
jmp 0x845a
lock
incl 0x8(%rdi)
testq %rcx, %rcx
je 0x8464
movl 0x38(%rcx), %ecx
jmp 0x8466
xorl %ecx, %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
incl %ecx
movq (%r14), %rax
movl %ecx, 0x38(%rax)
testq %rdi, %rdi
je 0x847d
callq 0x7814
testq %r15, %r15
je 0x848a
movq %r15, %rdi
callq 0x7814
movq (%rbx), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %r14
testq %r14, %r14
je 0x84b1
movq 0x5b27(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x84ac
incl 0x8(%r14)
jmp 0x84b1
lock
incl 0x8(%r14)
testq %rax, %rax
je 0x84bb
movl 0x38(%rax), %eax
jmp 0x84bd
xorl %eax, %eax
movq (%rbx), %rdx
movq 0x18(%rdx), %rcx
movq 0x20(%rdx), %rdi
testq %rdi, %rdi
je 0x84e2
movq 0x5af4(%rip), %rdx      # 0xdfc8
cmpb $0x0, (%rdx)
je 0x84de
incl 0x8(%rdi)
jmp 0x84e2
lock
incl 0x8(%rdi)
testq %rcx, %rcx
je 0x84ec
movl 0x38(%rcx), %ecx
jmp 0x84ee
xorl %ecx, %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
incl %ecx
movq (%rbx), %rax
movl %ecx, 0x38(%rax)
testq %rdi, %rdi
je 0x8505
callq 0x7814
testq %r14, %r14
je 0x8512
movq %r14, %rdi
callq 0x7814
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8521
callq 0x7814
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rdi, %r14
movq (%rdx), %rax
movq %rax, (%rdi)
movq 0x8(%rdx), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x8560
movq 0x5a76(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x855c
incl 0x8(%rax)
jmp 0x8560
lock
incl 0x8(%rax)
leaq 0x8(%r14), %r15
cmpq $0x0, (%r14)
jne 0x857c
movq (%rsi), %rax
movq %rax, (%r14)
addq $0x8, %rsi
movq %r15, %rdi
callq 0x873a
movq (%r14), %rax
testq %rax, %rax
je 0x85a2
cmpl %ebx, (%rax)
je 0x85a2
setbe %cl
movzbl %cl, %ecx
shll $0x4, %ecx
leaq (%rcx,%rax), %rsi
addq $0x10, %rsi
movq -0x8(%rsi), %rax
movq %rax, (%r14)
jmp 0x8574
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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)
movl $0x1, %edx
movq %r14, %rdi
callq 0x32a0
movq (%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x32a0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdx), %rsi
callq 0x9188
movl (%rax), %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq %r14, %rdi
callq 0x32a0
movl 0x30(%rbx), %eax
leaq 0x14(%rsp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq %r14, %rdi
callq 0x32a0
movq 0x20(%rbx), %r15
addq $0x10, %rbx
cmpq %rbx, %r15
je 0x8db0
movl $0xff, %r12d
leaq 0xb(%rsp), %r13
movl 0x40(%r15), %eax
movl %eax, 0xc(%rsp)
movl $0x4, %edx
movq %r14, %rdi
leaq 0xc(%rsp), %rsi
callq 0x32a0
movq 0x28(%r15), %rbp
cmpq %r12, %rbp
cmovaeq %r12, %rbp
movb %bpl, 0xb(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x32a0
movq 0x20(%r15), %rsi
movq %r14, %rdi
movq %rbp, %rdx
callq 0x32a0
movq %r15, %rdi
callq 0x3250
movq %rax, %r15
cmpq %rbx, %rax
jne 0x8d57
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x8e63
movq %rdx, %r14
callq 0x9188
movl (%rax), %eax
leaq 0x4(%rsp), %r15
movl %eax, (%r15)
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x32a0
movl 0x8(%r14), %eax
movl %eax, (%r15)
leaq 0x4(%rsp), %r15
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x32a0
movl 0xc(%r14), %eax
movl %eax, (%r15)
leaq 0x4(%rsp), %r15
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x32a0
movq 0x18(%r14), %rax
movl $0xff, %r12d
cmpq %r12, %rax
cmovbq %rax, %r12
movb %r12b, (%r15)
leaq 0x4(%rsp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x32a0
movq 0x10(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
jmp 0x8e76
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq 0x32a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdx), %rax
subq (%rdx), %rax
shrq $0x4, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq 0x32a0
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r13, %r12
je 0x8f47
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x90a8
addq $0x50, %r12
jmp 0x8f2e
leaq 0x18(%r14), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8dc0
movq 0x50(%r14), %rax
subq 0x48(%r14), %rax
movl %eax, %ecx
shrl $0x2, %ecx
leaq 0xc(%rsp), %rsi
movb %cl, (%rsi)
movl %eax, %ecx
shrl $0xa, %ecx
movb %cl, 0x1(%rsi)
movl %eax, %ecx
shrl $0x12, %ecx
movb %cl, 0x2(%rsi)
shrq $0x1a, %rax
movb %al, 0x3(%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq 0x32a0
movq 0x48(%r14), %r15
movq 0x50(%r14), %r12
cmpq %r12, %r15
je 0x8fc0
leaq 0x4(%rsp), %r14
movl (%r15), %eax
movl %eax, 0x4(%rsp)
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32a0
addq $0x4, %r15
cmpq %r12, %r15
jne 0x8fa0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdx), %rax
movl $0xff, %r12d
cmpq %r12, %rax
cmovbq %rax, %r12
leaq 0x2(%rsp), %rsi
movb %r12b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x32a0
movq (%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x32a0
movb 0x20(%r15), %al
leaq 0x3(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x32a0
movl 0x24(%r15), %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq 0x32a0
movl 0x20(%r15), %eax
cmpl $0x3, %eax
je 0x9067
cmpl $0x4, %eax
je 0x9067
cmpl $0x5, %eax
jne 0x9082
movq 0x28(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8dc0
jmp 0x9076
movq 0x28(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8e88
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x4f67(%rip), %rdi      # 0xdff0
leaq 0x13da(%rip), %rsi      # 0xa46a
callq 0x31f0
movq %rax, %rdi
callq 0x3120
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3260
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
callq 0x10b0
testl %eax, %eax
je 0x1206
leaq -0x2d(%rip), %rsi       # 0x11bc
movl $0x3, %edi
callq 0x1060
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x1090
xorl %edi, %edi
callq 0x10a0
jmp 0x1231
leaq 0xe03(%rip), %rdi       # 0x2010
callq 0x1030
callq 0x1050
movl $0x186a0, %ebx          # imm = 0x186A0
callq 0x1080
movl %eax, %edi
movl $0x3, %esi
callq 0x1070
decl %ebx
jne 0x121c
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1100
movb $-0x1, %bl
testl %eax, %eax
js 0x1d25
movl %eax, %ebp
movl %eax, %edi
movq %r14, %rsi
callq 0x1190
cmpl %ebp, %eax
jne 0x1d25
xorl %eax, %eax
testl %ebp, %ebp
movl $0x42, %ecx
cmovnel %eax, %ecx
cmpl $0x30, %ebp
movl $0x48, %ebx
cmovnel %ecx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ryancdotorg[P]bloomslice/bfstool.c
// Function: chkmalloc
static void * _chkmalloc(size_t size, unsigned char *file, unsigned int line) {
  void *ptr = malloc(size);
  if (ptr == NULL) {
    bail(1, "[!] malloc(%zu) failed at %s:%u: %s\n", size, file, line, strerror(errno));
  }
  return ptr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1170
testq %rax, %rax
je 0x2b3c
popq %rbx
retq
movq %rbx, %rdi
callq 0x1b93
// File: /workspace/github_c_makefile_star2_O1/ryancdotorg[P]bloomslice/bloomutl.c
// Function: bloom_width_to_mask
uint64_t bloom_width_to_mask(uint8_t width) {
  if (width == BFS_TYPE_LEGACY) {
      return 1;
  } else if (width == BFS_TYPE_SINGLE) {
      return 1;
  } else if (width < 8 || width > 48) {
      return 0;
  } else {
      return (1ULL<<width) - 1;
  }
}

// Assembly:
movl $0x1, %eax
cmpb $0x2, %dil
jb 0x5bc9
leal -0x31(%rdi), %eax
cmpb $-0x29, %al
jae 0x5bba
xorl %eax, %eax
retq
movq $-0x1, %rax
movl %edi, %ecx
shlq %cl, %rax
notq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x1, %eax
cmpq $0x1d, %rdi
je 0x5bf6
cmpq $0x20000000, %rdi       # imm = 0x20000000
je 0x5bf6
leaq -0x9(%rdi), %rax
addq $-0xa, %rdi
testq %rdi, %rax
je 0x5bee
xorl %eax, %eax
retq
leaq -0x1(,%rax,8), %rax
retq