LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x188b0
movq -0x10(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf870
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf8a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xf8d0
testb $0x1, %al
jne 0x18840
jmp 0x1889f
leaq -0x20(%rbp), %rdi
callq 0xf910
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xf930
movq -0x58(%rbp), %rdi
callq 0xded0
movq -0x50(%rbp), %rsi
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x18874
leaq -0x38(%rbp), %rdi
callq 0xda50
leaq -0x20(%rbp), %rdi
callq 0xf9e0
jmp 0x1882d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xda50
jmp 0x188b6
movq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x115e0
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xa650
nop
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::AnyCharacter::parse_core(char const*, unsigned long, peg::SemanticValues&, peg::Context&, std::any&) const
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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x21340
movq %rax, -0x40(%rbp)
cmpq $0x1, -0x40(%rbp)
jae 0x18a53
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xd050
movq $-0x1, -0x8(%rbp)
jmp 0x18a5b
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Definition::is_token() const::'lambda'()::operator()() const
bool is_token() const {
    std::call_once(is_token_init_, [this]() {
      is_token_ = TokenChecker::is_token(*get_core_operator());
    });
    return is_token_;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq %rsi, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x19720
movq -0x30(%rbp), %rdi
callq 0x104b0
movq %rax, %rdi
callq 0x19f70
movb %al, -0x25(%rbp)
jmp 0x19f2a
movq -0x38(%rbp), %rax
movb -0x25(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x1d4(%rax)
leaq -0x18(%rbp), %rdi
callq 0xda50
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xda50
movq -0x20(%rbp), %rdi
callq 0xa650
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a010
testb $0x1, %al
jne 0x19f8b
jmp 0x19f91
movb $0x1, -0x1(%rbp)
jmp 0x19fee
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1a080
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x19fb1
movb $0x1, %al
testb $0x1, -0x18(%rbp)
movb %al, -0x39(%rbp)
jne 0x19fc4
movb -0x17(%rbp), %al
xorb $-0x1, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x15660
jmp 0x19fee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x15660
jmp 0x19ff9
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq 0x130(%rdi), %rax
movq %rax, -0x60(%rbp)
addq $0x118, %rdi            # imm = 0x118
callq 0x1c620
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
ja 0x1b49c
jmp 0x1b4bb
leaq 0x867b7(%rip), %rdi     # 0xa1c5a
leaq 0x867e7(%rip), %rsi     # 0xa1c91
movl $0x398, %edx            # imm = 0x398
leaq 0x867e6(%rip), %rcx     # 0xa1c9c
callq 0xa290
movq -0x68(%rbp), %rdi
movq 0x130(%rdi), %rax
movq %rax, -0x70(%rbp)
addq $0x118, %rdi            # imm = 0x118
callq 0x1c620
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jne 0x1b53d
movq -0x68(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movq %rax, -0x80(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1c6d0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x1c650
jmp 0x1b51b
leaq -0x40(%rbp), %rdi
callq 0x1c6f0
jmp 0x1b573
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1c6f0
jmp 0x1b592
movq -0x68(%rbp), %rax
movq %rax, %rdi
addq $0x118, %rdi            # imm = 0x118
movq 0x130(%rax), %rsi
callq 0xfe70
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x1c710
testb $0x1, %al
jne 0x1b571
movq -0x58(%rbp), %rdi
callq 0x1c730
jmp 0x1b573
movq -0x68(%rbp), %rax
movq 0x130(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x130(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xa650
nopl (%rax,%rax)
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Context::is_traceable(peg::Ope const&) const
inline bool Context::is_traceable(const Ope &ope) const {
  if (tracer_enter && tracer_leave) {
    if (ignore_trace_state) { return false; }
    return !dynamic_cast<const peg::Reference *>(&ope);
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x1f0, %rdi            # imm = 0x1F0
callq 0x1c4b0
testb $0x1, %al
jne 0x1e5aa
jmp 0x1e61e
movq -0x20(%rbp), %rdi
addq $0x210, %rdi            # imm = 0x210
callq 0x1c540
testb $0x1, %al
jne 0x1e5c0
jmp 0x1e61e
movq -0x20(%rbp), %rax
testb $0x1, 0x288(%rax)
je 0x1e5d3
movb $0x0, -0x1(%rbp)
jmp 0x1e622
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1e602
movq -0x28(%rbp), %rdi
leaq 0xd456c(%rip), %rsi     # 0xf2b58
leaq 0xd4585(%rip), %rdx     # 0xf2b78
xorl %eax, %eax
movl %eax, %ecx
callq 0xa480
movq %rax, -0x30(%rbp)
jmp 0x1e60a
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x1e60a
movq -0x30(%rbp), %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1e622
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x210a0
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x21092
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x21067
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
subq %rdi, %rsi
callq 0x21500
incq %rax
movq %rax, -0x40(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x34(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x21580
movq -0x58(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x215b0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x18ff0
movq %rax, %rcx
movq -0x58(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x21283
movq -0x60(%rbp), %rdi
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movsbl (%rax,%rcx), %esi
callq 0x215e0
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %edi
callq 0xa6e0
cmpl $0x0, %eax
jne 0x21212
movl -0x3c(%rbp), %edi
callq 0xa050
cmpl $0x0, %eax
jne 0x21212
jmp 0x2119b
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0x71(%rbp)
jae 0x211f9
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x215e0
movl %eax, %edi
callq 0xa6e0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x71(%rbp)
jne 0x211f9
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x215e0
movl %eax, %edi
callq 0xa050
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x21202
jmp 0x21210
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2119b
jmp 0x21212
movq $0x20, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x48(%rbp)
movb %al, -0x72(%rbp)
jbe 0x2123c
movq -0x50(%rbp), %rax
cmpq -0x38(%rbp), %rax
setb %al
movb %al, -0x72(%rbp)
movb -0x72(%rbp), %al
testb $0x1, %al
jne 0x21245
jmp 0x21270
movq -0x28(%rbp), %rdi
addq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
subq -0x50(%rbp), %rsi
callq 0x21340
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x21222
movq -0x70(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x21600
jmp 0x2128c
movq -0x70(%rbp), %rdi
callq 0xa520
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdx, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xa720
movq %rax, -0x30(%rbp)
cmpq $-0x1, %rax
je 0x21326
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa5a0
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
movq -0x28(%rbp), %rcx
callq 0xa110
movq -0x28(%rbp), %rdi
callq 0xa5a0
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x212d3
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0xa240
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::codepoint_length(char const*, unsigned long)
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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x213e3
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x21378
movq $0x1, -0x8(%rbp)
jmp 0x213eb
movzbl -0x19(%rbp), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0x21399
cmpq $0x2, -0x18(%rbp)
jb 0x21399
movq $0x2, -0x8(%rbp)
jmp 0x213eb
movzbl -0x19(%rbp), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0x213ba
cmpq $0x3, -0x18(%rbp)
jb 0x213ba
movq $0x3, -0x8(%rbp)
jmp 0x213eb
movzbl -0x19(%rbp), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0x213db
cmpq $0x4, -0x18(%rbp)
jb 0x213db
movq $0x4, -0x8(%rbp)
jmp 0x213eb
jmp 0x213dd
jmp 0x213df
jmp 0x213e1
jmp 0x213e3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::codepoint_count(char const*, unsigned long)
inline size_t codepoint_count(const char *s8, size_t l) {
  size_t count = 0;
  for (size_t i = 0; i < l;) {
    auto len = codepoint_length(s8 + i, l - i);
    if (len == 0) {
      // Invalid UTF-8 byte, treat as single byte to avoid infinite loop
      len = 1;
    }
    i += len;
    count++;
  }
  return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2156c
movq -0x8(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
subq -0x20(%rbp), %rsi
callq 0x21340
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x21552
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x21520
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::escape_characters[abi:cxx11](char const*, unsigned long)
inline std::string escape_characters(const char *s, size_t n) {
  std::string str;
  for (size_t i = 0; i < n; i++) {
    auto c = s[i];
    switch (c) {
    case '\f': str += "\\f"; break;
    case '\n': str += "\\n"; break;
    case '\r': str += "\\r"; break;
    case '\t': str += "\\t"; break;
    case '\v': str += "\\v"; break;
    default: str += c; break;
    }
  }
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xa520
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x21718
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
addl $-0x9, %eax
movl %eax, %ecx
movq %rcx, -0x58(%rbp)
subl $0x4, %eax
ja 0x216f4
movq -0x58(%rbp), %rax
leaq 0x7f9a7(%rip), %rcx     # 0xa1014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x50(%rbp), %rdi
leaq 0x806de(%rip), %rsi     # 0xa1d5f
callq 0xa390
jmp 0x21688
jmp 0x21705
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xa250
jmp 0x21735
movq -0x50(%rbp), %rdi
leaq 0x806b3(%rip), %rsi     # 0xa1d62
callq 0xa390
jmp 0x216b6
jmp 0x21705
movq -0x50(%rbp), %rdi
leaq 0x806a2(%rip), %rsi     # 0xa1d65
callq 0xa390
jmp 0x216ca
jmp 0x21705
movq -0x50(%rbp), %rdi
leaq 0x80691(%rip), %rsi     # 0xa1d68
callq 0xa390
jmp 0x216de
jmp 0x21705
movq -0x50(%rbp), %rdi
leaq 0x80680(%rip), %rsi     # 0xa1d6b
callq 0xa390
jmp 0x216f2
jmp 0x21705
movq -0x50(%rbp), %rdi
movsbl -0x29(%rbp), %esi
callq 0xa260
jmp 0x21703
jmp 0x21705
jmp 0x21707
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x21630
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2172b
movq -0x50(%rbp), %rdi
callq 0xa250
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xa650
nop
// File: 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
subq $0xf0, %rsp
movq %r8, -0x10(%rbp)
movq %r9, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rsi
movq %rsi, -0xd8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xc0(%rbp)
addq $0x38, %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x10520
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq -0xc0(%rbp), %rcx
movq -0xb8(%rbp), %r8
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0xa0(%rbp)
movaps -0xa0(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, (%rax)
leaq -0x68(%rbp), %rdi
callq 0x21dc0
jmp 0x21cb5
leaq -0x88(%rbp), %rdi
callq 0xd9d0
movq -0xd8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x21f10
movq -0xd8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
addq $0x10, %rdi
callq 0xa040
jmp 0x21ce7
movq -0xd8(%rbp), %rdi
movb -0x38(%rbp), %al
andb $0x1, %al
movb %al, 0x30(%rdi)
xorl %eax, %eax
movl %eax, %esi
callq 0x21f40
movb %al, -0xd9(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x21f70
movb -0xd9(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xd9d0
jmp 0x21d5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x21f70
movq -0xa8(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x48890
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x48619
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x51(%rbp)
jae 0x485bc
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0xc0, %eax
cmpl $0x80, %eax
sete %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x485c5
jmp 0x485d3
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x48591
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
addq %rax, %rdi
movq -0x28(%rbp), %rsi
subq %rax, %rsi
callq 0x48900
movl %eax, -0x58(%rbp)
jmp 0x485ef
movl -0x58(%rbp), %esi
movq -0x50(%rbp), %rdi
callq 0x48940
jmp 0x485fd
jmp 0x48570
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x48790
jmp 0x48636
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x4862c
movq -0x50(%rbp), %rdi
callq 0x48790
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xa650
nop
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> peg::SemanticValues::transform<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(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
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x3c590
movq -0x70(%rbp), %rdi
callq 0x4ed80
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x19490
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x61280
movq -0x70(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4ec10
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x4ec30
jmp 0x61235
movq -0x80(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x61320
jmp 0x61244
leaq -0x58(%rbp), %rdi
callq 0xa250
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x61210
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x612a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xa250
jmp 0x612a0
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x61293
movq -0x80(%rbp), %rdi
callq 0x3c720
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x3c720
movq -0x60(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::parse_hex_number(char const*, unsigned long, unsigned long)
inline std::pair<int, size_t> parse_hex_number(const char *s, size_t n,
                                               size_t i) {
  int ret = 0;
  int val;
  while (i < n && is_hex(s[i], val)) {
    ret = static_cast<int>(ret * 16 + val);
    i++;
  }
  return std::pair(ret, i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0x64792
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %rsi
movsbl (%rax,%rcx), %edi
callq 0x649a0
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x6479b
jmp 0x647b5
movl -0x2c(%rbp), %eax
shll $0x4, %eax
addl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6476b
leaq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x21580
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::parse_octal_number(char const*, unsigned long, unsigned long)
inline std::pair<int, size_t> parse_octal_number(const char *s, size_t n,
                                                 size_t i) {
  int ret = 0;
  int val;
  while (i < n && is_digit(s[i], val)) {
    ret = static_cast<int>(ret * 8 + val);
    i++;
  }
  return std::pair(ret, i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0x64952
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %rsi
movsbl (%rax,%rcx), %edi
callq 0x64d80
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x6495b
jmp 0x64975
movl -0x2c(%rbp), %eax
shll $0x3, %eax
addl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6492b
leaq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x21580
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::is_hex(char, int&)
inline bool is_hex(char c, int &v) {
  if ('0' <= c && c <= '9') {
    v = c - '0';
    return true;
  } else if ('a' <= c && c <= 'f') {
    v = c - 'a' + 10;
    return true;
  } else if ('A' <= c && c <= 'F') {
    v = c - 'A' + 10;
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movsbl -0x2(%rbp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x649d7
movsbl -0x2(%rbp), %eax
cmpl $0x39, %eax
jg 0x649d7
movsbl -0x2(%rbp), %ecx
subl $0x30, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x64a37
movsbl -0x2(%rbp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0x64a03
movsbl -0x2(%rbp), %eax
cmpl $0x66, %eax
jg 0x64a03
movsbl -0x2(%rbp), %ecx
subl $0x61, %ecx
addl $0xa, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x64a37
movsbl -0x2(%rbp), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0x64a2f
movsbl -0x2(%rbp), %eax
cmpl $0x46, %eax
jg 0x64a2f
movsbl -0x2(%rbp), %ecx
subl $0x41, %ecx
addl $0xa, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x64a37
jmp 0x64a31
jmp 0x64a33
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::is_digit(char, int&)
inline bool is_digit(char c, int &v) {
  if ('0' <= c && c <= '9') {
    v = c - '0';
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movsbl -0x2(%rbp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x64db7
movsbl -0x2(%rbp), %eax
cmpl $0x39, %eax
jg 0x64db7
movsbl -0x2(%rbp), %ecx
subl $0x30, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x64dbb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq %rax, %rdi
addq $0x28c, %rdi            # imm = 0x28C
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x68130
movq -0x90(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x18ff0
movq -0x90(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x290, %rdi            # imm = 0x290
callq 0x1ebe0
movq -0x90(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x290, %rdi            # imm = 0x290
callq 0x1ea30
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x681b0
movq -0x90(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x290, %rdi            # imm = 0x290
callq 0x1ebe0
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x68200
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x680ad
xorl %eax, %eax
movq %rax, -0x98(%rbp)
jmp 0x680d6
movq -0x90(%rbp), %rdi
addq $0x290, %rdi            # imm = 0x290
movq -0x58(%rbp), %rsi
subq $0x1, %rsi
callq 0x68240
movq (%rax), %rax
addq $0x1, %rax
movq %rax, -0x98(%rbp)
movq -0x88(%rbp), %rax
movq -0x98(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x58(%rbp), %rax
incq %rax
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rax
incq %rax
movq %rax, -0x80(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x68260
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Definition::initialize_definition_ids() const::'lambda'()::operator()() const
void initialize_definition_ids() const {
    std::call_once(definition_ids_init_, [&]() {
      AssignIDToDefinition vis;
      holder_->accept(vis);
      if (whitespaceOpe) { whitespaceOpe->accept(vis); }
      if (wordOpe) { wordOpe->accept(vis); }
      definition_ids_.swap(vis.ids);
    });
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x7b900
movq -0x68(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x19b90
movq -0x60(%rbp), %rsi
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x7b836
movq -0x68(%rbp), %rdi
addq $0xc8, %rdi
callq 0xd270
testb $0x1, %al
jne 0x7b84c
jmp 0x7b887
movq -0x68(%rbp), %rdi
addq $0xc8, %rdi
callq 0xded0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq -0x48(%rbp), %rsi
callq *%rax
jmp 0x7b86e
jmp 0x7b887
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x183b0
jmp 0x7b8e8
movq -0x68(%rbp), %rdi
addq $0xd8, %rdi
callq 0xd270
testb $0x1, %al
jne 0x7b89d
jmp 0x7b8c1
movq -0x68(%rbp), %rdi
addq $0xd8, %rdi
callq 0xded0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq -0x48(%rbp), %rsi
callq *%rax
jmp 0x7b8bf
jmp 0x7b8c1
movq -0x68(%rbp), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
leaq -0x48(%rbp), %rsi
addq $0x8, %rsi
callq 0x7b940
leaq -0x48(%rbp), %rdi
callq 0x183b0
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq 0xb0(%rdi), %rax
movq %rax, -0x58(%rbp)
addq $0x98, %rdi
callq 0x86680
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
ja 0x862fc
jmp 0x8631b
leaq 0x1c23c(%rip), %rdi     # 0xa253f
leaq 0x1b987(%rip), %rsi     # 0xa1c91
movl $0x374, %edx            # imm = 0x374
leaq 0x1c250(%rip), %rcx     # 0xa2566
callq 0xa290
movq -0x60(%rbp), %rdi
movq 0xb0(%rdi), %rax
movq %rax, -0x68(%rbp)
addq $0x98, %rdi
callq 0x86680
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jne 0x863a0
movq -0x60(%rbp), %rax
movq %rax, %rcx
addq $0x98, %rcx
movq %rcx, -0x78(%rbp)
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x70(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x86720
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x866a0
jmp 0x86378
leaq -0x18(%rbp), %rdi
callq 0x1e170
jmp 0x86451
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1e170
jmp 0x864b0
movq -0x60(%rbp), %rax
movq %rax, %rdi
addq $0x98, %rdi
movq 0xb0(%rax), %rsi
callq 0x86790
movq %rax, %rdi
callq 0x867b0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x57130
testb $0x1, %al
jne 0x863fc
movq -0x38(%rbp), %rdi
callq 0x867e0
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
callq 0x86800
testb $0x1, %al
jne 0x863fa
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
callq 0x86840
jmp 0x863fc
leaq -0x48(%rbp), %rdi
callq 0x12ad0
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
callq 0x6a320
testb $0x1, %al
jne 0x8644f
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
callq 0x86860
jmp 0x86451
movq -0x60(%rbp), %rax
movq %rax, %rdi
addq $0x98, %rdi
movq 0xb0(%rax), %rsi
movq %rsi, %rcx
addq $0x1, %rcx
movq %rcx, 0xb0(%rax)
callq 0x86790
movq %rax, %rdi
callq 0x867b0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq (%rax), %rdx
movq -0x50(%rbp), %rcx
movq %rdx, 0x18(%rcx)
movq 0x8(%rax), %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xa650
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rcx
movq 0x60(%rcx), %rdx
movq %rdx, 0x60(%rax)
movq 0x68(%rcx), %rcx
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x87d60
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x87d90
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x87dc0
testb $0x1, %al
jne 0x86544
jmp 0x86569
leaq -0x20(%rbp), %rdi
callq 0x87e00
movq -0x78(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0xf0c0
leaq -0x20(%rbp), %rdi
callq 0x87e20
jmp 0x86531
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x87e40
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x87e70
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x87ea0
testb $0x1, %al
jne 0x865a2
jmp 0x865cb
leaq -0x40(%rbp), %rdi
callq 0x87ee0
movq -0x78(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x28, %rdi
movq -0x50(%rbp), %rsi
callq 0xf140
leaq -0x40(%rbp), %rdi
callq 0x87f00
jmp 0x8658f
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x87f20
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x87f50
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x87f80
testb $0x1, %al
jne 0x86604
jmp 0x8662d
leaq -0x60(%rbp), %rdi
callq 0x87fc0
movq -0x78(%rbp), %rdi
movq %rax, -0x70(%rbp)
addq $0x40, %rdi
movq -0x70(%rbp), %rsi
callq 0xe9c0
leaq -0x60(%rbp), %rdi
callq 0x87fe0
jmp 0x865f1
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x2, 0x130(%rax)
jb 0x88240
jmp 0x8825f
leaq 0x1a376(%rip), %rdi     # 0xa25bd
leaq 0x19a43(%rip), %rsi     # 0xa1c91
movl $0x3a6, %edx            # imm = 0x3A6
leaq 0x1a381(%rip), %rcx     # 0xa25db
callq 0xa290
movq -0x50(%rbp), %rax
movq %rax, %rdi
addq $0x118, %rdi            # imm = 0x118
movq 0x130(%rax), %rsi
subq $0x1, %rsi
callq 0xfe70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $-0x30, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x89aa0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5f5f0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x89ad0
testb $0x1, %al
jne 0x882c2
jmp 0x88315
leaq -0x28(%rbp), %rdi
callq 0x5f640
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x89b00
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x89b20
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x5f4b0
movq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0xa040
leaq -0x28(%rbp), %rdi
callq 0x60380
jmp 0x882af
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x31(%rax)
je 0x89eb8
movl -0x1c(%rbp), %edi
callq 0xa560
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0xa560
movl %eax, %ecx
xorl %eax, %eax
cmpl -0x20(%rbp), %ecx
movb %al, -0x21(%rbp)
jg 0x89eae
movl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
callq 0xa560
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
setle %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x89ee0
movq -0x18(%rbp), %rax
movl (%rax), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x29(%rbp)
ja 0x89ed8
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
setbe %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x58(%rax), %rax
testb $0x1, 0xe9(%rax)
je 0x8ac53
movq -0x18(%rbp), %rdi
callq 0xf770
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x104b0
movq %rax, %rdi
leaq 0x67fab(%rip), %rsi     # 0xf2b58
leaq 0x67fc4(%rip), %rdx     # 0xf2b78
xorl %eax, %eax
movl %eax, %ecx
callq 0xa480
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
jne 0x8abcc
callq 0xa6c0
movq -0x58(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xfbd0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0xf930
leaq -0x38(%rbp), %rdi
callq 0x104b0
movq %rax, %rdi
leaq 0x67f54(%rip), %rsi     # 0xf2b58
leaq 0x67f6d(%rip), %rdx     # 0xf2b78
xorl %eax, %eax
movl %eax, %ecx
callq 0xa480
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
jne 0x8ac25
callq 0xa6c0
jmp 0x8ac25
movq -0x60(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xda50
jmp 0x8ac95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xda50
jmp 0x8ac9f
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x104b0
movq %rax, %rdi
leaq 0x67eee(%rip), %rsi     # 0xf2b58
leaq 0x67f07(%rip), %rdx     # 0xf2b78
xorl %eax, %eax
movl %eax, %ecx
callq 0xa480
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
jne 0x8ac89
callq 0xa6c0
movq -0x68(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xa650
nopl (%rax,%rax)
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Holder::reduce(peg::SemanticValues&, std::any&) const
inline std::any Holder::reduce(SemanticValues &vs, std::any &dt) const {
  if (outer_->action && !outer_->disable_action) {
    return outer_->action(vs, dt);
  } else if (vs.empty()) {
    return std::any();
  } else {
    return std::move(vs.front());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x18(%rax), %rdi
addq $0x60, %rdi
callq 0x8b360
testb $0x1, %al
jne 0x93cbe
jmp 0x93cee
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
testb $0x1, 0x108(%rax)
jne 0x93cee
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rsi
addq $0x60, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x8b380
jmp 0x93d1d
movq -0x18(%rbp), %rdi
callq 0x57130
testb $0x1, %al
jne 0x93cfd
jmp 0x93d08
movq -0x38(%rbp), %rdi
callq 0xda70
jmp 0x93d1d
movq -0x18(%rbp), %rdi
callq 0x93d70
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x53410
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Definition::Result peg::Definition::parse_and_get_value<std::shared_ptr<peg::AstBase<peg::EmptyType>>>(char const*, unsigned long, std::shared_ptr<peg::AstBase<peg::EmptyType>>&, char const*, std::function<void (unsigned long, unsigned long, 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
Result parse_and_get_value(const char *s, size_t n, T &val,
                             const char *path = nullptr,
                             Log log = nullptr) const {
    SemanticValues vs;
    std::any dt;
    auto r = parse_core(s, n, vs, dt, path, log);
    if (r.ret && !vs.empty() && vs.front().has_value()) {
      val = std::any_cast<T>(vs[0]);
    }
    return r;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x160(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x148(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0xd2c0
leaq -0xe0(%rbp), %rdi
callq 0xda70
movq -0x148(%rbp), %rsi
movb $0x0, -0xe1(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x140(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x10520
jmp 0x9d3bf
movq -0x138(%rbp), %rcx
movq -0x140(%rbp), %rdx
movq -0x150(%rbp), %rsi
movq -0x160(%rbp), %rdi
movq -0x130(%rbp), %r8
movq %rsp, %rax
leaq -0x108(%rbp), %r9
movq %r9, 0x8(%rax)
movq %r8, (%rax)
leaq -0xd0(%rbp), %r8
leaq -0xe0(%rbp), %r9
callq 0x7ada0
jmp 0x9d408
leaq -0x108(%rbp), %rdi
callq 0xd9d0
movq -0x160(%rbp), %rax
testb $0x1, (%rax)
je 0x9d4eb
leaq -0xd0(%rbp), %rdi
callq 0x57130
testb $0x1, %al
jne 0x9d4eb
leaq -0xd0(%rbp), %rdi
callq 0x93d70
movq %rax, %rdi
callq 0x1c580
testb $0x1, %al
jne 0x9d455
jmp 0x9d4eb
xorl %eax, %eax
movl %eax, %esi
leaq -0xd0(%rbp), %rdi
callq 0x8b010
movq %rax, %rsi
leaq -0x128(%rbp), %rdi
callq 0x9d5e0
jmp 0x9d476
movq -0x28(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x9d630
leaq -0x128(%rbp), %rdi
callq 0x13040
jmp 0x9d4eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
jmp 0x9d52f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
leaq -0x108(%rbp), %rdi
callq 0xd9d0
jmp 0x9d52f
movq -0x160(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
callq 0x77af0
jmp 0x9d52f
movb $0x1, -0xe1(%rbp)
testb $0x1, -0xe1(%rbp)
jne 0x9d507
movq -0x160(%rbp), %rdi
callq 0x77af0
leaq -0xe0(%rbp), %rdi
callq 0xd9f0
leaq -0xd0(%rbp), %rdi
callq 0xde10
movq -0x158(%rbp), %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
leaq -0xe0(%rbp), %rdi
callq 0xd9f0
leaq -0xd0(%rbp), %rdi
callq 0xde10
movq -0x110(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3c590
movq -0x60(%rbp), %rdi
callq 0x4f200
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3b3c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3b3f0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3b420
testb $0x1, %al
jne 0x9d866
jmp 0x9d8cf
leaq -0x28(%rbp), %rdi
callq 0x3b450
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x77e30
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x77e50
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
testb $0x1, 0x1b8(%rax)
je 0x9d8c2
movq -0x70(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x9df10
jmp 0x9d8a9
jmp 0x9d8c2
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x3c720
jmp 0x9d8ec
jmp 0x9d8c4
leaq -0x28(%rbp), %rdi
callq 0x3b480
jmp 0x9d853
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x9d8e2
movq -0x70(%rbp), %rdi
callq 0x3c720
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
nop