LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::FindReference::visit(peg::PrioritizedChoice&)
void visit(PrioritizedChoice &ope) override {
    std::vector<std::shared_ptr<Ope>> opes;
    for (auto o : ope.opes_) {
      o->accept(*this);
      opes.push_back(found_ope);
    }
    found_ope = std::make_shared<PrioritizedChoice>(opes);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movq $0x0, -0x50(%rbp)
movq 0x8(%rsi), %r13
movq 0x10(%rsi), %r15
cmpq %r15, %r13
je 0x1094f
leaq 0x8(%rbx), %r14
movq (%r13), %rdi
movq 0x8(%r13), %r12
testq %r12, %r12
je 0x10924
movq 0x4d65e(%rip), %rax     # 0x5df70
cmpb $0x0, (%rax)
je 0x1091e
incl 0x8(%r12)
jmp 0x10924
lock
incl 0x8(%r12)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x3c726
testq %r12, %r12
je 0x10946
movq %r12, %rdi
callq 0x123fc
addq $0x10, %r13
cmpq %r15, %r13
jne 0x108fe
leaq -0x38(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x40(%rbp), %rsi
leaq -0x29(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0x2f3bc
movaps -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x40(%rbp)
movq 0x10(%rbx), %rdi
movups %xmm0, 0x8(%rbx)
testq %rdi, %rdi
je 0x10997
callq 0x123fc
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x10997
callq 0x123fc
leaq -0x60(%rbp), %rdi
callq 0xbb18
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x109c4
movq %rax, %rbx
testq %r12, %r12
je 0x109c4
movq %r12, %rdi
callq 0x123fc
leaq -0x60(%rbp), %rdi
callq 0xbb18
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::AssignIDToDefinition::visit(peg::Reference&)
inline void AssignIDToDefinition::visit(Reference &ope) {
  if (ope.rule_) {
    for (auto arg : ope.args_) {
      arg->accept(*this);
    }
    ope.rule_->accept(*this);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x68(%rsi), %rax
testq %rax, %rax
je 0x11363
movq %rdi, %rbx
movq 0x50(%rsi), %r12
movq 0x58(%rsi), %r13
cmpq %r13, %r12
je 0x11342
movq %rsi, -0x30(%rbp)
movq 0x4cc74(%rip), %r14     # 0x5df70
movq (%r12), %rdi
movq 0x8(%r12), %r15
testq %r15, %r15
je 0x1131b
cmpb $0x0, (%r14)
je 0x11316
incl 0x8(%r15)
jmp 0x1131b
lock
incl 0x8(%r15)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
testq %r15, %r15
je 0x11331
movq %r15, %rdi
callq 0x123fc
addq $0x10, %r12
cmpq %r13, %r12
jne 0x112fc
movq -0x30(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x1c0(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r15, %r15
je 0x11382
movq %r15, %rdi
callq 0x123fc
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::AnyCharacter::~AnyCharacter()
size_t parse_core(const char *s, size_t n, SemanticValues & /*vs*/,
                    Context &c, std::any & /*dt*/) const override {
    auto len = codepoint_length(s, n);
    if (len < 1) {
      c.set_error_pos(s);
      return static_cast<size_t>(-1);
    }
    return len;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x11422
movq 0x4cb74(%rip), %rax     # 0x5df70
cmpb $0x0, (%rax)
je 0x1140c
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x11416
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x11422
movq (%rdi), %rax
popq %rbp
jmpq *0x18(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::AnyCharacter::parse_core(char const*, unsigned long, peg::SemanticValues&, peg::Context&, std::any&) const
inline size_t codepoint_length(const char *s8, size_t l) {
  if (l) {
    auto b = static_cast<uint8_t>(s8[0]);
    if ((b & 0x80) == 0) {
      return 1;
    } else if ((b & 0xE0) == 0xC0 && l >= 2) {
      return 2;
    } else if ((b & 0xF0) == 0xE0 && l >= 3) {
      return 3;
    } else if ((b & 0xF8) == 0xF0 && l >= 4) {
      return 4;
    }
  }
  return 0;
}

// Assembly:
testq %rdx, %rdx
je 0x114e4
movzbl (%rsi), %ecx
movl $0x1, %eax
testb %cl, %cl
js 0x11488
retq
movl %ecx, %eax
andl $-0x20, %eax
cmpl $0xc0, %eax
sete %dil
cmpq $0x1, %rdx
setne %r9b
movl $0x2, %eax
testb %dil, %r9b
jne 0x11487
movl %ecx, %eax
andl $-0x10, %eax
cmpl $0xe0, %eax
sete %dil
cmpq $0x3, %rdx
setae %r9b
movl $0x3, %eax
testb %dil, %r9b
jne 0x11487
andl $-0x8, %ecx
cmpl $0xf0, %ecx
sete %cl
cmpq $0x4, %rdx
setae %dl
movl $0x4, %eax
testb %cl, %dl
jne 0x11487
pushq %rbp
movq %rsp, %rbp
movq %r8, %rdi
xorl %edx, %edx
callq 0xa1fe
movq $-0x1, %rax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::TokenChecker::is_token(peg::Ope&)
static bool is_token(Ope &ope) {
    if (IsLiteralToken::check(ope)) { return true; }

    TokenChecker vis;
    ope.accept(vis);
    return vis.has_token_boundary_ || !vis.has_rule_;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x4b3ef(%rip), %rax     # 0x5cd38
leaq -0x20(%rbp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
cmpb $0x0, 0x8(%r14)
movb $0x1, %al
jne 0x1198e
leaq 0x4aa5a(%rip), %rax     # 0x5c3c8
movq %rax, (%r14)
movw $0x0, 0x8(%r14)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x18(%rax)
movb 0x9(%r14), %al
xorb $0x1, %al
orb 0x8(%r14), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Context::push_capture_scope()
void push_capture_scope() {
    assert(capture_scope_stack_size <= capture_scope_stack.size());
    if (capture_scope_stack_size == capture_scope_stack.size()) {
      capture_scope_stack.emplace_back(
          std::map<std::string_view, std::string>());
    } else {
      auto &cs = capture_scope_stack[capture_scope_stack_size];
      if (!cs.empty()) { cs.clear(); }
    }
    capture_scope_stack_size++;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x130(%rdi), %rcx
addq $0x118, %rdi            # imm = 0x118
movq 0x118(%rbx), %rax
movq 0x120(%rbx), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rsi
cmpq %rsi, %rcx
ja 0x11d80
jne 0x11d57
leaq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0x40(%rbp), %rsi
callq 0x12058
leaq -0x40(%rbp), %rdi
callq 0x12294
jmp 0x11d72
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
cmpq $0x0, 0x28(%rax,%rcx)
je 0x11d72
addq %rcx, %rax
movq %rax, %rdi
callq 0x12324
incq 0x130(%rbx)
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
leaq 0x308f7(%rip), %rdi     # 0x4267e
leaq 0x30927(%rip), %rsi     # 0x426b5
leaq 0x3092b(%rip), %rcx     # 0x426c0
movl $0x398, %edx            # imm = 0x398
callq 0x81b0
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x12294
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::line_info(char const*, char const*)
inline std::pair<size_t, size_t> line_info(const char *start, const char *cur) {
  auto p = start;
  auto col_ptr = p;
  auto no = 1;

  while (p < cur) {
    if (*p == '\n') {
      no++;
      col_ptr = p + 1;
    }
    p++;
  }

  auto col = codepoint_count(col_ptr, p - col_ptr) + 1;

  return std::pair(no, col);
}

// Assembly:
movl $0x1, %edx
movl $0x1, %eax
cmpq %rsi, %rdi
jae 0x12d96
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
movq %rdi, %rcx
xorl %r8d, %r8d
cmpb $0xa, (%rcx)
leaq 0x1(%rcx), %r9
cmoveq %r9, %rdi
sete %r8b
addl %r8d, %eax
movq %r9, %rcx
cmpq %rsi, %r9
jne 0x12ce3
subq %rdi, %rsi
je 0x12d95
movl $0x1, %edx
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %r8d
movl $0x1, %r10d
testb %r8b, %r8b
jns 0x12d82
movq %rsi, %r9
subq %rcx, %r9
cmpq $0x1, %r9
je 0x12d42
movl %r8d, %r11d
andl $-0x20, %r11d
movl $0x2, %r10d
cmpl $0xc0, %r11d
je 0x12d82
cmpq $0x3, %r9
jb 0x12d5e
movl %r8d, %r11d
andl $-0x10, %r11d
movl $0x3, %r10d
cmpl $0xe0, %r11d
je 0x12d82
andl $-0x8, %r8d
xorl %r11d, %r11d
cmpl $0xf0, %r8d
sete %r11b
shll $0x2, %r11d
cmpq $0x4, %r9
movl $0x0, %r10d
cmovaeq %r11, %r10
cmpq $0x1, %r10
adcq %r10, %rcx
incq %rdx
cmpq %rsi, %rcx
jb 0x12d10
popq %rbp
movl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::ErrorInfo::heuristic_error_token[abi:cxx11](char const*, unsigned long, char const*) const
std::string heuristic_error_token(const char *s, size_t n,
                                    const char *pos) const {
    auto len = n - std::distance(s, pos);
    if (len) {
      size_t i = 0;
      auto c = cast_char(pos[i++]);
      if (!std::ispunct(c) && !std::isspace(c)) {
        while (i < len && !std::ispunct(cast_char(pos[i])) &&
               !std::isspace(cast_char(pos[i]))) {
          i++;
        }
      }

      size_t count = CPPPEGLIB_HEURISTIC_ERROR_TOKEN_MAX_CHAR_COUNT;
      size_t j = 0;
      while (count > 0 && j < i) {
        j += codepoint_length(&pos[j], i - j);
        count--;
      }

      return escape_characters(pos, j);
    }
    return std::string();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdi, %rbx
movq %r8, %rax
subq %rdx, %rax
subq %rax, %r15
jne 0x12dd1
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x12f0a
movq %r8, %r14
movzbl (%r8), %r12d
movl %r12d, %edi
callq 0x8490
movl $0x1, %r13d
testl %eax, %eax
jne 0x12e2a
movl %r12d, %edi
callq 0x8050
testl %eax, %eax
setne %al
cmpq $0x2, %r15
setb %cl
orb %al, %cl
jne 0x12e2a
movzbl (%r14,%r13), %r12d
movl %r12d, %edi
callq 0x8490
testl %eax, %eax
jne 0x12e2a
movl %r12d, %edi
callq 0x8050
testl %eax, %eax
jne 0x12e2a
incq %r13
cmpq %r15, %r13
jb 0x12e02
movq %r15, %r13
movq $-0x1f, %rcx
xorl %edx, %edx
movq %rdx, %rax
movzbl (%r14,%rdx), %edx
movl $0x1, %r15d
testb %dl, %dl
jns 0x12e9d
movq %r13, %rsi
subq %rax, %rsi
cmpq $0x1, %rsi
je 0x12e64
movl %edx, %edi
andl $-0x20, %edi
movl $0x2, %r15d
cmpl $0xc0, %edi
je 0x12e9d
cmpq $0x3, %rsi
jb 0x12e7d
movl %edx, %edi
andl $-0x10, %edi
movl $0x3, %r15d
cmpl $0xe0, %edi
je 0x12e9d
andl $-0x8, %edx
xorl %edi, %edi
cmpl $0xf0, %edx
sete %dil
shll $0x2, %edi
cmpq $0x4, %rsi
movl $0x0, %r15d
cmovaeq %rdi, %r15
leaq (%r15,%rax), %rdx
testq %rcx, %rcx
je 0x12eae
incq %rcx
cmpq %r13, %rdx
jb 0x12e33
leaq 0x10(%rbx), %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
testq %rdx, %rdx
je 0x12f0a
addq %rax, %r15
xorl %r13d, %r13d
leaq 0x32f39(%rip), %r12     # 0x45e10
movb (%r14,%r13), %al
leal -0x9(%rax), %ecx
cmpb $0x5, %cl
jae 0x12ef7
movzbl %cl, %eax
movslq (%r12,%rax,4), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x8480
jmp 0x12f02
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8250
incq %r13
cmpq %r13, %r15
jne 0x12ed7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x12f37
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x82b0
movq %r14, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::ErrorInfo::replace_all(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::string replace_all(std::string str, const std::string &from,
                          const std::string &to) const {
    size_t pos = 0;
    while ((pos = str.find(from, pos)) != std::string::npos) {
      str.replace(pos, from.length(), to);
      pos += to.length();
    }
    return str;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r14
movq (%rcx), %rsi
movq 0x8(%rcx), %rcx
movq %rdx, %rdi
xorl %edx, %edx
callq 0x8410
cmpq $-0x1, %rax
je 0x12fac
movq %rax, %r13
movq 0x8(%r12), %rdx
movq (%r15), %rcx
movq 0x8(%r15), %r8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x82f0
addq 0x8(%r15), %r13
movq (%r12), %rsi
movq 0x8(%r12), %rcx
movq %rbx, %rdi
movq %r13, %rdx
callq 0x8410
movq %rax, %r13
cmpq $-0x1, %rax
jne 0x12f74
leaq 0x10(%r14), %rcx
movq %rcx, (%r14)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rax
cmpq %rax, %rdx
je 0x12fcb
movq %rdx, (%r14)
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
jmp 0x12fd1
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::parser::load_grammar(char const*, unsigned long, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<peg::Ope>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<peg::Ope>>>> const&, std::basic_string_view<char, std::char_traits<char>>)
bool load_grammar(const char *s, size_t n, const Rules &rules,
                    std::string_view start = {}) {
    auto cxt = ParserGenerator::parse(s, n, rules, log_, start);
    grammar_ = cxt.grammar;
    start_ = cxt.start;
    enablePackratParsing_ = cxt.enablePackratParsing;
    return grammar_ != nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, -0x30(%rbp)
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x38(%rdi), %rsi
leaq -0x60(%rbp), %rdi
callq 0xc1b6
movq %r15, -0x40(%rbp)
movq %r14, -0x38(%rbp)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq -0x98(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq -0x30(%rbp), %rcx
leaq -0x60(%rbp), %r8
callq 0x132be
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x1320f
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq -0x90(%rbp), %rsi
movq -0x8(%rsi), %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
callq 0x130c6
leaq -0x88(%rbp), %rsi
leaq 0x10(%rbx), %rdi
callq 0x8170
leaq -0x78(%rbp), %rax
movb 0x10(%rax), %cl
movb %cl, 0x30(%rbx)
movq (%rbx), %rbx
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13258
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x82b0
movq -0x90(%rbp), %rdi
testq %rdi, %rdi
je 0x13269
callq 0x123fc
testq %rbx, %rbx
setne %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x132b6
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x133bc
jmp 0x132ae
movq %rax, %rbx
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x132ae
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x8420
movq %rax, %rdi
callq 0xe032
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::decode[abi:cxx11](char const*, unsigned long)
inline std::u32string decode(const char *s8, size_t l) {
  std::u32string out;
  size_t i = 0;
  while (i < l) {
    auto beg = i++;
    while (i < l && (s8[i] & 0xc0) == 0x80) {
      i++;
    }
    out += decode_codepoint(&s8[beg], (i - beg));
  }
  return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
leaq -0x1(%rdx), %r13
xorl %r14d, %r14d
cmpq %r12, %r14
jae 0x2bd6a
movq %r14, %rax
cmpq %r14, %r13
je 0x2bc96
movb 0x1(%r15,%r14), %cl
incq %r14
andb $-0x40, %cl
negb %cl
jo 0x2bc80
jmp 0x2bc99
movq %r12, %r14
xorl %esi, %esi
movq %r14, %rdx
subq %rax, %rdx
je 0x2bd5d
addq %r15, %rax
movzbl (%rax), %ecx
movl %ecx, %esi
testb %cl, %cl
jns 0x2bd5d
movl %ecx, %esi
andl $-0x20, %esi
cmpl $0xc0, %esi
jne 0x2bce0
movl $0x0, %esi
cmpq $0x1, %rdx
je 0x2bd5d
andl $0x1f, %ecx
shll $0x6, %ecx
movl $0x1, %edx
jmp 0x2bd54
movl %ecx, %esi
andl $-0x10, %esi
cmpl $0xe0, %esi
jne 0x2bd11
movl $0x0, %esi
cmpq $0x3, %rdx
jb 0x2bd5d
andl $0xf, %ecx
shll $0xc, %ecx
movzbl 0x1(%rax), %edx
andl $0x3f, %edx
shll $0x6, %edx
orl %edx, %ecx
movl $0x2, %edx
jmp 0x2bd54
movl %ecx, %esi
andl $-0x8, %esi
cmpl $0xf0, %esi
setne %sil
cmpq $0x4, %rdx
setb %dl
orb %sil, %dl
movl $0x0, %esi
jne 0x2bd5d
andl $0x7, %ecx
shll $0x12, %ecx
movzbl 0x1(%rax), %edx
andl $0x3f, %edx
shll $0xc, %edx
orl %ecx, %edx
movzbl 0x2(%rax), %ecx
andl $0x3f, %ecx
shll $0x6, %ecx
orl %edx, %ecx
movl $0x3, %edx
movzbl (%rax,%rdx), %esi
andl $0x3f, %esi
orl %ecx, %esi
movq %rbx, %rdi
callq 0x2be22
jmp 0x2bc74
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x2bd9c
movq -0x30(%rbp), %rax
movq (%rax), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x82b0
movq %r14, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: std::any peg::call<peg::ParserGenerator::setup_actions()::'lambda7'(peg::SemanticValues const&), peg::SemanticValues&>(peg::ParserGenerator::setup_actions()::'lambda7'(peg::SemanticValues const&), peg::SemanticValues&)
std::any call(F fn, Args &&...args) {
  using R = decltype(fn(std::forward<Args>(args)...));
  if constexpr (std::is_void<R>::value) {
    fn(std::forward<Args>(args)...);
    return std::any();
  } else if constexpr (std::is_same<typename std::remove_cv<R>::type,
                                    std::any>::value) {
    return fn(std::forward<Args>(args)...);
  } else {
    return std::any(fn(std::forward<Args>(args)...));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x40(%rsi), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rsi
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x32923
leaq -0x19(%rbp), %rcx
movb $0x0, (%rcx)
leaq -0x30(%rbp), %rdi
leaq -0x1a(%rbp), %rsi
movq %r14, %rdx
callq 0x2b6f4
movq -0x30(%rbp), %r15
movq -0x28(%rbp), %r14
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x328b8
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x82b0
leaq -0x4d2d(%rip), %rax     # 0x2db92
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movl $0x10, %edi
callq 0x82a0
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0x3291b
movq %r14, %rdi
callq 0x123fc
jmp 0x3291b
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3291b
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x82b0
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: std::vector<peg::ParserGenerator::Instruction, std::allocator<peg::ParserGenerator::Instruction>> peg::SemanticValues::transform<peg::ParserGenerator::Instruction>(unsigned long, unsigned long) const
std::vector<T> transform(size_t beg = 0,
                           size_t end = static_cast<size_t>(-1)) const {
    std::vector<T> r;
    end = (std::min)(end, size());
    for (size_t i = beg; i < end; i++) {
      r.emplace_back(std::any_cast<T>((*this)[i]));
    }
    return r;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rbx
subq (%rsi), %rbx
sarq $0x4, %rbx
cmpq %rcx, %rbx
cmovaeq %rcx, %rbx
subq %rdx, %rbx
jbe 0x3699c
movq %rdx, %r14
movq %rsi, %r15
leaq -0x68(%rbp), %r13
shlq $0x4, %r14
movq (%r15), %rdi
addq %r14, %rdi
callq 0x36b15
movq %rax, %r12
testq %rax, %rax
je 0x369af
movq %r13, -0x78(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0x13028
movq $0x0, -0x50(%rbp)
movq 0x20(%r12), %rax
testq %rax, %rax
je 0x3693c
movq %r12, %rsi
addq $0x20, %rsi
leaq -0x58(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movl $0x2, %edi
leaq -0x38(%rbp), %rdx
callq *%rax
jmp 0x36944
movq $0x0, -0x58(%rbp)
movups 0x30(%r12), %xmm0
movups %xmm0, 0x20(%r13)
movq -0x30(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x369fc
movq -0x58(%rbp), %rax
testq %rax, %rax
je 0x3697a
movl $0x3, %edi
leaq -0x58(%rbp), %rsi
xorl %edx, %edx
callq *%rax
movq $0x0, -0x58(%rbp)
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0x3698f
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x82b0
addq $0x10, %r14
decq %rbx
jne 0x368de
movq -0x30(%rbp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2d5bc
jmp 0x369e0
movq %rax, %r14
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0x369eb
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x82b0
jmp 0x369eb
jmp 0x369e8
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x2df98
jmp 0x369eb
movq %rax, %rdi
callq 0xe032
movq %rax, %r14
movq -0x30(%rbp), %rdi
callq 0x2d364
movq %r14, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Context::line_info(char const*) const
std::pair<size_t, size_t> line_info(const char *cur) const {
    std::call_once(source_line_index_init_, [this]() {
      for (size_t pos = 0; pos < l; pos++) {
        if (s[pos] == '\n') { source_line_index.push_back(pos); }
      }
      source_line_index.push_back(l);
    });

    auto pos = static_cast<size_t>(std::distance(s, cur));

    auto it = std::lower_bound(
        source_line_index.begin(), source_line_index.end(), pos,
        [](size_t element, size_t value) { return element < value; });

    auto id = static_cast<size_t>(std::distance(source_line_index.begin(), it));
    auto off = pos - (id == 0 ? 0 : source_line_index[id - 1] + 1);
    return std::pair(id + 1, off + 1);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x28c, %rdi            # imm = 0x28C
leaq -0x18(%rbp), %rsi
movq %r14, (%rsi)
callq 0x33b6c
subq 0x8(%r14), %rbx
movq 0x290(%r14), %rcx
movq 0x298(%r14), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
testq %rdx, %rdx
jle 0x33b51
movq %rcx, %rax
movq %rdx, %rsi
shrq %rsi
movq %rsi, %rdi
notq %rdi
addq %rdx, %rdi
leaq (%rax,%rsi,8), %rdx
addq $0x8, %rdx
cmpq %rbx, -0x8(%rdx)
cmovbq %rdx, %rax
cmovaeq %rsi, %rdi
movq %rdi, %rdx
testq %rdi, %rdi
jg 0x33b17
subq %rcx, %rax
je 0x33b53
movq -0x8(%rcx,%rax), %rcx
notq %rcx
jmp 0x33b55
xorl %eax, %eax
xorl %ecx, %ecx
sarq $0x3, %rax
incq %rax
leaq (%rbx,%rcx), %rdx
incq %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Context::push_semantic_values_scope()
SemanticValues &push_semantic_values_scope() {
    assert(value_stack_size <= value_stack.size());
    if (value_stack_size == value_stack.size()) {
      value_stack.emplace_back(std::make_shared<SemanticValues>(this));
    } else {
      auto &vs = *value_stack[value_stack_size];
      if (!vs.empty()) {
        vs.clear();
        if (!vs.tags.empty()) { vs.tags.clear(); }
      }
      vs.sv_ = std::string_view();
      vs.choice_count_ = 0;
      vs.choice_ = 0;
      if (!vs.tokens.empty()) { vs.tokens.clear(); }
    }

    auto &vs = *value_stack[value_stack_size++];
    vs.path = path;
    vs.ss = s;
    return vs;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0xb0(%rdi), %rax
leaq 0x98(%rdi), %r14
movq 0x98(%rdi), %rcx
movq 0xa0(%rdi), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
cmpq %rdx, %rax
ja 0x3a716
movq %rdi, %rbx
jne 0x3a69b
movl $0xb0, %edi
callq 0x82a0
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x2358f(%rip), %rcx     # 0x5dbb8
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
xorl %edx, %edx
movq %rdx, 0x60(%rax)
movq %rbx, 0x68(%rax)
leaq 0xa0(%rax), %rsi
movups %xmm0, 0x70(%rax)
movups %xmm0, 0x80(%rax)
movq %rsi, 0x90(%rax)
movq %rdx, 0x98(%rax)
movb $0x0, 0xa0(%rax)
leaq -0x20(%rbp), %rsi
movq %rax, 0x8(%rsi)
movq %rcx, (%rsi)
movq %r14, %rdi
callq 0x3a812
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x3a6dd
callq 0x123fc
jmp 0x3a6dd
shlq $0x4, %rax
movq (%rcx,%rax), %r14
movq (%r14), %rsi
cmpq 0x8(%r14), %rsi
je 0x3a6c2
movq %r14, %rdi
callq 0x3aad6
movq 0x28(%r14), %rax
cmpq 0x30(%r14), %rax
je 0x3a6c2
movq %rax, 0x30(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r14)
movups %xmm0, 0x70(%r14)
movq 0x40(%r14), %rax
cmpq 0x48(%r14), %rax
je 0x3a6dd
movq %rax, 0x48(%r14)
movq 0xb0(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xb0(%rbx)
movq (%rbx), %rcx
movq 0x98(%rbx), %rdx
shlq $0x4, %rax
movq (%rdx,%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x20(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x8827(%rip), %rdi      # 0x42f44
leaq 0x7f91(%rip), %rsi      # 0x426b5
leaq 0x8840(%rip), %rcx      # 0x42f6b
movl $0x374, %edx            # imm = 0x374
callq 0x81b0
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x3a746
callq 0x123fc
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::SemanticValues::append(peg::SemanticValues&)
void append(SemanticValues &chvs) {
    sv_ = chvs.sv_;
    for (auto &v : chvs) {
      emplace_back(std::move(v));
    }
    for (auto &tag : chvs.tags) {
      tags.emplace_back(std::move(tag));
    }
    for (auto &tok : chvs.tokens) {
      tokens.emplace_back(std::move(tok));
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movups 0x60(%rsi), %xmm0
movups %xmm0, 0x60(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x3a787
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb6e4
addq $0x10, %r15
jmp 0x3a771
movq 0x28(%r14), %r15
movq 0x30(%r14), %r13
cmpq %r13, %r15
je 0x3a7c5
leaq 0x28(%rbx), %r12
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
je 0x3a7b1
movl (%r15), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x30(%rbx)
jmp 0x3a7bc
movq %r12, %rdi
movq %r15, %rdx
callq 0x3cc72
addq $0x4, %r15
cmpq %r13, %r15
jne 0x3a798
movq 0x40(%r14), %r15
movq 0x48(%r14), %r12
cmpq %r12, %r15
je 0x3a802
leaq 0x40(%rbx), %r14
movq 0x48(%rbx), %rsi
cmpq 0x50(%rbx), %rsi
je 0x3a7ee
movups (%r15), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x48(%rbx)
jmp 0x3a7f9
movq %r14, %rdi
movq %r15, %rdx
callq 0x3cd94
addq $0x10, %r15
cmpq %r12, %r15
jne 0x3a7d6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Context::shift_capture_values()
void shift_capture_values() {
    assert(capture_scope_stack_size >= 2);
    auto curr = &capture_scope_stack[capture_scope_stack_size - 1];
    auto prev = curr - 1;
    for (const auto &[k, v] : *curr) {
      (*prev)[k] = v;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x130(%rdi), %rcx
cmpq $0x1, %rcx
jbe 0x3abcf
movq 0x118(%rdi), %rax
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %r12
addq $-0x28, %r12
movq 0x10(%r12), %rbx
cmpq %r12, %rbx
je 0x3abc6
leaq (%rax,%rcx), %r14
addq $-0x60, %r14
leaq 0x20(%rbx), %rsi
leaq 0x30(%rbx), %r15
movq %r14, %rdi
callq 0x317d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x8170
movq %rbx, %rdi
callq 0x81f0
movq %rax, %rbx
cmpq %r12, %rax
jne 0x3ab9b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x83ec(%rip), %rdi      # 0x42fc2
leaq 0x7ad8(%rip), %rsi      # 0x426b5
leaq 0x83fc(%rip), %rcx      # 0x42fe0
movl $0x3a6, %edx            # imm = 0x3A6
callq 0x81b0
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::CharacterClass::in_range(std::pair<char32_t, char32_t> const&, char32_t) const
bool in_range(const std::pair<char32_t, char32_t> &range, char32_t cp) const {
    if (ignore_case_) {
      auto cpl = std::tolower(cp);
      return std::tolower(range.first) <= cpl &&
             cpl <= std::tolower(range.second);
    } else {
      return range.first <= cp && cp <= range.second;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpb $0x1, 0x31(%rdi)
jne 0x3afa8
movl %edx, %edi
callq 0x8380
movl %eax, %r14d
movl (%rbx), %edi
callq 0x8380
cmpl %r14d, %eax
jle 0x3afb7
xorl %eax, %eax
jmp 0x3afc5
cmpl %edx, (%rbx)
setbe %cl
cmpl %edx, 0x4(%rbx)
setae %al
andb %cl, %al
jmp 0x3afc5
movl 0x4(%rbx), %edi
callq 0x8380
cmpl %eax, %r14d
setle %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::PrecedenceClimbing::get_reference_for_binop(peg::Context&) const
inline Definition &
PrecedenceClimbing::get_reference_for_binop(Context &c) const {
  if (rule_.is_macro) {
    // Reference parameter in macro
    const auto &args = c.top_args();
    auto iarg = dynamic_cast<Reference &>(*binop_).iarg_;
    auto arg = args[iarg];
    return *dynamic_cast<Reference &>(*arg).rule_;
  }

  return *dynamic_cast<Reference &>(*binop_).rule_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rdi), %rax
movq 0x58(%rdi), %rcx
movb 0xe9(%rcx), %r14b
leaq 0x2075a(%rip), %rsi     # 0x5bd18
leaq 0x20773(%rip), %rdx     # 0x5bd38
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x8300
cmpb $0x1, %r14b
jne 0x3b60c
testq %rax, %rax
je 0x3b611
movq 0xd8(%rbx), %rcx
movq 0x70(%rax), %rax
movq -0x18(%rcx), %rcx
shlq $0x4, %rax
movq (%rcx,%rax), %rdi
movq 0x8(%rcx,%rax), %rbx
testq %rbx, %rbx
je 0x3b616
movq 0x2296e(%rip), %rax     # 0x5df70
cmpb $0x0, (%rax)
je 0x3b636
incl 0x8(%rbx)
jmp 0x3b63a
testq %rax, %rax
jne 0x3b630
callq 0x8470
leaq 0x206fb(%rip), %rsi     # 0x5bd18
leaq 0x20714(%rip), %rdx     # 0x5bd38
xorl %ecx, %ecx
callq 0x8300
testq %rax, %rax
je 0x3b668
movq 0x68(%rax), %r14
jmp 0x3b660
lock
incl 0x8(%rbx)
leaq 0x206d7(%rip), %rsi     # 0x5bd18
leaq 0x206f0(%rip), %rdx     # 0x5bd38
xorl %ecx, %ecx
callq 0x8300
testq %rax, %rax
je 0x3b668
movq 0x68(%rax), %r14
movq %rbx, %rdi
callq 0x123fc
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x8470
movq %rax, %r14
testq %rbx, %rbx
je 0x3b67d
movq %rbx, %rdi
callq 0x123fc
movq %r14, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::parser::get_no_ast_opt_rules[abi:cxx11]() const
std::vector<std::string> get_no_ast_opt_rules() const {
    std::vector<std::string> rules;
    for (auto &[name, rule] : *grammar_) {
      if (rule.no_ast_opt) { rules.push_back(name); }
    }
    return rules;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq 0x10(%rax), %r14
testq %r14, %r14
je 0x400ab
cmpb $0x1, 0x1e0(%r14)
jne 0x400a6
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x40478
movq (%r14), %r14
jmp 0x4008b
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x299c8
movq %r14, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/fzbz.cc
// Function: Value::str[abi:cxx11]() const
string str() const {
    switch (v.index()) {
      case 0:
        return "nil";
      case 1:
        return get<bool>() ? "true" : "false";
      case 2:
        return to_string(get<long>());
      case 3:
        return string(get<string_view>());
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movzbl 0x20(%rsi), %eax
leaq 0x117d(%rip), %rcx      # 0x421ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x200f(%rip), %rsi      # 0x43095
leaq 0x200b(%rip), %rdx      # 0x43098
jmp 0x41154
movq %rsi, %rdi
callq 0xdd86
movq %rax, %r15
movq %rax, %r14
negq %r14
cmovsq %rax, %r14
movl $0x1, %r12d
cmpq $0xa, %r14
jb 0x41167
movl $0x4, %r12d
movabsq $0x346dc5d63886594b, %rsi # imm = 0x346DC5D63886594B
movq %r14, %rcx
cmpq $0x63, %rcx
jbe 0x4115e
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0x41164
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0x41167
movq %rcx, %rax
mulq %rsi
shrq $0xb, %rdx
addl $0x4, %r12d
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0x410ca
addl $-0x3, %r12d
jmp 0x41167
movq %rsi, %rdi
callq 0x39cc8
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
addq %rdx, %rax
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
jmp 0x41157
movq %rsi, %rdi
callq 0xdc38
leaq 0x1f63(%rip), %rcx      # 0x43099
leaq 0x1f61(%rip), %rsi      # 0x4309e
testb %al, %al
cmovneq %rcx, %rsi
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movzbl %al, %edx
xorq $0x5, %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x11634
jmp 0x41194
addl $-0x2, %r12d
jmp 0x41167
decl %r12d
shrq $0x3f, %r15
leal (%r15,%r12), %esi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movl $0x2d, %edx
callq 0x8320
addq (%rbx), %r15
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x411a0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./word_io.h
// Function: unsigned int readU<unsigned int>(std::istream&, bool)
static inline T readU(std::istream& in, bool swap) {
	T x;
	in.read((char *)&x, sizeof(T));
	assert_eq(sizeof(T), in.gcount());
	if(swap) {
		if(sizeof(T) == 4) {
			return endianSwapU32(x);
		} else if(sizeof(T) == 8) {
			return endianSwapU64(x);
		} else {
			assert(false);
		}
	} else {
		return x;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
callq 0x4400
cmpq $0x4, 0x8(%r14)
jne 0xe317
movl 0xc(%rsp), %ecx
movl %ecx, %eax
bswapl %eax
testb %bl, %bl
cmovel %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x28c9a(%rip), %rbx     # 0x36fb8
leaq 0x1dec1(%rip), %rsi     # 0x2c1e6
movq %rbx, %rdi
callq 0x4300
movl $0x4, %esi
movq %rax, %rdi
callq 0x40c0
leaq 0x1debb(%rip), %r15     # 0x2c1fc
movq %rax, %rdi
movq %r15, %rsi
callq 0x4300
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movl $0x4, %esi
movq %rax, %rdi
callq 0x40c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
leaq 0x1de77(%rip), %rsi     # 0x2c201
movq %rax, %rdi
callq 0x4300
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x4640
movq %rax, %rdi
movq %r15, %rsi
callq 0x4300
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x4640
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
leaq 0x20026(%rip), %rsi     # 0x2e40c
movq %rax, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4150
leaq 0x1f92d(%rip), %r14     # 0x2dd2a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4300
leaq 0x1f3b9(%rip), %rsi     # 0x2d7c8
movq %rax, %rdi
callq 0x4300
movq %rax, %rdi
movl $0x37, %esi
callq 0x4600
movq %rax, %rdi
callq 0x4150
leaq 0x1f275(%rip), %rdi     # 0x2d6a8
leaq 0x2009b(%rip), %rcx     # 0x2e4d5
movq %r14, %rsi
movl $0x37, %edx
callq 0x41c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/dataprov_hook/hook_cli.c
// Function: output_next
scdcint_t output_next(scdc_dataset_output_t *output, scdc_result_t *result)
{
  scdcint_t i = (intptr_t) output->data;


  if (strcmp(output->format, "text") == 0 || strcmp(output->format, "fslist") == 0)
    printf(PREFIX "processing OUTPUT #%" scdcint_fmt ": '%.*s'\n", i, (int) SCDC_DATASET_INOUT_BUF_CURRENT(output), (char *) SCDC_DATASET_INOUT_BUF_PTR(output));
  else
    printf(PREFIX "processing OUTPUT #%" scdcint_fmt": %" scdcint_fmt " bytes\n", i, SCDC_DATASET_INOUT_BUF_CURRENT(output));

  output->data = (void *) (intptr_t) (i + 1);

  return SCDC_SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r14
leaq 0x4fb97(%rip), %rsi     # 0x5c041
callq 0xb750
testl %eax, %eax
je 0xc4dd
leaq 0x52320(%rip), %rsi     # 0x5e7da
movq %rbx, %rdi
callq 0xb750
testl %eax, %eax
je 0xc4dd
movq 0x20(%rbx), %rdx
leaq 0x4fba0(%rip), %rdi     # 0x5c071
movq %r14, %rsi
xorl %eax, %eax
callq 0xb080
jmp 0xc4f5
movl 0x20(%rbx), %edx
movq 0x10(%rbx), %rcx
leaq 0x4fb5b(%rip), %rdi     # 0x5c046
movq %r14, %rsi
xorl %eax, %eax
callq 0xb080
incq %r14
movq %r14, 0x40(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/dataprov_hook/hook_cli.c
// Function: main
int main(int argc, char *argv[])
{
  scdc_dataprov_t dp_hook = SCDC_DATAPROV_NULL;

  scdc_dataset_t dataset = SCDC_DATASET_NULL;

#define OPTARG_MAX  256
  char scheme[OPTARG_MAX] = { '\0' }, authority[OPTARG_MAX] = { '\0' }, open[OPTARG_MAX] = { '\0' }, cmdline[OPTARG_MAX] = { '\0' };


  printf(PREFIX "start hook demo client\n");

#if 0
  strcpy(scheme, "scdc");
  strcpy(authority, "");
#elif 1
  strcpy(scheme, "scdc+uds");
  strcpy(authority, "");
#elif 1
  strcpy(scheme, "scdc+tcp");
  strcpy(authority, "localhost");
#endif
  strcpy(open, "hookdemo/");
  strcpy(cmdline, "ls");

  scdc_init(SCDC_INIT_DEFAULT);

  dp_hook = scdc_dataprov_open("hookdemo", "hook:id", &hook, 0x2501);

  if (strlen(scheme) > 0 || strlen(authority) > 0 || strlen(open) > 0)
  {
    char uri[1024];

    sprintf(uri, "%s://%s/%s", scheme, authority, open);

    printf(PREFIX "uri: '%s'\n", uri);

    dataset = scdc_dataset_open(uri);
  }

  printf(PREFIX "dataset: %p\n", dataset);

  do_dataset_cmd(dataset, cmdline);

  scdc_dataset_close(dataset);

  scdc_dataprov_close(dp_hook);

  scdc_release();

  printf(PREFIX "quit hook demo client\n");

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
leaq 0x300(%rsp), %rbx
xorl %ebp, %ebp
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb2d0
leaq 0x4fa9a(%rip), %rdi     # 0x5c124
callq 0xb840
leaq 0x209(%rsp), %r14
movl $0xf7, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xb2d0
movabsq $0x7364752b63646373, %rax # imm = 0x7364752B63646373
movq %rax, -0x9(%r14)
movb %bpl, -0x1(%r14)
movb %bpl, (%rbx)
leaq 0x10a(%rsp), %r14
movl $0xf6, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xb2d0
movabsq $0x6f6d65646b6f6f68, %rax # imm = 0x6F6D65646B6F6F68
movq %rax, -0xa(%r14)
movw $0x2f, -0x2(%r14)
leaq 0x3(%rsp), %r14
movl $0xfd, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xb2d0
movb %bpl, -0x1(%r14)
movw $0x736c, -0x3(%r14)     # imm = 0x736C
leaq 0x51320(%rip), %rdi     # 0x5da2d
xorl %eax, %eax
callq 0xcee9
leaq 0x4f9c1(%rip), %rdi     # 0x5c0dc
leaq 0x4f9c3(%rip), %rsi     # 0x5c0e5
leaq 0x6a4cf(%rip), %rdx     # 0x76bf8
movl $0x2501, %ecx           # imm = 0x2501
xorl %eax, %eax
callq 0xd2a3
movq %rax, %r14
leaq 0x4f9ae(%rip), %rsi     # 0x5c0ed
leaq 0x400(%rsp), %r15
leaq 0x200(%rsp), %rdx
leaq 0x100(%rsp), %r8
movq %r15, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0xb0d0
leaq 0x4f98d(%rip), %rdi     # 0x5c0f8
movq %r15, %rsi
xorl %eax, %eax
callq 0xb080
movq %r15, %rdi
xorl %eax, %eax
callq 0xdd11
movq %rax, %rbx
leaq 0x4f984(%rip), %rdi     # 0x5c10d
movq %rax, %rsi
xorl %eax, %eax
callq 0xb080
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xc509
movq %rbx, %rdi
callq 0xde03
movq %r14, %rdi
callq 0xd39e
callq 0xcfea
leaq 0x4f98b(%rip), %rdi     # 0x5c145
callq 0xb840
xorl %eax, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cpearce[P]OggIndex/src/OggIndexValid.cpp
// Function: main
int main(int argc, char** argv) 
{
  if (argc != 2) {
    PrintUsage();
    return -1;
  }
  bool valid = ValidateIndexedOgg(string(argv[1]));
  cout << "Index is " << (valid ? "" : "NOT ") << "valid" << endl;
  return valid ? 0 : -1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x2, %edi
jne 0x79e9
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x7b42
movq %rbx, %rdi
callq 0xbf18
movl %eax, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7963
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4370
movq 0xd666(%rip), %r14      # 0x14fd0
leaq 0x7f34(%rip), %rsi      # 0xf8a5
movl $0x9, %edx
movq %r14, %rdi
callq 0x43d0
leaq 0x87cd(%rip), %rax      # 0x10152
leaq 0x7f23(%rip), %rsi      # 0xf8af
testb %bl, %bl
cmovneq %rax, %rsi
movl %ebx, %eax
xorb $0x1, %al
movzbl %al, %edx
shll $0x2, %edx
movq %r14, %rdi
callq 0x43d0
leaq 0x7f6b(%rip), %rsi      # 0xf916
movl $0x5, %edx
movq %r14, %rdi
callq 0x43d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4330
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4240
movzbl %bl, %eax
decl %eax
jmp 0x7b14
movq 0xd5e0(%rip), %rbx      # 0x14fd0
leaq 0x7ebd(%rip), %rsi      # 0xf8b4
movl $0xe, %edx
movq %rbx, %rdi
callq 0x43d0
leaq 0x7eb8(%rip), %rsi      # 0xf8c3
movl $0x9, %edx
movq %rbx, %rdi
callq 0x43d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4330
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4240
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4330
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4240
movq %rax, %rbx
leaq 0x7e5a(%rip), %rsi      # 0xf8cd
movl $0x6, %edx
movq %rax, %rdi
callq 0x43d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4330
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4240
movq %rax, %rbx
leaq 0x7e23(%rip), %rsi      # 0xf8d4
movl $0x1d, %edx
movq %rax, %rdi
callq 0x43d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4330
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4240
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4330
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7b3a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4370
movq %rbx, %rdi
callq 0x4670
// File: /workspace/github_cpp_makefile_star2_O3/narula[P]skiplists/skiplist.cc
// Function: SkipList::findNodeFast(int)
int SkipList::findNodeFast(int key) {
  node* pred = head;
  inc();
  for (int level = pred->topLevel-1; level >= 0; level--) {
	node* curr = pred->nexts[level].nxt;
	while (key > pred->nexts[level].prefix) {
	  pred = curr; 
	  curr = pred->nexts[level].nxt;
	  inc();
	}
	if (key == pred->nexts[level].prefix) {
	  return level;
	}
  }
  return -1;
}

// Assembly:
movq (%rdi), %r8
movl 0x1c(%rdi), %ecx
movl 0x18(%rdi), %edx
cmpl $0x1, %ecx
jne 0x1305
incl %edx
movl %edx, 0x18(%rdi)
movl 0x4(%r8), %eax
testl %eax, %eax
jle 0x134f
decq %rax
movl %eax, %r9d
shlq $0x4, %r9
movl 0x8(%r8,%r9), %r11d
cmpl %esi, %r11d
jge 0x1349
addq $0x8, %r8
movq 0x8(%r8,%r9), %r10
movq %r10, %r8
movq 0x10(%r10,%r9), %r10
cmpl $0x1, %ecx
jne 0x133c
incl %edx
movl %edx, 0x18(%rdi)
leaq 0x8(%r8), %r11
movl (%r11,%r9), %r11d
cmpl %esi, %r11d
jl 0x132a
cmpl %esi, %r11d
jne 0x1309
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O3/narula[P]skiplists/skiplist.cc
// Function: randomLevel(int, int)
int randomLevel(int max, int probability) {
  unsigned long long x = rand();
  int toplayer = 1;
  switch (probability) {
  case 4:
	while((x & 3) == 3){
	  toplayer += 1;
	  x >>= 2;
	}
	break;
  case 8:
	while((x & 7) == 7){
	  toplayer += 1;
	  x >>= 3;
	}
	break;
  case 16:
	while((x & 15) == 15){
	  toplayer += 1;
	  x >>= 4;
	}
	break;
  case 32:
	while((x & 31) == 31){
	  toplayer += 1;
	  x >>= 5;
	}
	break;
  default:
	while((x & 1) != 0) {
	  toplayer += 1;
	  x >>= 1;
	}
	break;
  }
  if(toplayer > max)
	toplayer = max;
  return toplayer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %edi, %ebx
callq 0x1040
movslq %eax, %rcx
addl $-0x4, %r14d
roll $0x1e, %r14d
cmpl $0x7, %r14d
ja 0x140f
leaq 0xc85(%rip), %rdx       # 0x2004
movslq (%rdx,%r14,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
notl %eax
movl $0x1, %edx
testb $0x3, %al
jne 0x1429
movq %rcx, %rax
incl %edx
shrq $0x2, %rax
notl %ecx
testb $0xc, %cl
movq %rax, %rcx
je 0x139a
jmp 0x1429
notl %eax
movl $0x1, %edx
testb $0xf, %al
jne 0x1429
movq %rcx, %rax
incl %edx
shrq $0x4, %rax
notl %ecx
testb $-0x10, %cl
movq %rax, %rcx
je 0x13ba
jmp 0x1429
notl %eax
movl $0x1, %edx
testb $0x7, %al
jne 0x1429
movq %rcx, %rax
incl %edx
shrq $0x3, %rax
notl %ecx
testb $0x38, %cl
movq %rax, %rcx
je 0x13da
jmp 0x1429
notl %eax
movl $0x1, %edx
testb $0x1f, %al
jne 0x1429
movq %rcx, %rax
incl %edx
shrq $0x5, %rax
notl %ecx
testl $0x3e0, %ecx            # imm = 0x3E0
movq %rax, %rcx
je 0x13fa
jmp 0x1429
movl $0x1, %edx
testb $0x1, %cl
je 0x1429
movq %rcx, %rax
incl %edx
shrq %rax
testb $0x2, %cl
movq %rax, %rcx
jne 0x141c
cmpl %ebx, %edx
cmovll %edx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/narula[P]skiplists/skiplist.cc
// Function: SkipList::findNode(int, node**, node**)
int SkipList::findNode(int key, node* preds[], node* succs[]) {
  int lFound = -1;
  node* pred = head;
  inc();
  for (int level = pred->topLevel-1; level >= 0; level--) {
	node* curr = pred->nexts[level].nxt;
	while (key > pred->nexts[level].prefix) {
	  pred = curr; 
	  curr = pred->nexts[level].nxt;
	  inc();
	}
	if (lFound == -1 && key == pred->nexts[level].prefix) {
	  lFound = level;
	}
	preds[level] = pred;
	succs[level] = curr;
  }
  return lFound;
}

// Assembly:
movq (%rdi), %r9
movl 0x1c(%rdi), %r8d
cmpl $0x1, %r8d
jne 0x1448
incl 0x18(%rdi)
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq 0x4(%r9), %r10
testq %r10, %r10
jle 0x14c0
movl 0x18(%rdi), %r11d
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq -0x1(%r10), %r14
movq %r14, %rax
shlq $0x4, %rax
movq 0x10(%r9,%rax), %r15
movl 0x8(%r9,%rax), %ebp
cmpl %esi, %ebp
jge 0x149a
movq %r15, %r9
movq 0x10(%r15,%rax), %r15
cmpl $0x1, %r8d
jne 0x1490
incl %r11d
movl %r11d, 0x18(%rdi)
leaq 0x8(%r9), %r12
movl (%r12,%rax), %ebp
jmp 0x1477
cmpl %esi, %ebp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovel %r14d, %eax
cmpl $-0x1, %ebx
cmovnel %ebx, %eax
movq %r9, (%rdx,%r14,8)
movq %r15, (%rcx,%r14,8)
movl %eax, %ebx
cmpq $0x1, %r10
movq %r14, %r10
jg 0x1462
jmp 0x14c5
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq