LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x66e7
movq -0x18(%rbp), %rax
movl $0x3, 0x20(%rax)
movl $0x18, %edi
callq 0x3240
movq %rax, %rdi
movq %rdi, -0xa0(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x3140
movq -0xa0(%rbp), %rdi
callq 0x6d00
movq -0xa0(%rbp), %rcx
movq -0x98(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x5f40
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x683f
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x6758
movq -0x18(%rbp), %rax
movl $0x4, 0x20(%rax)
movl $0x18, %edi
callq 0x3240
movq %rax, %rdi
movq %rdi, -0xa8(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x3140
movq -0xa8(%rbp), %rdi
callq 0x6d00
movq -0xa8(%rbp), %rcx
movq -0x98(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x5f40
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x683f
movq -0x18(%rbp), %rax
movl $0x5, 0x20(%rax)
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movq -0x18(%rbp), %rdi
callq 0x3050
movq -0x28(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xc500
movq -0xb8(%rbp), %rdi
movl $0x3a, %esi
callq 0xc990
movb %al, -0xa9(%rbp)
jmp 0x67a1
movb -0xa9(%rbp), %al
xorb $-0x1, %al
movb %al, -0xb9(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x68a0
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x67c4
jmp 0x67e7
movb $0x0, -0x1(%rbp)
jmp 0x683f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x68a0
jmp 0x684d
movl $0x30, %edi
callq 0x3240
movq %rax, %rdi
movq %rdi, -0xc8(%rbp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x3140
movq -0xc8(%rbp), %rdi
callq 0x6f20
movq -0xc8(%rbp), %rcx
movq -0x98(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x6320
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x3490
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0xb718
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x18, -0x30(%rbp)
movq 0xd864(%rip), %rax      # 0x18fd0
movq %rax, -0xf0(%rbp)
movq (%rax), %rax
movq %rax, -0xf8(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x3100
movq -0xf8(%rbp), %rdi
movq %rax, %rdx
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %ecx
leaq 0x59cf(%rip), %rsi      # 0x11171
xorl %eax, %eax
callq 0x33a0
movq -0xf0(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3340
movq -0xe8(%rbp), %rax
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
movl (%rax), %eax
subl $0xa, %eax
setl %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0xbac8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x18, -0x30(%rbp)
movq 0xd4b4(%rip), %rax      # 0x18fd0
movq %rax, -0xf0(%rbp)
movq (%rax), %rax
movq %rax, -0xf8(%rbp)
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x3100
movq -0xf8(%rbp), %rdi
movq %rax, %rdx
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
leaq 0x561f(%rip), %rsi      # 0x11171
xorl %eax, %eax
callq 0x33a0
movq -0xf0(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3340
movq -0xe8(%rbp), %rax
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
movl (%rax), %eax
subl $0xa, %eax
setl %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
testb $0x1, 0x28(%rax)
jne 0xbbf5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3100
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rcx
leaq 0x5684(%rip), %rdx      # 0x11266
movb $0x0, %al
callq 0xb6e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xbca2
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0xbc0b
movl $0x4, -0x4(%rbp)
jmp 0xbca2
movq -0x18(%rbp), %rax
movq (%rax), %rax
testb $0x1, 0x21(%rax)
jne 0xbc77
movq -0x18(%rbp), %rax
movq (%rax), %rax
testb $0x1, 0x20(%rax)
je 0xbc58
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3100
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rcx
leaq 0x5631(%rip), %rdx      # 0x11279
movb $0x0, %al
callq 0xba90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xbca2
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xb7e0
testb $0x1, %al
jne 0xbc75
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xbca2
jmp 0xbc77
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x24(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jl 0xbc9c
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
imull -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0xac90
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xaac0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc1b0
testb $0x1, %al
jne 0xbd03
jmp 0xbe37
leaq -0x30(%rbp), %rdi
callq 0xc1f0
movl 0x20(%rax), %eax
movl %eax, -0x4c(%rbp)
subl $0x3, %eax
je 0xbd62
jmp 0xbd19
movl -0x4c(%rbp), %eax
subl $0x4, %eax
je 0xbd90
jmp 0xbd23
movl -0x4c(%rbp), %eax
subl $0x5, %eax
jne 0xbdbe
jmp 0xbd31
leaq -0x30(%rbp), %rdi
callq 0xc1f0
movq -0x48(%rbp), %rdi
movq 0x28(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xbb90
movl %eax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xc1f0
movl -0x50(%rbp), %ecx
movl %ecx, 0x24(%rax)
jmp 0xbdf9
leaq -0x30(%rbp), %rdi
callq 0xc1f0
movq -0x48(%rbp), %rdi
movq 0x28(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xbcb0
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xc1f0
movl -0x54(%rbp), %ecx
movl %ecx, 0x24(%rax)
jmp 0xbdf9
leaq -0x30(%rbp), %rdi
callq 0xc1f0
movq -0x48(%rbp), %rdi
movq 0x28(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xbe50
movl %eax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xc1f0
movl -0x58(%rbp), %ecx
movl %ecx, 0x24(%rax)
jmp 0xbdf9
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xc1f0
movq %rax, %rdi
callq 0x3100
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rcx
leaq 0x54ac(%rip), %rdx      # 0x11295
movb $0x0, %al
callq 0xba90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xbe3d
leaq -0x30(%rbp), %rdi
callq 0xc1f0
cmpl $0x0, 0x24(%rax)
jge 0xbe11
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xbe3d
leaq -0x30(%rbp), %rdi
callq 0xc1f0
movl 0x24(%rax), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xc210
movq %rax, -0x40(%rbp)
jmp 0xbce0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x11(%rbp)
jae 0xc4be
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x3060
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xc4c7
jmp 0xc4f3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xc4e3
movq -0x10(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xc494
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x49a9(%rip), %rsi      # 0x112af
callq 0xcbe0
testb $0x1, %al
jne 0xc911
jmp 0xc91a
movl $0x1, -0x4(%rbp)
jmp 0xc963
movq -0x20(%rbp), %rdi
leaq 0x498f(%rip), %rsi      # 0x112b4
callq 0xcbe0
testb $0x1, %al
jne 0xc930
jmp 0xc939
movl $0x5, -0x4(%rbp)
jmp 0xc963
movq -0x20(%rbp), %rdi
leaq 0x4977(%rip), %rsi      # 0x112bb
callq 0xcbe0
testb $0x1, %al
jne 0xc94f
jmp 0xc958
movl $0x6, -0x4(%rbp)
jmp 0xc963
jmp 0xc95a
jmp 0xc95c
movl $0x7, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x3, (%rax)
je 0xca08
movq -0x20(%rbp), %rdi
movq 0xc616(%rip), %rax      # 0x18fd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
addq $0x30, %rdi
callq 0x3100
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movq -0x20(%rbp), %rax
movl 0x50(%rax), %ecx
leaq 0x4792(%rip), %rsi      # 0x11171
movb $0x0, %al
callq 0x33a0
movq 0xc5e3(%rip), %rax      # 0x18fd0
movq (%rax), %rdi
movsbl -0x11(%rbp), %edx
leaq 0x48c6(%rip), %rsi      # 0x112c1
movb $0x0, %al
callq 0x33a0
movb $0x0, -0x1(%rbp)
jmp 0xca7d
movq -0x20(%rbp), %rax
movsbl 0x28(%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0xca79
movq -0x20(%rbp), %rdi
movq 0xc5ad(%rip), %rax      # 0x18fd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
addq $0x30, %rdi
callq 0x3100
movq -0x30(%rbp), %rdi
movq %rax, %rdx
movq -0x20(%rbp), %rax
movl 0x50(%rax), %ecx
leaq 0x4729(%rip), %rsi      # 0x11171
movb $0x0, %al
callq 0x33a0
movq -0x20(%rbp), %rax
movq 0xc576(%rip), %rcx      # 0x18fd0
movq (%rcx), %rdi
movsbl -0x11(%rbp), %edx
movsbl 0x28(%rax), %ecx
leaq 0x4864(%rip), %rsi      # 0x112d0
movb $0x0, %al
callq 0x33a0
movb $0x0, -0x1(%rbp)
jmp 0xca7d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x3, (%rax)
jne 0xcaec
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0xcaea
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x28(%rcx), %ecx
cmpl %ecx, %eax
jne 0xcada
movb $0x1, -0x1(%rbp)
jmp 0xcbc8
jmp 0xcadc
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xcab5
jmp 0xcaec
movq -0x38(%rbp), %rdi
movq 0xc4d9(%rip), %rax      # 0x18fd0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
addq $0x30, %rdi
callq 0x3100
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movq -0x38(%rbp), %rax
movl 0x50(%rax), %ecx
leaq 0x4655(%rip), %rsi      # 0x11171
movb $0x0, %al
callq 0x33a0
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0xcb81
movq 0xc491(%rip), %rax      # 0x18fd0
movq (%rax), %rdi
movb -0x21(%rbp), %cl
leaq 0x45be(%rip), %rdx      # 0x1110a
leaq 0x47a8(%rip), %rax      # 0x112fb
testb $0x1, %cl
cmovneq %rax, %rdx
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
leaq 0x478c(%rip), %rsi      # 0x112f4
movb $0x0, %al
callq 0x33a0
movb $0x1, -0x21(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xcb2f
movq -0x38(%rbp), %rax
cmpl $0x3, (%rax)
jne 0xcbac
movq -0x38(%rbp), %rax
movq 0xc43b(%rip), %rcx      # 0x18fd0
movq (%rcx), %rdi
movsbl 0x28(%rax), %edx
leaq 0x475d(%rip), %rsi      # 0x11300
movb $0x0, %al
callq 0x33a0
jmp 0xcbc4
movq 0xc41d(%rip), %rax      # 0x18fd0
movq (%rax), %rdi
leaq 0x4708(%rip), %rsi      # 0x112c5
movb $0x0, %al
callq 0x33a0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, %rax
movq -0x88(%rbp), %rdi
movq %rax, -0x78(%rbp)
movq %rax, %rcx
movq %rcx, -0x98(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xdcb0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0xdd20
movq -0x78(%rbp), %rdi
callq 0xdcb0
movq %rax, %rsi
addq $0x18, %rsi
leaq -0x28(%rbp), %rdi
callq 0xdd20
movq -0x78(%rbp), %rdi
callq 0xdcb0
movq -0x88(%rbp), %rsi
movq %rax, %rdi
addq $0x18, %rdi
callq 0xdd50
movq -0x88(%rbp), %rdi
callq 0xdcb0
movq %rax, %rdi
addq $0x8, %rdi
leaq -0x28(%rbp), %rsi
callq 0xdd50
movq -0x88(%rbp), %rdi
callq 0xdcb0
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
callq 0xdd20
leaq -0x38(%rbp), %rdi
callq 0xd4a0
movq -0x88(%rbp), %rdi
movl %eax, -0x8c(%rbp)
callq 0xdcb0
movq %rax, %rsi
addq $0x18, %rsi
leaq -0x48(%rbp), %rdi
callq 0xdd20
leaq -0x48(%rbp), %rdi
callq 0xd4a0
movl -0x8c(%rbp), %edi
movl %eax, %esi
callq 0xd470
movq -0x88(%rbp), %rdi
addl $0x1, %eax
movl %eax, -0x80(%rbp)
callq 0xdcb0
movl -0x80(%rbp), %ecx
movl %ecx, 0x38(%rax)
leaq -0x48(%rbp), %rdi
callq 0xc2c0
leaq -0x38(%rbp), %rdi
callq 0xc2c0
movq -0x78(%rbp), %rdi
callq 0xdcb0
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
callq 0xdd20
leaq -0x58(%rbp), %rdi
callq 0xd4a0
movq -0x78(%rbp), %rdi
movl %eax, -0x7c(%rbp)
callq 0xdcb0
movq %rax, %rsi
addq $0x18, %rsi
leaq -0x68(%rbp), %rdi
callq 0xdd20
leaq -0x68(%rbp), %rdi
callq 0xd4a0
movl -0x7c(%rbp), %edi
movl %eax, %esi
callq 0xd470
movq -0x78(%rbp), %rdi
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
callq 0xdcb0
movl -0x6c(%rbp), %ecx
movl %ecx, 0x38(%rax)
leaq -0x68(%rbp), %rdi
callq 0xc2c0
leaq -0x58(%rbp), %rdi
callq 0xc2c0
movb $0x1, -0x11(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xc2c0
testb $0x1, -0x11(%rbp)
jne 0xd737
movq -0x78(%rbp), %rdi
callq 0xc2c0
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x40(%rbp)
movq %rsi, %rax
movq -0x40(%rbp), %rsi
movq %rdi, -0x28(%rbp)
movq %rdi, %rdx
movq %rdx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x1d(%rbp)
callq 0xdd20
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdbe0
testb $0x1, %al
jne 0xd971
jmp 0xd97e
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0xdd50
jmp 0xd980
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdd80
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0xd99b
jmp 0xd9af
movq -0x28(%rbp), %rdi
callq 0xdcb0
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xd9b8
jmp 0xda0a
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x48(%rbp)
callq 0xdcb0
movq %rax, %rcx
movl -0x48(%rbp), %eax
cmpl (%rcx), %eax
jae 0xd9ec
movq -0x28(%rbp), %rdi
callq 0xdcb0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0xdd50
jmp 0xda05
movq -0x28(%rbp), %rdi
callq 0xdcb0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x18, %rsi
callq 0xdd50
jmp 0xd980
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0xda1d
movq -0x28(%rbp), %rdi
callq 0xc2c0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa4f0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0xdbb7
movq -0x20(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xdd20
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xddb0
movq -0x88(%rbp), %rsi
movq -0x98(%rbp), %rdx
movl (%rax), %ecx
leaq -0x38(%rbp), %rdi
callq 0xcc10
jmp 0xdabc
movq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xdc80
leaq -0x38(%rbp), %rdi
callq 0xc2c0
leaq -0x48(%rbp), %rdi
callq 0xc2c0
movq -0x20(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0xdd20
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xddb0
movq -0x88(%rbp), %rsi
movl (%rax), %ecx
leaq -0x68(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0xd920
leaq -0x78(%rbp), %rdi
callq 0xc2c0
movslq -0x24(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa4f0
movq %rax, %rcx
movq -0xa0(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0xdb7b
leaq -0x68(%rbp), %rdi
callq 0xdcb0
testb $0x1, 0x3c(%rax)
je 0xdb6e
movb $0x0, -0x1(%rbp)
movl $0x1, -0x7c(%rbp)
jmp 0xdb93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xc2c0
jmp 0xdbc9
leaq -0x68(%rbp), %rdi
callq 0xdcb0
movb $0x1, 0x3c(%rax)
leaq -0x68(%rbp), %rdi
callq 0xdcb0
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x7c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xc2c0
movl -0x7c(%rbp), %eax
testl %eax, %eax
je 0xdba7
jmp 0xdba5
jmp 0xdbbb
jmp 0xdba9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xda59
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/docmaker/output.cc
// Function: Output::w32(std::ostream*, unsigned int)
void Output::w32(std::ostream *f, uint32_t val) {
  char buf[4];
  buf[0] = val & 0xff;
  buf[1] = (val >> 8) & 0xff;
  buf[2] = (val >> 16) & 0xff;
  buf[3] = (val >> 24) & 0xff;
  f->write(buf, 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, -0x18(%rbp)
movl -0x14(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0x17(%rbp)
movl -0x14(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0x16(%rbp)
movl -0x14(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x3330
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x33e0
cmpq $0xff, %rax
jbe 0xf130
movl $0xff, %eax
movq %rax, -0x28(%rbp)
jmp 0xf13d
movq -0x18(%rbp), %rdi
callq 0x33e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
movb %al, -0x1a(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1a(%rbp), %rsi
movl $0x1, %edx
callq 0x3330
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3100
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movzbl -0x19(%rbp), %eax
movl %eax, %edx
callq 0x3330
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xf190
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
movl %eax, %edx
callq 0xf060
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0xf960
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl %eax, %edx
callq 0xf060
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0xf980
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0xf9e0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xf9b0
testb $0x1, %al
jne 0xf288
jmp 0xf2db
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xfa10
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %rdi
movl 0x20(%rax), %edx
callq 0xf060
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xfa10
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0xf100
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xfa40
movq %rax, -0x30(%rbp)
jmp 0xf264
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xf327
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0xf060
jmp 0xf38b
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xf190
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
movl %eax, %edx
callq 0xf060
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
callq 0xf060
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %edx
callq 0xf060
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x10, %rdx
callq 0xf100
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9a60
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl %eax, %edx
callq 0xf060
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xfb60
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xfb90
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xfbc0
testb $0x1, %al
jne 0xf4b1
jmp 0xf4da
leaq -0x28(%rbp), %rdi
callq 0xfc00
movq -0x68(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xf670
leaq -0x28(%rbp), %rdi
callq 0xfc20
jmp 0xf49e
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x18, %rdx
callq 0xf2f0
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
callq 0xa4f0
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movl %eax, %edx
callq 0xf060
movq -0x18(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xfc40
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0xfc70
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xfca0
testb $0x1, %al
jne 0xf54c
jmp 0xf575
leaq -0x48(%rbp), %rdi
callq 0xfce0
movq -0x68(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rsi
movl -0x54(%rbp), %edx
callq 0xf060
leaq -0x48(%rbp), %rdi
callq 0xfd00
jmp 0xf539
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf100
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %edx
callq 0xf0c0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x24(%rax), %edx
callq 0xf060
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x3, %eax
je 0xf60e
jmp 0xf5e3
movl -0x1c(%rbp), %eax
subl $0x4, %eax
je 0xf625
jmp 0xf5ed
movl -0x1c(%rbp), %eax
subl $0x5, %eax
jne 0xf63c
jmp 0xf5f7
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0xf2f0
jmp 0xf668
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0xf3a0
jmp 0xf668
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0xf3a0
jmp 0xf668
movq 0x99ad(%rip), %rdi      # 0x18ff0
leaq 0x1df0(%rip), %rsi      # 0x1143a
callq 0x3230
movq %rax, %rdi
movq 0x995f(%rip), %rsi      # 0x18fb8
callq 0x3280
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x32e0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x10a0
cmpl $0x0, %eax
jne 0x123a
leaq 0xe10(%rip), %rdi       # 0x2010
movb $0x0, %al
callq 0x1030
callq 0x1040
movl $0x0, -0x8(%rbp)
cmpl $0x186a0, -0x8(%rbp)    # imm = 0x186A0
jge 0x1238
callq 0x1070
movl %eax, %edi
movl $0x3, %esi
callq 0x1060
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1213
jmp 0x125e
movl $0x3, %edi
leaq -0x96(%rip), %rsi       # 0x11b0
callq 0x1050
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x1080
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/fader/fader.c
// Function: main
int
main(int argc,char **argv)
    {
    int argIndex = 1;
    static FILE *in,*out;

    RRA *h;

    argIndex = processOptions(argc,argv);

    if (argc-argIndex == 0)
        {
        in = stdin;
        out = stdout;
        }
    else if (argc-argIndex == 1)
        {
        in = OpenFile(argv[argIndex],"r");
        out = stdout;
        }
    else if (argc-argIndex == 2)
        {
        in = OpenFile(argv[argIndex],"r");
        out = OpenFile(argv[argIndex+1],"w");
        }
    else
        {
        printf("usage: fader -n<N> [<input rra file> [<output rra file>]]\n");
        exit(-1);
        }

    h = newRRAHeader();
    
    readRRAHeader(in,h,0);

    process(h,in,out);

    fclose(in);
    fclose(out);

    return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1470
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0x136e
movq 0x6c8a(%rip), %rax      # 0x7fd8
movq (%rax), %rax
movq %rax, 0x6df8(%rip)      # 0x8150
movq 0x6c71(%rip), %rax      # 0x7fd0
movq (%rax), %rax
movq %rax, 0x6def(%rip)      # 0x8158
jmp 0x1417
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x1, %eax
jne 0x13ab
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3d16(%rip), %rsi      # 0x50a2
callq 0x1950
movq %rax, 0x6db8(%rip)      # 0x8150
movq 0x6c31(%rip), %rax      # 0x7fd0
movq (%rax), %rax
movq %rax, 0x6daf(%rip)      # 0x8158
jmp 0x1415
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x2, %eax
jne 0x13fb
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3cd9(%rip), %rsi      # 0x50a2
callq 0x1950
movq %rax, 0x6d7b(%rip)      # 0x8150
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3c68(%rip), %rsi      # 0x5055
callq 0x1950
movq %rax, 0x6d5f(%rip)      # 0x8158
jmp 0x1413
leaq 0x3c55(%rip), %rdi      # 0x5057
movb $0x0, %al
callq 0x1090
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x11d0
jmp 0x1415
jmp 0x1417
callq 0x1e30
movq %rax, -0x20(%rbp)
movq 0x6d29(%rip), %rdi      # 0x8150
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2330
movq -0x20(%rbp), %rdi
movq 0x6d11(%rip), %rsi      # 0x8150
movq 0x6d12(%rip), %rdx      # 0x8158
callq 0x16b0
movq 0x6cfe(%rip), %rdi      # 0x8150
callq 0x1070
movq 0x6cfa(%rip), %rdi      # 0x8158
callq 0x1070
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/fader/fader.c
// Function: process
static void
process(RRA *h,FILE *in,FILE *out)
    {
    int i,j;
    int amp;
    double delta,factor = 0;

    writeRRAHeader(out,h,"modifiedBy: fader",0);

    delta = 1.0 / inrun;
    for (i = 0; !feof(in); ++i)
        {
        for (j = 0; j < h->channels; ++j)
            {
            amp = readRRAAmplitude(in,out,h->bitsPerSample,outputComment);
            fprintf(out,"%d\n",(int)(amp * factor * amplify));
            }
        factor += delta;
        if (i == inrun) { factor = 1.0; delta = 0; }
        if (h->samples - i == outrun) { delta = - 1.0 / outrun; }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x39b7(%rip), %rdx      # 0x5092
xorl %eax, %eax
movl %eax, %ecx
callq 0x32d0
cvtsi2sdl 0x6a3c(%rip), %xmm1 # 0x8128
movsd 0x394c(%rip), %xmm0     # 0x5040
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1130
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x171e
jmp 0x17eb
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1781
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x1fca(%rip), %rcx      # 0x3710
callq 0x2a60
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
cvtsi2sdl -0x24(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
mulsd 0x69cc(%rip), %xmm0     # 0x8130
cvttsd2si %xmm0, %edx
leaq 0x3b3e(%rip), %rsi      # 0x52ad
movb $0x0, %al
callq 0x1110
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1725
movsd -0x30(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x698f(%rip), %eax      # 0x8128
jne 0x17b0
movsd 0x389d(%rip), %xmm0     # 0x5040
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
subl -0x1c(%rbp), %eax
cmpl 0x6978(%rip), %eax      # 0x8138
jne 0x17db
cvtsi2sdl 0x696e(%rip), %xmm1 # 0x8138
movsd 0x3876(%rip), %xmm0     # 0x5048
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x17dd
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1704
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x13b4
movb $-0x1, -0x1(%rbp)
jmp 0x13ed
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1190
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0x13d1
movb $-0x1, -0x1(%rbp)
jmp 0x13ed
cmpl $0x30, -0x18(%rbp)
jne 0x13dd
movb $0x48, -0x1(%rbp)
jmp 0x13ed
cmpl $0x0, -0x18(%rbp)
jne 0x13e9
movb $0x42, -0x1(%rbp)
jmp 0x13ed
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1170
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2e74
jmp 0x2e19
movq 0xb1d8(%rip), %rax      # 0xdff8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x1030
movl (%rax), %edi
callq 0x1270
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %r8d
movq %rax, %r9
leaq 0x8e5e(%rip), %rsi      # 0xbcc1
movb $0x0, %al
callq 0x1130
movl $0x1, %edi
callq 0x1250
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ryancdotorg[P]bloomslice/./hex.h
// Function: unhex
static inline unsigned char *
unhex(unsigned char *str, size_t str_sz,
        unsigned char *unhexed, size_t unhexed_sz) {
  size_t i;
  str_sz /= 2;
  if (unhexed_sz < str_sz) str_sz = unhexed_sz;
  for (i = 0; i < str_sz; ++i) unhexed[i] = unhexH[str[i*2]] | unhexL[str[i*2+1]];
  return unhexed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
shrq %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2eb1
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2f19
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x8265(%rip), %rax      # 0xb140
movzbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rdx
shlq %rdx
movzbl 0x1(%rcx,%rdx), %ecx
movl %ecx, %edx
leaq 0x8348(%rip), %rcx      # 0xb240
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2eb9
movq -0x18(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ryancdotorg[P]bloomslice/bloomutl.c
// Function: bloom_width_to_size
size_t bloom_width_to_size(uint8_t width) {
  if (width == BFS_TYPE_LEGACY) {
    return LEGACY_BYTES;
  } else if (width == BFS_TYPE_SINGLE) {
    return SINGLE_BYTES;
  } else if (width < 8 || width > 48) {
    return 0;
  } else {
    return ((1ULL<<width)>>3) + FOOTER_BYTES;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jne 0x913d
movq $0x20000000, -0x8(%rbp) # imm = 0x20000000
jmp 0x9188
movzbl -0x9(%rbp), %eax
cmpl $0x1, %eax
jne 0x9150
movq $0x1d, -0x8(%rbp)
jmp 0x9188
movzbl -0x9(%rbp), %eax
cmpl $0x8, %eax
jl 0x9162
movzbl -0x9(%rbp), %eax
cmpl $0x30, %eax
jle 0x916c
movq $0x0, -0x8(%rbp)
jmp 0x9188
movzbl -0x9(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
shrq $0x3, %rax
addq $0x9, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jne 0x91ad
movq $0x1, -0x8(%rbp)
jmp 0x91f4
movzbl -0x9(%rbp), %eax
cmpl $0x1, %eax
jne 0x91c0
movq $0x1, -0x8(%rbp)
jmp 0x91f4
movzbl -0x9(%rbp), %eax
cmpl $0x8, %eax
jl 0x91d2
movzbl -0x9(%rbp), %eax
cmpl $0x30, %eax
jle 0x91dc
movq $0x0, -0x8(%rbp)
jmp 0x91f4
movzbl -0x9(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
subq $0x9, %rax
movq %rax, -0x18(%rbp)
cmpq $0x20000000, -0x10(%rbp) # imm = 0x20000000
jne 0x9228
movq $0x1, -0x8(%rbp)
jmp 0x9268
cmpq $0x1d, -0x10(%rbp)
jne 0x9239
movq $0x1, -0x8(%rbp)
jmp 0x9268
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x9258
movq $0x0, -0x8(%rbp)
jmp 0x9268
movq -0x18(%rbp), %rax
shlq $0x3, %rax
subq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ryancdotorg[P]bloomslice/bloomutl.c
// Function: bloom_chk_size
int bloom_chk_size(size_t sz) {
  size_t bz = sz - FOOTER_BYTES;
  if (sz == LEGACY_BYTES) {
    return 2;
  } else if (sz == SINGLE_BYTES) {
    return 3;
  } else if (bz & (bz - 1)) {
    return 0;
  } else {
    return 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
subq $0x9, %rax
movq %rax, -0x18(%rbp)
cmpq $0x20000000, -0x10(%rbp) # imm = 0x20000000
jne 0x9297
movl $0x2, -0x4(%rbp)
jmp 0x92cc
cmpq $0x1d, -0x10(%rbp)
jne 0x92a7
movl $0x3, -0x4(%rbp)
jmp 0x92cc
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x92c5
movl $0x0, -0x4(%rbp)
jmp 0x92cc
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryancdotorg[P]bloomslice/bloomutl.c
// Function: bloom_get_hash
uint8_t bloom_get_hash(unsigned char *bloom, size_t sz) {
  uint8_t ret;
  if (sz == 1<<29) return 0;
  memcpy(&ret, (bloom+sz)-(sizeof(uint8_t)), sizeof(uint8_t));
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x20000000, -0x18(%rbp) # imm = 0x20000000
jne 0x92fc
movb $0x0, -0x1(%rbp)
jmp 0x9311
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movb -0x1(%rax,%rcx), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryancdotorg[P]bloomslice/bloomutl.c
// Function: bloom_get_items
uint64_t bloom_get_items(unsigned char *bloom, size_t sz) {
  uint64_t ret;
  if (sz == 1<<29) return 0;
  memcpy(&ret, (bloom+sz)-FOOTER_BYTES, sizeof(uint64_t));
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x20000000, -0x18(%rbp) # imm = 0x20000000
jne 0x9370
movq $0x0, -0x8(%rbp)
jmp 0x9389
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x9(%rax,%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop