LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Trie::match(char const*, unsigned long, unsigned long&) const
size_t match(const char *text, size_t text_len, size_t &id) const {
    std::string lower_text;
    if (ignore_case_) {
      lower_text = to_lower(text);
      text = lower_text.data();
    }

    size_t match_len = 0;
    auto done = false;
    size_t len = 1;
    while (!done && len <= text_len) {
      std::string_view sv(text, len);
      auto it = dic_.find(sv);
      if (it == dic_.end()) {
        done = true;
      } else {
        if (it->second.match) {
          match_len = len;
          id = it->second.id;
        }
        if (it->second.done) { done = true; }
      }
      len += 1;
    }
    return match_len;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, -0x40(%rbp)
movq %rdx, %r14
movq %rsi, %r12
leaq -0x70(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r15
movb $0x0, (%rax)
cmpb $0x1, 0x30(%rdi)
jne 0xa713
leaq -0xa0(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %r12, %rsi
callq 0xff44
leaq -0x60(%rbp), %rbx
leaq -0xa0(%rbp), %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xfef0
leaq -0x80(%rbp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x9310
movq %rbx, %rdi
callq 0x9140
movq %r12, %rdi
callq 0x9140
movq (%r13), %r12
leaq 0x8(%r15), %r13
pushq $0x1
popq %rbx
movq $0x0, -0x38(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0xa767
cmpq %r14, %rbx
ja 0xa767
movq %rbx, -0x60(%rbp)
movq %r12, -0x58(%rbp)
movq %r15, %rdi
leaq -0x60(%rbp), %rsi
callq 0x1001e
cmpq %r13, %rax
je 0xa760
cmpb $0x1, 0x41(%rax)
jne 0xa75b
movq 0x48(%rax), %rcx
movq -0x40(%rbp), %rdx
movq %rcx, (%rdx)
movq %rbx, -0x38(%rbp)
movb 0x40(%rax), %al
jmp 0xa762
movb $0x1, %al
incq %rbx
jmp 0xa724
leaq -0x80(%rbp), %rdi
callq 0x9140
movq -0x38(%rbp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa785
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x9140
movq %rbx, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Context::set_error_pos(char const*, char const*)
inline void Context::set_error_pos(const char *a_s, const char *literal) {
  if (log) {
    if (error_info.error_pos <= a_s) {
      if (error_info.error_pos < a_s || !error_info.keep_previous_token) {
        error_info.error_pos = a_s;
        error_info.expected_tokens.clear();
      }

      const char *error_literal = nullptr;
      const Definition *error_rule = nullptr;

      if (literal) {
        error_literal = literal;
      } else if (!rule_stack.empty()) {
        auto rule = rule_stack.back();
        auto ope = rule->get_core_operator();
        if (auto token = FindLiteralToken::token(*ope);
            token && token[0] != '\0') {
          error_literal = token;
        }
      }

      for (auto r : rule_stack) {
        error_rule = r;
        if (r->is_token()) { break; }
      }

      if (error_literal || error_rule) {
        error_info.add(error_literal, error_rule);
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, 0x258(%rdi)
je 0xa875
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
cmpq %rsi, 0x18(%rdi)
ja 0xa875
movq %rdx, %r14
jb 0xa7d9
cmpb $0x0, 0x88(%r15)
jne 0xa7eb
movq %rsi, 0x18(%r15)
movq 0x20(%r15), %rax
cmpq %rax, 0x28(%r15)
je 0xa7eb
movq %rax, 0x28(%r15)
testq %r14, %r14
jne 0xa835
movq 0xc0(%r15), %rax
cmpq %rax, 0xb8(%r15)
je 0xa832
movq -0x8(%rax), %rsi
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x101ac
movq (%r14), %rdi
callq 0x101d0
xorl %r14d, %r14d
testq %rax, %rax
je 0xa827
cmpb $0x0, (%rax)
cmovneq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x1106c
jmp 0xa835
xorl %r14d, %r14d
movq 0xb8(%r15), %r12
movq 0xc0(%r15), %r13
xorl %r15d, %r15d
cmpq %r13, %r12
je 0xa85f
movq (%r12), %r15
movq %r15, %rdi
callq 0x10200
addq $0x8, %r12
testb %al, %al
je 0xa846
movq %r14, %rax
orq %r15, %rax
je 0xa875
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1022a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x1106c
movq %rbx, %rdi
callq 0x9430
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Ope::parse(char const*, unsigned long, peg::SemanticValues&, peg::Context&, std::any&) const
inline size_t Ope::parse(const char *s, size_t n, SemanticValues &vs,
                         Context &c, std::any &dt) const {
  if (c.is_traceable(*this)) {
    c.trace_enter(*this, s, n, vs, dt);
    auto len = parse_core(s, n, vs, c, dt);
    c.trace_leave(*this, s, n, vs, dt, len);
    return len;
  }
  return parse_core(s, n, vs, c, dt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, -0x38(%rbp)
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rbx, %rsi
callq 0x11168
testb %al, %al
je 0xac66
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r14, %r8
movq %r14, -0x30(%rbp)
movq -0x38(%rbp), %r14
movq %r14, %r9
callq 0x111b2
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq -0x30(%rbp), %rcx
movq %r15, %r8
movq %r14, %r9
callq *0x10(%rax)
movq %rax, -0x40(%rbp)
movq %rax, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq -0x30(%rbp), %r8
movq %r14, %r9
callq 0x11232
movq -0x40(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %r15, %r8
movq -0x38(%rbp), %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Context::~Context()
~Context() {
    pop_capture_scope();

    assert(!value_stack_size);
    assert(!capture_scope_stack_size);
    assert(cut_stack.empty());
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x130(%rdi), %rax
decq %rax
movq %rax, 0x130(%rdi)
cmpq $0x0, 0xb0(%rdi)
jne 0xadce
testq %rax, %rax
jne 0xaded
movq %rdi, %rbx
movq 0x138(%rdi), %rax
cmpq 0x148(%rdi), %rax
jne 0xae0c
cmpl $0x0, 0x150(%rbx)
jne 0xae0c
leaq 0x138(%rbx), %r14
leaq 0x290(%rbx), %rdi
callq 0x10e74
leaq 0x270(%rbx), %rdi
callq 0x10e74
leaq 0x248(%rbx), %rdi
callq 0x3209c
leaq 0x230(%rbx), %rdi
callq 0x1113a
leaq 0x210(%rbx), %rdi
callq 0x3209c
leaq 0x1f0(%rbx), %rdi
callq 0x3209c
leaq 0x1c0(%rbx), %rdi
callq 0x10eb2
leaq 0x198(%rbx), %rdi
callq 0x1085e
leaq 0x170(%rbx), %rdi
callq 0x1085e
movq %r14, %rdi
callq 0x1085e
leaq 0x118(%rbx), %rdi
callq 0x10872
leaq 0x110(%rbx), %rdi
callq 0x1106c
leaq 0xf8(%rbx), %rdi
callq 0x1106c
leaq 0xd0(%rbx), %rdi
callq 0x1089e
leaq 0xb8(%rbx), %rdi
callq 0x10fe6
leaq 0x98(%rbx), %rdi
callq 0x108ca
addq $0x18, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x108f6
leaq 0x2e913(%rip), %rdi     # 0x396e8
leaq 0x2e8d9(%rip), %rsi     # 0x396b5
leaq 0x2e917(%rip), %rcx     # 0x396fa
movl $0x33f, %edx            # imm = 0x33F
callq 0x91d0
leaq 0x2e91f(%rip), %rdi     # 0x39713
leaq 0x2e8ba(%rip), %rsi     # 0x396b5
leaq 0x2e8f8(%rip), %rcx     # 0x396fa
movl $0x340, %edx            # imm = 0x340
callq 0x91d0
leaq 0x2e91a(%rip), %rdi     # 0x3972d
leaq 0x2e89b(%rip), %rsi     # 0x396b5
leaq 0x2e8d9(%rip), %rcx     # 0x396fa
movl $0x341, %edx            # imm = 0x341
callq 0x91d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::TokenBoundary::parse_core(char const*, unsigned long, peg::SemanticValues&, peg::Context&, std::any&) const
inline size_t TokenBoundary::parse_core(const char *s, size_t n,
                                        SemanticValues &vs, Context &c,
                                        std::any &dt) const {
  auto save_ignore_trace_state = c.ignore_trace_state;
  c.ignore_trace_state = !c.verbose_trace;
  auto se =
      scope_exit([&]() { c.ignore_trace_state = save_ignore_trace_state; });

  size_t len;
  {
    c.in_token_boundary_count++;
    auto se = scope_exit([&]() { c.in_token_boundary_count--; });
    len = ope_->parse(s, n, vs, c, dt);
  }

  if (success(len)) {
    vs.tokens.emplace_back(std::string_view(s, len));

    if (!c.in_token_boundary_count) {
      if (c.whitespaceOpe) {
        auto l = c.whitespaceOpe->parse(s + len, n - len, vs, c, dt);
        if (fail(l)) { return l; }
        len += l;
      }
    }
  }
  return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movb 0x240(%r8), %al
movb 0x288(%r8), %cl
movb %cl, -0x29(%rbp)
xorb $0x1, %al
movb %al, 0x288(%r8)
incq 0xe8(%r8)
movq 0x8(%rdi), %rdi
movq %r12, %rcx
movq %r9, -0x38(%rbp)
callq 0xabc8
movq %rax, %r15
decq 0xe8(%rbx)
cmpq $-0x1, %rax
je 0xb333
leaq 0x40(%r12), %rdi
leaq -0x48(%rbp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
callq 0xb372
cmpq $0x0, 0xe8(%rbx)
jne 0xb337
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0xb337
addq %r15, %r14
subq %r15, %r13
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %rbx, %r8
movq -0x38(%rbp), %r9
callq 0xabc8
addq %rax, %r15
cmpq $-0x1, %rax
cmoveq %rax, %r15
jmp 0xb337
pushq $-0x1
popq %r15
movb -0x29(%rbp), %al
movb %al, 0x288(%rbx)
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb354
movq %rax, %rdi
jmp 0xb363
movq %rax, %rdi
decq 0xe8(%rbx)
movb -0x29(%rbp), %al
movb %al, 0x288(%rbx)
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: void peg::Context::packrat<peg::Holder::parse_core(char const*, unsigned long, peg::SemanticValues&, peg::Context&, std::any&) const::'lambda'(std::any&)>(char const*, unsigned long, unsigned long&, std::any&, peg::Holder::parse_core(char const*, unsigned long, peg::SemanticValues&, peg::Context&, std::any&) const::'lambda'(std::any&))
void packrat(const char *a_s, size_t def_id, size_t &len, std::any &val,
               T fn) {
    if (!enablePackratParsing) {
      fn(val);
      return;
    }

    auto col = a_s - s;
    auto idx = def_count * static_cast<size_t>(col) + def_id;

    if (cache_registered[idx]) {
      if (cache_success[idx]) {
        auto key = std::pair(col, def_id);
        std::tie(len, val) = cache_values[key];
        return;
      } else {
        len = static_cast<size_t>(-1);
        return;
      }
    } else {
      fn(val);
      cache_registered[idx] = true;
      cache_success[idx] = success(len);
      if (success(len)) {
        auto key = std::pair(col, def_id);
        cache_values[key] = std::pair(len, val);
      }
      return;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x10(%rbp), %r12
cmpb $0x0, 0x168(%rdi)
je 0xb630
movq %rsi, %r13
movq %rdi, %r15
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
subq 0x8(%rdi), %r13
movq 0x160(%rdi), %r14
imulq %r13, %r14
movq %rdx, -0x40(%rbp)
addq %rdx, %r14
leaq 0x170(%rdi), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x346a4
testq %rdx, (%rax)
je 0xb64a
leaq 0x198(%r15), %rdi
movq %r14, %rsi
callq 0x346a4
testq %rdx, (%rax)
je 0xb685
addq $0x1c0, %r15            # imm = 0x1C0
leaq -0x58(%rbp), %rsi
movq %r13, (%rsi)
movq -0x40(%rbp), %rax
movq %rax, 0x8(%rsi)
movq %r15, %rdi
callq 0x346c6
leaq -0x68(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq %rcx, (%rdi)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rsi
callq 0x34c1a
jmp 0xb63b
movq %r12, %rdi
movq %r8, %rsi
callq 0x3437e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq -0x38(%rbp), %rsi
callq 0x3437e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x346a4
orq %rdx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rbx
leaq 0x198(%r15), %rdi
movq %r14, %rsi
callq 0x346a4
cmpq $-0x1, %rbx
je 0xb68f
orq (%rax), %rdx
jmp 0xb695
movq -0x30(%rbp), %rax
orq $-0x1, (%rax)
jmp 0xb63b
notq %rdx
andq (%rax), %rdx
movq %rdx, (%rax)
movq -0x30(%rbp), %rsi
cmpq $-0x1, (%rsi)
je 0xb63b
leaq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rdx
callq 0x34730
addq $0x1c0, %r15            # imm = 0x1C0
leaq -0x68(%rbp), %rsi
movq %r13, (%rsi)
movq -0x40(%rbp), %rax
movq %rax, 0x8(%rsi)
movq %r15, %rdi
callq 0x346c6
leaq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x34748
leaq -0x50(%rbp), %rdi
callq 0x1113a
jmp 0xb63b
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x1113a
movq %rbx, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::BackReference::parse_core(char const*, unsigned long, peg::SemanticValues&, peg::Context&, std::any&) const
inline size_t BackReference::parse_core(const char *s, size_t n,
                                        SemanticValues &vs, Context &c,
                                        std::any &dt) const {
  auto size = static_cast<int>(c.capture_scope_stack_size);
  for (auto i = size - 1; i >= 0; i--) {
    auto index = static_cast<size_t>(i);
    const auto &cs = c.capture_scope_stack[index];
    if (cs.find(name_) != cs.end()) {
      const auto &lit = cs.at(name_);
      std::once_flag init_is_word;
      auto is_word = false;
      return parse_literal(s, n, vs, c, dt, lit, init_is_word, is_word, false);
    }
  }

  c.error_info.message_pos = s;
  c.error_info.message = "undefined back reference '$" + name_ + "'...";
  return static_cast<size_t>(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, -0x50(%rbp)
movq %rcx, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
movq %r8, -0x30(%rbp)
movq 0x130(%r8), %r12
movl %r12d, %eax
leaq 0x8(%rdi), %rcx
movq %rcx, -0x58(%rbp)
incl %r12d
imulq $-0x30, %rax, %r13
imulq $0x30, %rax, %rbx
orq $0x8, %rbx
decl %r12d
testl %r12d, %r12d
jle 0xbc6e
addq $0x30, %r13
movq -0x30(%rbp), %rax
movq 0x118(%rax), %r14
leaq (%r14,%rbx), %rdi
addq $-0x38, %rdi
addq $-0x30, %rbx
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
movq %rcx, -0x78(%rbp)
movq %rax, -0x70(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x34d5c
leaq (%r14,%rbx), %rcx
cmpq %rax, %rcx
je 0xbbc9
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
leaq -0x78(%rbp), %r15
movq %rcx, (%r15)
movq %rax, 0x8(%r15)
subq %r13, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xbcf8
andl $0x0, (%r15)
leaq -0x98(%rbp), %r10
movb $0x0, (%r10)
subq $0x8, %rsp
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x50(%rbp), %r8
movq %rax, %r9
pushq $0x0
pushq %r10
pushq %r15
callq 0xaea1
addq $0x20, %rsp
jmp 0xbcd1
movq -0x30(%rbp), %rbx
movq -0x38(%rbp), %rax
movq %rax, 0x38(%rbx)
leaq 0x2d5a4(%rip), %rsi     # 0x39225
leaq -0x98(%rbp), %r14
movq %r14, %rdi
movq -0x58(%rbp), %rdx
callq 0xbd74
leaq 0x2d5a6(%rip), %rdx     # 0x39241
leaq -0x78(%rbp), %rdi
movq %r14, %rsi
callq 0xbd4b
addq $0x40, %rbx
leaq -0x78(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9310
movq %r14, %rdi
callq 0x9140
leaq -0x98(%rbp), %rdi
callq 0x9140
pushq $-0x1
popq %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x9140
movq %rbx, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::ErrorInfo::clear()
void clear() {
    error_pos = nullptr;
    expected_tokens.clear();
    message_pos = nullptr;
    message.clear();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $0x0, (%rdi)
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
je 0xc57c
movq %rax, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
andq $0x0, 0x30(%rdi)
movq 0x28(%rdi), %rax
movb $0x0, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::AssignIDToDefinition::visit(peg::Holder&)
inline void AssignIDToDefinition::visit(Holder &ope) {
  auto p = static_cast<void *>(ope.outer_);
  if (ids.count(p)) { return; }
  auto id = ids.size();
  ids[p] = id;
  ope.outer_->id = id;
  ope.ope_->accept(*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rax
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0x34e82
testq %rax, %rax
jne 0xc7af
movq 0x20(%rbx), %r12
leaq -0x28(%rbp), %rsi
movq %r15, %rdi
callq 0x34f22
movq %r12, (%rax)
movq 0x18(%r14), %rax
movq %r12, 0x58(%rax)
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::TokenChecker::visit(peg::Reference&)
inline void TokenChecker::visit(Reference &ope) {
  if (ope.is_macro_) {
    for (auto arg : ope.args_) {
      arg->accept(*this);
    }
  } else {
    has_rule_ = true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x48(%rsi)
jne 0xc811
movq 0x50(%rsi), %r15
movq 0x58(%rsi), %r13
leaq -0x30(%rbp), %r14
leaq -0x38(%rbp), %r12
cmpq %r13, %r15
je 0xc815
movq %r12, %rdi
movq %r15, %rsi
callq 0x117ce
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq %r14, %rdi
callq 0x1106c
addq $0x10, %r15
jmp 0xc7e6
movb $0x1, 0x9(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x1106c
movq %rbx, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::FindLiteralToken::visit(peg::Reference&)
inline void FindLiteralToken::visit(Reference &ope) {
  if (ope.is_macro_) {
    ope.rule_->accept(*this);
    for (auto arg : ope.args_) {
      arg->accept(*this);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpb $0x1, 0x48(%rsi)
jne 0xc8a4
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rsi), %rax
movq 0x1c0(%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x50(%r14), %r15
movq 0x58(%r14), %r13
leaq -0x30(%rbp), %r14
leaq -0x38(%rbp), %r12
cmpq %r13, %r15
je 0xc8a4
movq %r12, %rdi
movq %r15, %rsi
callq 0x117ce
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq %r14, %rdi
callq 0x1106c
addq $0x10, %r15
jmp 0xc879
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x1106c
movq %rbx, %rdi
callq 0x9430
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::DetectLeftRecursion::visit(peg::Reference&)
inline void DetectLeftRecursion::visit(Reference &ope) {
  if (ope.name_ == name_) {
    error_s = ope.s_;
  } else if (!refs_.count(ope.name_)) {
    refs_.insert(ope.name_);
    if (ope.rule_) {
      ope.rule_->accept(*this);
      if (done_ == false) { return; }
    }
  }
  done_ = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsi), %r15
leaq 0x10(%rdi), %rsi
movq %r15, %rdi
callq 0xc942
testb %al, %al
je 0xc8f5
movq 0x40(%r14), %rax
movq %rax, 0x8(%rbx)
jmp 0xc909
leaq 0x30(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x35250
testq %rax, %rax
je 0xc916
movb $0x1, 0x68(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %r15, %rsi
callq 0x2f826
movq 0x68(%r14), %rax
testq %rax, %rax
je 0xc909
movq 0x1c0(%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
cmpb $0x0, 0x68(%rbx)
jne 0xc909
jmp 0xc90d
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::HasEmptyElement::visit(peg::Sequence&)
inline void HasEmptyElement::visit(Sequence &ope) {
  auto save_is_empty = false;
  const char *save_error_s = nullptr;
  std::string save_error_name;

  auto it = ope.opes_.begin();
  while (it != ope.opes_.end()) {
    (*it)->accept(*this);
    if (!is_empty) {
      ++it;
      while (it != ope.opes_.end()) {
        DetectInfiniteLoop vis(refs_, has_error_cache_);
        (*it)->accept(vis);
        if (vis.has_error) {
          is_empty = true;
          error_s = vis.error_s;
          error_name = vis.error_name;
        }
        ++it;
      }
      return;
    }

    save_is_empty = is_empty;
    save_error_s = error_s;
    save_error_name = error_name;

    is_empty = false;
    error_name.clear();
    ++it;
  }

  is_empty = save_is_empty;
  error_s = save_error_s;
  error_name = save_error_name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
leaq -0x88(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r15
movb $0x0, (%rax)
movq 0x8(%rsi), %r12
leaq 0x18(%rdi), %rax
movq %rax, -0x30(%rbp)
xorl %r14d, %r14d
xorl %eax, %eax
xorl %r13d, %r13d
cmpq 0x10(%rbx), %r12
je 0xc9f2
movq (%r12), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x18(%rax)
cmpb $0x0, 0x8(%r15)
je 0xca25
movq 0x10(%r15), %r13
leaq -0x98(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9190
movb %r14b, 0x8(%r15)
andq $0x0, 0x20(%r15)
movq 0x18(%r15), %rax
movb %r14b, (%rax)
addq $0x10, %r12
movb $0x1, %al
jmp 0xc9ac
movb %al, 0x8(%r15)
movq %r13, 0x10(%r15)
leaq -0x98(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x9190
leaq -0x98(%rbp), %rdi
callq 0x9140
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x10, %r12
xorl %r14d, %r14d
leaq -0x78(%rbp), %r13
cmpq 0x10(%rbx), %r12
je 0xca0a
movups 0x38(%r15), %xmm0
leaq 0x4ed1e(%rip), %rax     # 0x5b760
movq %rax, -0x78(%rbp)
movb %r14b, -0x70(%rbp)
andq $0x0, -0x68(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
andq $0x0, -0x58(%rbp)
movb %r14b, -0x50(%rbp)
movups %xmm0, -0x40(%rbp)
movq (%r12), %rdi
movq (%rdi), %rax
movq %r13, %rsi
callq *0x18(%rax)
cmpb $0x1, -0x70(%rbp)
jne 0xca91
movb $0x1, 0x8(%r15)
movq -0x68(%rbp), %rax
movq %rax, 0x10(%r15)
movq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x9190
movq %r13, %rdi
callq 0xcac6
addq $0x10, %r12
jmp 0xca30
jmp 0xcaaf
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0xcac6
jmp 0xcab2
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x9140
movq %rbx, %rdi
callq 0x9430
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::DetectInfiniteLoop::visit(peg::Reference&)
inline void DetectInfiniteLoop::visit(Reference &ope) {
  auto it = std::find_if(refs_.begin(), refs_.end(),
                         [&](const std::pair<const char *, std::string> &ref) {
                           return ope.name_ == ref.second;
                         });
  if (it != refs_.end()) { return; }

  if (ope.rule_) {
    auto it = has_error_cache_.find(ope.name_);
    if (it != has_error_cache_.end()) {
      has_error = it->second;
    } else {
      refs_.emplace_back(ope.s_, ope.name_);
      ope.rule_->accept(*this);
      refs_.pop_back();
      has_error_cache_[ope.name_] = has_error;
    }
  }

  if (ope.is_macro_) {
    for (auto arg : ope.args_) {
      arg->accept(*this);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq %r14, %rdx
callq 0x35293
movq 0x38(%rbx), %rcx
cmpq 0x8(%rcx), %rax
jne 0xcbbc
cmpq $0x0, 0x68(%r14)
je 0xcb7a
movq 0x40(%rbx), %rdi
leaq 0x20(%r14), %r15
movq %r15, %rsi
callq 0x353cc
testq %rax, %rax
je 0xcb3a
movb 0x28(%rax), %al
movb %al, 0x8(%rbx)
jmp 0xcb7a
movq 0x38(%rbx), %rdi
leaq 0x40(%r14), %rsi
movq %r15, %rdx
callq 0xcbde
movq 0x68(%r14), %rax
movq 0x1c0(%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x38(%rbx), %rdi
callq 0xcc2a
movb 0x8(%rbx), %r12b
movq 0x40(%rbx), %rdi
movq %r15, %rsi
callq 0x354aa
movb %r12b, (%rax)
cmpb $0x1, 0x48(%r14)
jne 0xcbbc
movq 0x50(%r14), %r15
movq 0x58(%r14), %r13
leaq -0x30(%rbp), %r14
leaq -0x38(%rbp), %r12
cmpq %r13, %r15
je 0xcbbc
movq %r12, %rdi
movq %r15, %rsi
callq 0x117ce
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq %r14, %rdi
callq 0x1106c
addq $0x10, %r15
jmp 0xcb91
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x1106c
movq %rbx, %rdi
callq 0x9430
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::LinkReferences::visit(peg::Reference&)
inline void LinkReferences::visit(Reference &ope) {
  // Check if the reference is a macro parameter
  auto found_param = false;
  for (size_t i = 0; i < params_.size(); i++) {
    const auto &param = params_[i];
    if (param == ope.name_) {
      ope.iarg_ = i;
      found_param = true;
      break;
    }
  }

  // Check if the reference is a definition rule
  if (!found_param && grammar_.count(ope.name_)) {
    auto &rule = grammar_.at(ope.name_);
    ope.rule_ = &rule;
  }

  for (auto arg : ope.args_) {
    arg->accept(*this);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsi), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x10(%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %rax, %r13
jae 0xcee8
addq %r12, %rdi
movq %r15, %rsi
callq 0xc942
testb %al, %al
jne 0xcf0b
incq %r13
addq $0x20, %r12
jmp 0xceb9
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x3594a
testq %rax, %rax
je 0xcf0f
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x36276
movq %rax, 0x68(%r14)
jmp 0xcf0f
movq %r13, 0x70(%r14)
movq 0x50(%r14), %r15
movq 0x58(%r14), %r13
leaq -0x30(%rbp), %r14
leaq -0x38(%rbp), %r12
cmpq %r13, %r15
je 0xcf4a
movq %r12, %rdi
movq %r15, %rsi
callq 0x117ce
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq %r14, %rdi
callq 0x1106c
addq $0x10, %r15
jmp 0xcf1f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x1106c
movq %rbx, %rdi
callq 0x9430
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::FindReference::visit(peg::Reference&)
inline void FindReference::visit(Reference &ope) {
  for (size_t i = 0; i < args_.size(); i++) {
    const auto &name = params_[i];
    if (name == ope.name_) {
      found_ope = args_[i];
      return;
    }
  }
  found_ope = ope.shared_from_this();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, -0x30(%rbp)
leaq 0x20(%rsi), %r12
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x4, %rcx
cmpq %rcx, %r14
jae 0xcfc8
movq 0x20(%rbx), %rax
movq (%rax), %rdi
addq %r13, %rdi
movq %r12, %rsi
callq 0xc942
testb %al, %al
jne 0xd003
incq %r14
addq $0x10, %r15
addq $0x20, %r13
jmp 0xcf91
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x362c4
addq $0x8, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x362ea
leaq -0x38(%rbp), %rdi
callq 0x1106c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rbx), %rax
addq (%rax), %r15
addq $0x8, %rbx
movq %rbx, %rdi
movq %r15, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11f0a
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: bool peg::parser::parse_n<std::shared_ptr<peg::AstBase<peg::EmptyType>>>(char const*, unsigned long, std::shared_ptr<peg::AstBase<peg::EmptyType>>&, char const*) const
bool parse_n(const char *s, size_t n, T &val,
               const char *path = nullptr) const {
    if (grammar_ != nullptr) {
      const auto &rule = (*grammar_)[start_];
      auto result = rule.parse_and_get_value(s, n, val, path, log_);
      return post_process(s, n, result);
    }
    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %r15
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xd1b1
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x10(%r15), %rsi
movq %r8, -0x30(%rbp)
callq 0x25a7a
movq %rax, %r12
leaq 0x38(%r15), %rsi
leaq -0x50(%rbp), %rdi
callq 0xbff0
leaq -0x50(%rbp), %rax
movq %rax, (%rsp)
leaq -0xd8(%rbp), %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
movq -0x30(%rbp), %r9
callq 0x372b6
leaq -0x50(%rbp), %rdi
callq 0x3209c
leaq -0xd8(%rbp), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x373fa
movl %eax, %ebx
leaq -0xc8(%rbp), %rdi
callq 0x108f6
jmp 0xd1b3
xorl %ebx, %ebx
movl %ebx, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x108f6
jmp 0xd1e4
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3209c
movq %rbx, %rdi
callq 0x9430
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/fzbz.cc
// Function: bool Value::get<bool>() const
T get() const {
    try {
      return std::get<T>(v);
    } catch (bad_variant_access&) {
      throw runtime_error("type error.");
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x37ee8
movb (%rax), %al
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0xd346
movq %rbx, %rdi
callq 0x9110
pushq $0x10
popq %rdi
callq 0x9160
movq %rax, %r14
leaq 0x2cbee(%rip), %rsi     # 0x39f01
movq %rax, %rdi
callq 0x9100
movq 0x4fcce(%rip), %rsi     # 0x5cff0
movq 0x4fc17(%rip), %rdx     # 0x5cf40
movq %r14, %rdi
callq 0x9420
movq %rax, %rbx
jmp 0xd341
movq %rax, %rbx
movq %r14, %rdi
callq 0x9230
callq 0x9410
movq %rbx, %rdi
callq 0x9430
movq %rax, %rdi
callq 0xd6c3
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/fzbz.cc
// Function: Value::operator==(Value const&) const
bool operator==(const Value& rhs) const {
    switch (v.index()) {
      case 0:
        return get<nullptr_t>() == rhs.get<nullptr_t>();
      case 1:
        return get<bool>() == rhs.get<bool>();
      case 2:
        return get<long>() == rhs.get<long>();
      case 3:
        return get<string_view>() == rhs.get<string_view>();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movzbl 0x20(%rdi), %eax
leaq 0x2bcb2(%rip), %rcx     # 0x39020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x3089a
movq %rax, %r14
movq %rbx, %rdi
callq 0x3089a
jmp 0xd399
callq 0xd3f0
movq %rax, %r14
movq %rbx, %rdi
callq 0xd3f0
cmpq %rax, %r14
sete %al
jmp 0xd3e4
callq 0x30948
movq %rax, %r14
movq %rdx, %r15
movq %rbx, %rdi
callq 0x30948
movq %rdx, %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30912
callq 0xd2de
movl %eax, %r14d
movq %rbx, %rdi
callq 0xd2de
xorb %r14b, %al
xorb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/fzbz.cc
// Function: Environment::get_value(std::basic_string_view<char, std::char_traits<char>>) const
const Value& get_value(string_view s) const {
    if (auto it = values.find(s); it != values.end()) {
      return it->second;
    } else if (outer) {
      return outer->get_value(s);
    }
    throw runtime_error("undefined variable '" + string(s) + "'...");
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
addq $0x10, %rdi
movq %rax, %rsi
callq 0x30aa0
leaq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0xd4a0
addq $0x30, %rax
jmp 0xd4b5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xd4c0
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xd46a
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x9160
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x19(%rbp), %rdx
callq 0x1371e
leaq 0x2ca4c(%rip), %rsi     # 0x39f2f
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x30a71
leaq 0x2bd4a(%rip), %rdx     # 0x39241
leaq -0x90(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xbd4b
movb $0x1, %r15b
leaq -0x90(%rbp), %rsi
movq %rbx, %rdi
callq 0x93f0
xorl %r15d, %r15d
movq 0x4facd(%rip), %rsi     # 0x5cff0
movq 0x4fa16(%rip), %rdx     # 0x5cf40
movq %rbx, %rdi
callq 0x9420
movq %rax, %r14
leaq -0x90(%rbp), %rdi
callq 0x9140
jmp 0xd549
movq %rax, %r14
movb $0x1, %r15b
leaq -0x70(%rbp), %rdi
callq 0x9140
jmp 0xd55a
movq %rax, %r14
movb $0x1, %r15b
leaq -0x50(%rbp), %rdi
callq 0x9140
testb %r15b, %r15b
jne 0xd56d
jmp 0xd575
movq %rax, %r14
movq %rbx, %rdi
callq 0x9230
movq %r14, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Sequence::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 &chvs = c.push_semantic_values_scope();
    auto se = scope_exit([&]() { c.pop_semantic_values_scope(); });
    size_t i = 0;
    for (const auto &ope : opes_) {
      auto len = ope->parse(s + i, n - i, chvs, c, dt);
      if (fail(len)) { return len; }
      i += len;
    }
    vs.append(chvs);
    return i;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, -0x48(%rbp)
movq %rcx, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %rsi, %r14
movq %rdi, %r15
movq %r8, -0x30(%rbp)
movq %r8, %rdi
callq 0x31480
movq %rax, %rbx
movq 0x8(%r15), %r12
movq 0x10(%r15), %r13
xorl %r15d, %r15d
cmpq %r13, %r12
je 0xd77a
movq (%r12), %rdi
leaq (%r14,%r15), %rsi
movq -0x40(%rbp), %rdx
subq %r15, %rdx
movq %rbx, %rcx
movq -0x30(%rbp), %r8
movq -0x48(%rbp), %r9
callq 0xabc8
cmpq $-0x1, %rax
je 0xd788
addq %rax, %r15
addq $0x10, %r12
jmp 0xd747
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x31598
jmp 0xd78c
pushq $-0x1
popq %r15
movq -0x30(%rbp), %rax
decq 0xb0(%rax)
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd7ab
movq -0x30(%rbp), %rcx
decq 0xb0(%rcx)
movq %rax, %rdi
callq 0x9430
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::PrioritizedChoice::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 {
    size_t len = static_cast<size_t>(-1);

    if (!for_label_) { c.cut_stack.push_back(false); }
    auto se = scope_exit([&]() {
      if (!for_label_) { c.cut_stack.pop_back(); }
    });

    size_t id = 0;
    for (const auto &ope : opes_) {
      if (!c.cut_stack.empty()) { c.cut_stack.back() = false; }

      auto &chvs = c.push();
      c.error_info.keep_previous_token = id > 0;
      auto se = scope_exit([&]() {
        c.pop();
        c.error_info.keep_previous_token = false;
      });

      len = ope->parse(s, n, chvs, c, dt);

      if (success(len)) {
        vs.append(chvs);
        vs.choice_count_ = opes_.size();
        vs.choice_ = id;
        c.shift_capture_values();
        break;
      } else if (!c.cut_stack.empty() && c.cut_stack.back()) {
        break;
      }

      id++;
    }

    return len;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, -0x58(%rbp)
movq %r8, %r14
movq %rcx, -0x40(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdi, -0x38(%rbp)
cmpb $0x0, 0x20(%rdi)
jne 0xd832
leaq 0x138(%r14), %rdi
xorl %esi, %esi
callq 0x31a94
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
movq %r14, -0x80(%rbp)
movb $0x1, -0x78(%rbp)
movq 0x8(%rax), %rbx
movq 0x10(%rax), %rax
movq %rax, -0x60(%rbp)
leaq 0x138(%r14), %rax
movq %rax, -0x30(%rbp)
pushq $-0x1
popq %r12
xorl %r15d, %r15d
cmpq -0x60(%rbp), %rbx
je 0xd950
movq 0x138(%r14), %rax
cmpq 0x148(%r14), %rax
jne 0xd887
cmpl $0x0, 0x150(%r14)
je 0xd896
movq -0x30(%rbp), %rdi
callq 0xc590
notq %rdx
andq %rdx, (%rax)
movq %r14, %rdi
callq 0x31ae0
movq %rax, %r13
testq %r15, %r15
setne 0x88(%r14)
movq %r14, -0x70(%rbp)
movb $0x1, -0x68(%rbp)
movq (%rbx), %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
movq %r14, %r8
movq -0x58(%rbp), %r9
callq 0xabc8
movq %rax, %r12
cmpq $-0x1, %rax
je 0xd90c
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq 0x31598
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rax
subq 0x8(%rcx), %rax
sarq $0x4, %rax
movq -0x40(%rbp), %rcx
movq %rax, 0x70(%rcx)
movq %r15, 0x78(%rcx)
movq %r14, %rdi
callq 0x31afc
xorl %r13d, %r13d
jmp 0xd93a
movq 0x138(%r14), %rax
cmpq 0x148(%r14), %rax
jne 0xd926
cmpl $0x0, 0x150(%r14)
je 0xd934
movq -0x30(%rbp), %rdi
callq 0xc590
testq %rdx, (%rax)
jne 0xd907
incq %r15
movb $0x1, %r13b
leaq -0x70(%rbp), %rdi
callq 0x31b88
addq $0x10, %rbx
testb %r13b, %r13b
jne 0xd863
leaq -0x88(%rbp), %rdi
callq 0x31ba2
movq %r12, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd977
jmp 0xd972
movq %rax, %rbx
jmp 0xd983
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x31b88
leaq -0x88(%rbp), %rdi
callq 0x31ba2
movq %rbx, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Repetition::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 {
    size_t count = 0;
    size_t i = 0;
    while (count < min_) {
      auto &chvs = c.push();
      auto se = scope_exit([&]() { c.pop(); });

      auto len = ope_->parse(s + i, n - i, chvs, c, dt);

      if (success(len)) {
        vs.append(chvs);
        c.shift_capture_values();
      } else {
        return len;
      }
      i += len;
      count++;
    }

    while (count < max_) {
      auto &chvs = c.push();
      auto se = scope_exit([&]() { c.pop(); });

      auto len = ope_->parse(s + i, n - i, chvs, c, dt);

      if (success(len)) {
        vs.append(chvs);
        c.shift_capture_values();
      } else {
        break;
      }
      i += len;
      count++;
    }
    return i;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, -0x50(%rbp)
movq %r8, %rbx
movq %rcx, -0x30(%rbp)
movq %rdx, -0x48(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdi, %r13
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %rdi, -0x38(%rbp)
cmpq 0x18(%r13), %r15
jae 0xdae1
movq %rbx, %rdi
callq 0x31ae0
movq %rax, %r12
movq 0x8(%r13), %rdi
movq -0x40(%rbp), %rax
leaq (%rax,%r14), %rsi
movq -0x48(%rbp), %rdx
subq %r14, %rdx
movq %r12, %rcx
movq %rbx, %r8
movq -0x50(%rbp), %r9
callq 0xabc8
movq %rax, %r13
cmpq $-0x1, %rax
je 0xda5b
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x31598
movq %rbx, %rdi
callq 0x31afc
addq %r13, %r14
incq %r15
decq 0x130(%rbx)
decq 0xb0(%rbx)
cmpq $-0x1, %r13
movq -0x38(%rbp), %r13
jne 0xda01
pushq $-0x1
popq %r14
jmp 0xdae7
movq %rbx, %rdi
callq 0x31ae0
movq %rax, %r12
movq 0x8(%r13), %rdi
movq -0x40(%rbp), %rax
leaq (%rax,%r14), %rsi
movq -0x48(%rbp), %rdx
subq %r14, %rdx
movq %r12, %rcx
movq %rbx, %r8
movq -0x50(%rbp), %r9
callq 0xabc8
movq %rax, %r13
cmpq $-0x1, %rax
je 0xdac9
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x31598
movq %rbx, %rdi
callq 0x31afc
addq %r13, %r14
incq %r15
decq 0x130(%rbx)
decq 0xb0(%rbx)
cmpq $-0x1, %r13
movq -0x38(%rbp), %r13
je 0xdae7
cmpq 0x20(%r13), %r15
jb 0xda79
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdafb
movq %rax, %rdi
decq 0x130(%rbx)
decq 0xb0(%rbx)
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::AndPredicate::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 &chvs = c.push();
    auto se = scope_exit([&]() { c.pop(); });

    auto len = ope_->parse(s, n, chvs, c, dt);

    if (success(len)) {
      return 0;
    } else {
      return len;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %r8, %rdi
callq 0x31ae0
movq 0x8(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
movq %rbx, %r8
movq %r14, %r9
callq 0xabc8
xorl %ecx, %ecx
cmpq $-0x1, %rax
sete %cl
negq %rcx
decq 0x130(%rbx)
decq 0xb0(%rbx)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
decq 0x130(%rbx)
decq 0xb0(%rbx)
movq %rax, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::NotPredicate::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 &chvs = c.push();
    auto se = scope_exit([&]() { c.pop(); });
    auto len = ope_->parse(s, n, chvs, c, dt);
    if (success(len)) {
      c.set_error_pos(s);
      return static_cast<size_t>(-1);
    } else {
      return 0;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movq %r8, %rdi
callq 0x31ae0
movq 0x8(%r13), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
movq %rbx, %r8
movq %r15, %r9
callq 0xabc8
cmpq $-0x1, %rax
je 0xdc3f
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xa79a
pushq $-0x1
popq %rax
jmp 0xdc41
xorl %eax, %eax
decq 0x130(%rbx)
decq 0xb0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
decq 0x130(%rbx)
decq 0xb0(%rbx)
movq %rax, %rdi
callq 0x9430
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::CharacterClass::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 {
    if (n < 1) {
      c.set_error_pos(s);
      return static_cast<size_t>(-1);
    }

    char32_t cp = 0;
    auto len = decode_codepoint(s, n, cp);

    for (const auto &range : ranges_) {
      if (in_range(range, cp)) {
        if (negated_) {
          c.set_error_pos(s);
          return static_cast<size_t>(-1);
        } else {
          return len;
        }
      }
    }

    if (negated_) {
      return len;
    } else {
      c.set_error_pos(s);
      return static_cast<size_t>(-1);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
testq %rdx, %rdx
je 0xddf5
movq %rdi, %r12
movq %r8, -0x38(%rbp)
leaq -0x2c(%rbp), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x22b65
movq %rax, %r15
movq 0x18(%r12), %r13
movq 0x20(%r12), %r14
cmpq %r14, %r13
je 0xddfa
movl -0x2c(%rbp), %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x32022
addq $0x8, %r13
testb %al, %al
je 0xddd0
cmpb $0x0, 0x30(%r12)
jne 0xde02
jmp 0xde14
movq %r8, %rdi
jmp 0xde06
cmpb $0x0, 0x30(%r12)
jne 0xde14
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xa79a
pushq $-0x1
popq %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Character::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 {
    if (n < 1) {
      c.set_error_pos(s);
      return static_cast<size_t>(-1);
    }

    char32_t cp = 0;
    auto len = decode_codepoint(s, n, cp);

    if (cp != ch_) {
      c.set_error_pos(s);
      return static_cast<size_t>(-1);
    }
    return len;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rsi, %rbx
testq %rdx, %rdx
je 0xde96
movq %rdi, %r15
leaq -0x24(%rbp), %r12
andl $0x0, (%r12)
movq %rbx, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x22b65
movl (%r12), %ecx
cmpl 0x18(%r15), %ecx
je 0xdea6
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xa79a
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Whitespace::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 {
    if (c.in_whitespace) { return 0; }
    c.in_whitespace = true;
    auto se = scope_exit([&]() { c.in_whitespace = false; });
    return ope_->parse(s, n, vs, c, dt);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpb $0x0, 0x100(%r8)
je 0xe2d8
xorl %eax, %eax
jmp 0xe2f3
movq %r8, %rbx
movb $0x1, 0x100(%r8)
movq 0x8(%rdi), %rdi
callq 0xabc8
movb $0x0, 0x100(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movb $0x0, 0x100(%rbx)
movq %rax, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::DetectLeftRecursion::visit(peg::Sequence&)
void visit(Sequence &ope) override {
    for (auto op : ope.opes_) {
      op->accept(*this);
      if (done_) {
        break;
      } else if (error_s) {
        done_ = true;
        break;
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %r13
leaq -0x30(%rbp), %rbx
leaq -0x38(%rbp), %r12
cmpq %r13, %r15
je 0xe77e
movq %r12, %rdi
movq %r15, %rsi
callq 0x117ce
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
cmpb $0x0, 0x68(%r14)
jne 0xe776
cmpq $0x0, 0x8(%r14)
jne 0xe771
movq %rbx, %rdi
callq 0x1106c
addq $0x10, %r15
jmp 0xe738
movb $0x1, 0x68(%r14)
movq %rbx, %rdi
callq 0x1106c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1106c
movq %r14, %rdi
callq 0x9430
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::DetectLeftRecursion::visit(peg::PrioritizedChoice&)
void visit(PrioritizedChoice &ope) override {
    for (auto op : ope.opes_) {
      op->accept(*this);
      if (error_s) {
        done_ = true;
        break;
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %r13
leaq -0x30(%rbp), %rbx
leaq -0x38(%rbp), %r12
cmpq %r13, %r15
je 0xe803
movq %r12, %rdi
movq %r15, %rsi
callq 0x117ce
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
cmpq $0x0, 0x8(%r14)
jne 0xe7f6
movq %rbx, %rdi
callq 0x1106c
addq $0x10, %r15
jmp 0xe7c4
movb $0x1, 0x68(%r14)
movq %rbx, %rdi
callq 0x1106c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1106c
movq %r14, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::HasEmptyElement::visit(peg::Repetition&)
void visit(Repetition &ope) override {
    if (ope.min_ == 0) {
      set_error();
    } else {
      ope.ope_->accept(*this);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
cmpq $0x0, 0x18(%rsi)
je 0xeac7
movq 0x8(%rsi), %rdi
movq (%rdi), %rcx
movq 0x18(%rcx), %rcx
movq %rax, %rsi
popq %rbp
jmpq *%rcx
movq %rax, %rdi
popq %rbp
jmp 0x33388