LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rdi, -0x38(%rbp)
testq %rdx, %rdx
je 0xfaa1
movzbl (%rsi), %r9d
testb %r9b, %r9b
movq %rsi, -0x48(%rbp)
movq %r8, -0x40(%rbp)
js 0xfaa9
movl $0x1, %eax
movq %rax, -0x30(%rbp)
jmp 0xfb77
movq %r8, %rdi
jmp 0xfc01
movl %r9d, %eax
andl $-0x20, %eax
cmpl $0xc0, %eax
jne 0xfade
cmpq $0x1, %rdx
je 0xfb6c
andl $0x1f, %r9d
shll $0x6, %r9d
movl $0x2, %eax
movq %rax, -0x30(%rbp)
movl $0x1, %ecx
movl %r9d, %eax
jmp 0xfb5e
movl %r9d, %eax
andl $-0x10, %eax
cmpl $0xe0, %eax
jne 0xfb16
cmpq $0x3, %rdx
jb 0xfb6c
andl $0xf, %r9d
shll $0xc, %r9d
movzbl 0x1(%rsi), %eax
andl $0x3f, %eax
shll $0x6, %eax
orl %r9d, %eax
movl $0x3, %ecx
movq %rcx, -0x30(%rbp)
movl $0x2, %ecx
jmp 0xfb5e
movl %r9d, %eax
andl $-0x8, %eax
cmpl $0xf0, %eax
setne %al
cmpq $0x4, %rdx
setb %cl
orb %al, %cl
jne 0xfb6c
andl $0x7, %r9d
shll $0x12, %r9d
movzbl 0x1(%rsi), %ecx
andl $0x3f, %ecx
shll $0xc, %ecx
orl %r9d, %ecx
movzbl 0x2(%rsi), %eax
andl $0x3f, %eax
shll $0x6, %eax
orl %ecx, %eax
movl $0x4, %ecx
movq %rcx, -0x30(%rbp)
movl $0x3, %ecx
movzbl (%rsi,%rcx), %r9d
andl $0x3f, %r9d
orl %eax, %r9d
jmp 0xfb77
xorl %r9d, %r9d
movq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %r14
movq 0x20(%rax), %r15
cmpq %r15, %r14
sete %r12b
je 0xfbe1
movq -0x38(%rbp), %rdi
movq %r14, %rsi
movq %r9, %r13
movl %r9d, %edx
callq 0x3d064
movl %eax, %ebx
testb %al, %al
je 0xfbcd
movq -0x38(%rbp), %rax
cmpb $0x1, 0x30(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
jne 0xfbcd
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0xb232
movq $-0x1, -0x50(%rbp)
testb %bl, %bl
jne 0xfbe1
addq $0x8, %r14
cmpq %r15, %r14
sete %r12b
movq %r13, %r9
jne 0xfb8c
testb $0x1, %r12b
movq -0x50(%rbp), %rax
je 0xfc0f
movq -0x38(%rbp), %rax
cmpb $0x0, 0x30(%rax)
movq -0x30(%rbp), %rax
jne 0xfc0f
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0xb232
movq $-0x1, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rdx, %rdx
je 0xfd7c
movzbl (%rsi), %ecx
testb %cl, %cl
js 0xfcca
movl $0x1, %eax
jmp 0xfd77
movl %ecx, %eax
andl $-0x20, %eax
cmpl $0xc0, %eax
jne 0xfcf5
cmpq $0x1, %rdx
je 0xfd73
andl $0x1f, %ecx
shll $0x6, %ecx
movl $0x2, %eax
movl $0x1, %r9d
movl %ecx, %edx
jmp 0xfd67
movl %ecx, %eax
andl $-0x10, %eax
cmpl $0xe0, %eax
jne 0xfd26
cmpq $0x3, %rdx
jb 0xfd73
andl $0xf, %ecx
shll $0xc, %ecx
movzbl 0x1(%rsi), %edx
andl $0x3f, %edx
shll $0x6, %edx
orl %ecx, %edx
movl $0x3, %eax
movl $0x2, %r9d
jmp 0xfd67
movl %ecx, %eax
andl $-0x8, %eax
cmpl $0xf0, %eax
setne %al
cmpq $0x4, %rdx
setb %dl
orb %al, %dl
jne 0xfd73
andl $0x7, %ecx
shll $0x12, %ecx
movzbl 0x1(%rsi), %eax
andl $0x3f, %eax
shll $0xc, %eax
orl %ecx, %eax
movzbl 0x2(%rsi), %edx
andl $0x3f, %edx
shll $0x6, %edx
orl %eax, %edx
movl $0x4, %eax
movl $0x3, %r9d
movzbl (%rsi,%r9), %ecx
andl $0x3f, %ecx
orl %edx, %ecx
jmp 0xfd77
xorl %ecx, %ecx
xorl %eax, %eax
cmpl 0x18(%rdi), %ecx
je 0xfd8d
movq %r8, %rdi
xorl %edx, %edx
callq 0xb232
movq $-0x1, %rax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x103be
xorl %eax, %eax
jmp 0x103d9
movq %r8, %rbx
movb $0x1, 0x100(%r8)
movq 0x8(%rdi), %rdi
callq 0xb7ee
movb $0x0, 0x100(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movb $0x0, 0x100(%rbx)
movq %rax, %rdi
callq 0x9420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %r12
cmpq %r12, %r15
je 0x10976
movq %rdi, %rbx
movq 0x4f665(%rip), %r13     # 0x5ff70
movq (%r15), %rdi
movq 0x8(%r15), %r14
testq %r14, %r14
je 0x10929
cmpb $0x0, (%r13)
je 0x10924
incl 0x8(%r14)
jmp 0x10929
lock
incl 0x8(%r14)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
cmpb $0x0, 0x68(%rbx)
jne 0x1095b
cmpq $0x0, 0x8(%rbx)
jne 0x10957
testq %r14, %r14
je 0x1094c
movq %r14, %rdi
callq 0x13612
addq $0x10, %r15
cmpq %r12, %r15
jne 0x1090b
jmp 0x10976
movb $0x1, 0x68(%rbx)
testq %r14, %r14
je 0x10976
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13612
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0x10995
movq %r14, %rdi
callq 0x13612
movq %rbx, %rdi
callq 0x9420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %r12
cmpq %r12, %r15
je 0x10a28
movq %rdi, %rbx
movq 0x4f5ad(%rip), %r13     # 0x5ff70
movq (%r15), %rdi
movq 0x8(%r15), %r14
testq %r14, %r14
je 0x109e1
cmpb $0x0, (%r13)
je 0x109dc
incl 0x8(%r14)
jmp 0x109e1
lock
incl 0x8(%r14)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
cmpq $0x0, 0x8(%rbx)
jne 0x10a09
testq %r14, %r14
je 0x109fe
movq %r14, %rdi
callq 0x13612
addq $0x10, %r15
cmpq %r12, %r15
jne 0x109c3
jmp 0x10a28
movb $0x1, 0x68(%rbx)
testq %r14, %r14
je 0x10a28
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13612
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0x10a47
movq %r14, %rdi
callq 0x13612
movq %rbx, %rdi
callq 0x9420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10d69
movq 0x8(%rsi), %rdi
movq (%rdi), %rcx
movq 0x18(%rcx), %rcx
movq %rax, %rsi
popq %rbp
jmpq *%rcx
movb $0x1, 0x8(%rax)
movq 0x38(%rax), %rcx
movq 0x8(%rcx), %rsi
movq -0x28(%rsi), %rcx
movq %rcx, 0x10(%rax)
addq $0x18, %rax
addq $-0x20, %rsi
movq %rax, %rdi
popq %rbp
jmp 0x9170
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::HasEmptyElement::visit(peg::Reference&)
inline void HasEmptyElement::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_) {
    refs_.emplace_back(ope.s_, ope.name_);
    ope.rule_->accept(*this);
    refs_.pop_back();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq %r14, %rdx
callq 0x3e4e0
movq 0x38(%rbx), %rdi
cmpq 0x8(%rdi), %rax
je 0x10f2d
popq %rbx
popq %r14
popq %rbp
retq
cmpq $0x0, 0x68(%r14)
je 0x10f28
leaq 0x40(%r14), %rsi
leaq 0x20(%r14), %rdx
callq 0xe24a
movq 0x68(%r14), %rax
movq 0x1c0(%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x38(%rbx), %rcx
movq 0x8(%rcx), %rax
leaq -0x28(%rax), %rdx
movq %rdx, 0x8(%rcx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x10f28
movq (%rax), %rsi
incq %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x92b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::DetectInfiniteLoop::visit(peg::Repetition&)
void visit(Repetition &ope) override {
    if (ope.max_ == std::numeric_limits<size_t>::max()) {
      HasEmptyElement vis(refs_, has_error_cache_);
      ope.ope_->accept(vis);
      if (vis.is_empty) {
        has_error = true;
        error_s = vis.error_s;
        error_name = vis.error_name;
      }
    } else {
      ope.ope_->accept(*this);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpq $-0x1, 0x20(%rsi)
je 0x11159
movq 0x8(%rsi), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
movq %rbx, %rsi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movups 0x38(%rbx), %xmm0
leaq 0x4d50c(%rip), %r15     # 0x5e670
leaq -0x38(%rbp), %r14
movq %r15, -0x28(%r14)
xorl %eax, %eax
movb %al, -0x20(%r14)
movq %rax, -0x18(%r14)
movq %r14, -0x10(%r14)
movq %rax, -0x8(%r14)
movb %al, (%r14)
movups %xmm0, 0x10(%r14)
movq 0x8(%rsi), %rdi
movq (%rdi), %rax
leaq -0x60(%rbp), %rsi
callq *0x18(%rax)
cmpb $0x1, -0x58(%rbp)
jne 0x111b6
leaq -0x48(%rbp), %rsi
movb $0x1, 0x8(%rbx)
movq -0x8(%rsi), %rax
movq %rax, 0x10(%rbx)
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x9170
movq %r15, -0x60(%rbp)
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x111cf
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x92b0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, -0x60(%rbp)
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x111f6
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x92b0
movq %rbx, %rdi
callq 0x9420
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::FindReference::visit(peg::Sequence&)
void visit(Sequence &ope) override {
    std::vector<std::shared_ptr<Ope>> opes;
    for (auto o : ope.opes_) {
      o->accept(*this);
      opes.push_back(found_ope);
    }
    found_ope = std::make_shared<Sequence>(opes);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movq $0x0, -0x50(%rbp)
movq 0x8(%rsi), %r13
movq 0x10(%rsi), %r15
cmpq %r15, %r13
je 0x119e3
leaq 0x8(%rbx), %r14
movq (%r13), %rdi
movq 0x8(%r13), %r12
testq %r12, %r12
je 0x119b8
movq 0x4e5ca(%rip), %rax     # 0x5ff70
cmpb $0x0, (%rax)
je 0x119b2
incl 0x8(%r12)
jmp 0x119b8
lock
incl 0x8(%r12)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x3e7e4
testq %r12, %r12
je 0x119da
movq %r12, %rdi
callq 0x13612
addq $0x10, %r13
cmpq %r15, %r13
jne 0x11992
leaq -0x38(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x40(%rbp), %rsi
leaq -0x29(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0x313e4
movaps -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x40(%rbp)
movq 0x10(%rbx), %rdi
movups %xmm0, 0x8(%rbx)
testq %rdi, %rdi
je 0x11a1d
callq 0x13612
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x11a2b
callq 0x13612
leaq -0x60(%rbp), %rdi
callq 0xcae6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x11a58
movq %rax, %rbx
testq %r12, %r12
je 0x11a58
movq %r12, %rdi
callq 0x13612
leaq -0x60(%rbp), %rdi
callq 0xcae6
movq %rbx, %rdi
callq 0x9420
nop
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::FindReference::visit(peg::PrioritizedChoice&)
void visit(PrioritizedChoice &ope) override {
    std::vector<std::shared_ptr<Ope>> opes;
    for (auto o : ope.opes_) {
      o->accept(*this);
      opes.push_back(found_ope);
    }
    found_ope = std::make_shared<PrioritizedChoice>(opes);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movq $0x0, -0x50(%rbp)
movq 0x8(%rsi), %r13
movq 0x10(%rsi), %r15
cmpq %r15, %r13
je 0x11aef
leaq 0x8(%rbx), %r14
movq (%r13), %rdi
movq 0x8(%r13), %r12
testq %r12, %r12
je 0x11ac4
movq 0x4e4be(%rip), %rax     # 0x5ff70
cmpb $0x0, (%rax)
je 0x11abe
incl 0x8(%r12)
jmp 0x11ac4
lock
incl 0x8(%r12)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x3e7e4
testq %r12, %r12
je 0x11ae6
movq %r12, %rdi
callq 0x13612
addq $0x10, %r13
cmpq %r15, %r13
jne 0x11a9e
leaq -0x38(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x40(%rbp), %rsi
leaq -0x29(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0x31026
movaps -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x40(%rbp)
movq 0x10(%rbx), %rdi
movups %xmm0, 0x8(%rbx)
testq %rdi, %rdi
je 0x11b29
callq 0x13612
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x11b37
callq 0x13612
leaq -0x60(%rbp), %rdi
callq 0xcae6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x11b64
movq %rax, %rbx
testq %r12, %r12
je 0x11b64
movq %r12, %rdi
callq 0x13612
leaq -0x60(%rbp), %rdi
callq 0xcae6
movq %rbx, %rdi
callq 0x9420
nop
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::AssignIDToDefinition::visit(peg::Reference&)
inline void AssignIDToDefinition::visit(Reference &ope) {
  if (ope.rule_) {
    for (auto arg : ope.args_) {
      arg->accept(*this);
    }
    ope.rule_->accept(*this);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x68(%rsi)
je 0x12565
movq %rdi, %rbx
movq 0x50(%rsi), %r12
movq %rsi, -0x30(%rbp)
movq 0x58(%rsi), %r13
cmpq %r13, %r12
je 0x1253c
movq 0x4da72(%rip), %r14     # 0x5ff70
movq (%r12), %rdi
movq 0x8(%r12), %r15
testq %r15, %r15
je 0x1251d
cmpb $0x0, (%r14)
je 0x12518
incl 0x8(%r15)
jmp 0x1251d
lock
incl 0x8(%r15)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
testq %r15, %r15
je 0x12533
movq %r15, %rdi
callq 0x13612
addq $0x10, %r12
cmpq %r13, %r12
jne 0x124fe
movq -0x30(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x1c0(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r15, %r15
je 0x12584
movq %r15, %rdi
callq 0x13612
movq %rbx, %rdi
callq 0x9420
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::AnyCharacter::~AnyCharacter()
size_t parse_core(const char *s, size_t n, SemanticValues & /*vs*/,
                    Context &c, std::any & /*dt*/) const override {
    auto len = codepoint_length(s, n);
    if (len < 1) {
      c.set_error_pos(s);
      return static_cast<size_t>(-1);
    }
    return len;
  }

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

// Assembly:
testq %rdx, %rdx
je 0x126d3
movzbl (%rsi), %eax
testb %al, %al
js 0x1268b
movl $0x1, %eax
jmp 0x126cd
movl %eax, %ecx
andl $-0x20, %ecx
cmpl $0xc0, %ecx
sete %cl
cmpq $0x1, %rdx
setne %dil
testb %cl, %dil
je 0x126ad
movl $0x2, %eax
jmp 0x126cd
movl %eax, %ecx
andl $-0x10, %ecx
cmpl $0xe0, %ecx
sete %cl
cmpq $0x3, %rdx
setae %dil
testb %cl, %dil
je 0x126f2
movl $0x3, %eax
xorl %ecx, %ecx
testb %cl, %cl
je 0x126d5
xorl %eax, %eax
testq %rax, %rax
je 0x126db
retq
pushq %rbp
movq %rsp, %rbp
movq %r8, %rdi
xorl %edx, %edx
callq 0xb232
movq $-0x1, %rax
popq %rbp
retq
andl $-0x8, %eax
cmpl $0xf0, %eax
setne %al
cmpq $0x4, %rdx
setb %cl
orb %al, %cl
movl $0x4, %eax
jmp 0x126cf
nop
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::TokenChecker::is_token(peg::Ope&)
static bool is_token(Ope &ope) {
    if (IsLiteralToken::check(ope)) { return true; }

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x130(%rdi), %rcx
addq $0x118, %rdi            # imm = 0x118
movq 0x118(%rbx), %rax
movq 0x120(%rbx), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rsi
cmpq %rsi, %rcx
ja 0x12fa6
jne 0x12f7d
leaq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x8(%rax)
movaps %xmm0, 0x18(%rax)
movaps %xmm0, -0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq $0x0, 0x20(%rax)
leaq -0x40(%rbp), %rsi
callq 0x1326c
leaq -0x40(%rbp), %rdi
callq 0x134aa
jmp 0x12f98
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
cmpq $0x0, 0x28(%rax,%rcx)
je 0x12f98
addq %rcx, %rax
movq %rax, %rdi
callq 0x1353a
incq 0x130(%rbx)
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
leaq 0x316d1(%rip), %rdi     # 0x4467e
leaq 0x31701(%rip), %rsi     # 0x446b5
leaq 0x31705(%rip), %rcx     # 0x446c0
movl $0x398, %edx            # imm = 0x398
callq 0x91b0
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x134aa
movq %rbx, %rdi
callq 0x9420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %edx
cmpq %rsi, %rdi
jae 0x13f35
movl $0x1, %eax
movq %rdi, %rcx
xorl %r8d, %r8d
cmpb $0xa, (%rcx)
leaq 0x1(%rcx), %r9
cmoveq %r9, %rdi
sete %r8b
addl %r8d, %eax
movq %r9, %rcx
cmpq %rsi, %r9
jne 0x13f14
movl %eax, %eax
jmp 0x13f3d
movl $0x1, %eax
movq %rdi, %rsi
subq %rdi, %rsi
je 0x13fd2
movl $0x1, %edx
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %r8d
movl $0x1, %r10d
testb %r8b, %r8b
jns 0x13fbf
movq %rsi, %r9
subq %rcx, %r9
cmpq $0x1, %r9
je 0x13f7f
movl %r8d, %r11d
andl $-0x20, %r11d
movl $0x2, %r10d
cmpl $0xc0, %r11d
je 0x13fbf
cmpq $0x3, %r9
jb 0x13f9b
movl %r8d, %r11d
andl $-0x10, %r11d
movl $0x3, %r10d
cmpl $0xe0, %r11d
je 0x13fbf
andl $-0x8, %r8d
xorl %r11d, %r11d
cmpl $0xf0, %r8d
sete %r11b
shll $0x2, %r11d
cmpq $0x4, %r9
movl $0x0, %r10d
cmovaeq %r11, %r10
cmpq $0x1, %r10
adcq %r10, %rcx
incq %rdx
cmpq %rsi, %rcx
jb 0x13f4d
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::ErrorInfo::heuristic_error_token[abi:cxx11](char const*, unsigned long, char const*) const
std::string heuristic_error_token(const char *s, size_t n,
                                    const char *pos) const {
    auto len = n - std::distance(s, pos);
    if (len) {
      size_t i = 0;
      auto c = cast_char(pos[i++]);
      if (!std::ispunct(c) && !std::isspace(c)) {
        while (i < len && !std::ispunct(cast_char(pos[i])) &&
               !std::isspace(cast_char(pos[i]))) {
          i++;
        }
      }

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdi, %rbx
movq %r8, %rax
subq %rdx, %rax
subq %rax, %r15
jne 0x1400b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x140f3
movq %r8, %r14
movzbl (%r8), %r12d
movl %r12d, %edi
callq 0x9490
movl $0x1, %r13d
testl %eax, %eax
jne 0x14064
movl %r12d, %edi
callq 0x9050
testl %eax, %eax
setne %al
cmpq $0x2, %r15
setb %cl
orb %al, %cl
jne 0x14064
movzbl (%r14,%r13), %r12d
movl %r12d, %edi
callq 0x9490
testl %eax, %eax
jne 0x14064
movl %r12d, %edi
callq 0x9050
testl %eax, %eax
jne 0x14064
incq %r13
cmpq %r15, %r13
jb 0x1403c
movq %r15, %r13
movq $-0x1f, %rax
xorl %edx, %edx
movzbl (%r14,%rdx), %ecx
movl $0x1, %edi
testb %cl, %cl
jns 0x140d8
movq %r13, %rsi
subq %rdx, %rsi
cmpq $0x1, %rsi
je 0x1409c
movl %ecx, %r8d
andl $-0x20, %r8d
movl $0x2, %edi
cmpl $0xc0, %r8d
je 0x140d8
cmpq $0x3, %rsi
jb 0x140b7
movl %ecx, %r8d
andl $-0x10, %r8d
movl $0x3, %edi
cmpl $0xe0, %r8d
je 0x140d8
andl $-0x8, %ecx
xorl %r8d, %r8d
cmpl $0xf0, %ecx
sete %r8b
shll $0x2, %r8d
cmpq $0x4, %rsi
movl $0x0, %edi
cmovaeq %r8, %rdi
addq %rdi, %rdx
testq %rax, %rax
je 0x140e8
incq %rax
cmpq %r13, %rdx
jb 0x1406d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x141ed
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::ErrorInfo::replace_all(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::string replace_all(std::string str, const std::string &from,
                          const std::string &to) const {
    size_t pos = 0;
    while ((pos = str.find(from, pos)) != std::string::npos) {
      str.replace(pos, from.length(), to);
      pos += to.length();
    }
    return str;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r14
movq (%rcx), %rsi
movq 0x8(%rcx), %rcx
movq %rdx, %rdi
xorl %edx, %edx
callq 0x9410
cmpq $-0x1, %rax
je 0x14172
movq %rax, %r13
movq 0x8(%r12), %rdx
movq (%r15), %rcx
movq 0x8(%r15), %r8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x92f0
addq 0x8(%r15), %r13
movq (%r12), %rsi
movq 0x8(%r12), %rcx
movq %rbx, %rdi
movq %r13, %rdx
callq 0x9410
movq %rax, %r13
cmpq $-0x1, %rax
jne 0x1413a
leaq 0x10(%r14), %rcx
movq %rcx, (%r14)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rax
cmpq %rax, %rdx
je 0x14191
movq %rdx, (%r14)
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
jmp 0x14197
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testq %rdx, %rdx
je 0x1425d
movq %rdx, %r14
movq %rsi, %r15
xorl %r13d, %r13d
leaq 0x33be6(%rip), %r12     # 0x47e10
movb (%r15,%r13), %al
leal -0x9(%rax), %ecx
cmpb $0x5, %cl
jae 0x1424a
movzbl %cl, %eax
movslq (%r12,%rax,4), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x9480
jmp 0x14255
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9250
incq %r13
cmpq %r13, %r14
jne 0x1422a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x1428a
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x92b0
movq %r14, %rdi
callq 0x9420
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::parser::load_grammar(char const*, unsigned long, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<peg::Ope>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<peg::Ope>>>> const&, std::basic_string_view<char, std::char_traits<char>>)
bool load_grammar(const char *s, size_t n, const Rules &rules,
                    std::string_view start = {}) {
    auto cxt = ParserGenerator::parse(s, n, rules, log_, start);
    grammar_ = cxt.grammar;
    start_ = cxt.start;
    enablePackratParsing_ = cxt.enablePackratParsing;
    return grammar_ != nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, -0x30(%rbp)
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x38(%rdi), %rsi
leaq -0x60(%rbp), %rdi
callq 0xd1a0
movq %r15, -0x40(%rbp)
movq %r14, -0x38(%rbp)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq -0x98(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq -0x30(%rbp), %rcx
leaq -0x60(%rbp), %r8
callq 0x14520
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x14471
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq -0x90(%rbp), %rsi
movq -0x8(%rsi), %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
callq 0x1432c
leaq -0x88(%rbp), %rsi
leaq 0x10(%rbx), %rdi
callq 0x9170
leaq -0x78(%rbp), %rax
movb 0x10(%rax), %cl
movb %cl, 0x30(%rbx)
movq (%rbx), %rbx
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x144ba
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x90(%rbp), %rdi
testq %rdi, %rdi
je 0x144cb
callq 0x13612
testq %rbx, %rbx
setne %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14518
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x1461e
jmp 0x14510
movq %rax, %rbx
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x14510
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x9420
movq %rax, %rdi
callq 0xf084
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::decode[abi:cxx11](char const*, unsigned long)
inline std::u32string decode(const char *s8, size_t l) {
  std::u32string out;
  size_t i = 0;
  while (i < l) {
    auto beg = i++;
    while (i < l && (s8[i] & 0xc0) == 0x80) {
      i++;
    }
    out += decode_codepoint(&s8[beg], (i - beg));
  }
  return out;
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x40(%rsi), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rsi
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x347a0
leaq -0x19(%rbp), %r8
movb $0x0, (%r8)
leaq -0x28(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x30(%rbp), %rsi
leaq -0x1a(%rbp), %rdx
movq %r14, %rcx
callq 0x2d2f6
leaq -0x30(%rbp), %r14
movq (%r14), %rsi
movq %r14, %rdi
callq 0x2d37e
movq (%r14), %r15
movq 0x8(%r14), %r14
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34735
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x92b0
leaq -0x4fd0(%rip), %rax     # 0x2f76c
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movl $0x10, %edi
callq 0x92a0
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0x34798
movq %r14, %rdi
callq 0x13612
jmp 0x34798
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34798
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x92b0
movq %rbx, %rdi
callq 0x9420
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: std::vector<peg::ParserGenerator::Instruction, std::allocator<peg::ParserGenerator::Instruction>> peg::SemanticValues::transform<peg::ParserGenerator::Instruction>(unsigned long, unsigned long) const
std::vector<T> transform(size_t beg = 0,
                           size_t end = static_cast<size_t>(-1)) const {
    std::vector<T> r;
    end = (std::min)(end, size());
    for (size_t i = beg; i < end; i++) {
      r.emplace_back(std::any_cast<T>((*this)[i]));
    }
    return r;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rbx
subq (%rsi), %rbx
sarq $0x4, %rbx
cmpq %rcx, %rbx
cmovaeq %rcx, %rbx
subq %rdx, %rbx
jbe 0x389cc
movq %rdx, %r14
movq %rsi, %r15
leaq -0x68(%rbp), %r13
shlq $0x4, %r14
movq (%r15), %rdi
addq %r14, %rdi
callq 0x38b3d
movq %rax, %r12
testq %rax, %rax
je 0x389df
movq %r13, -0x78(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0x14292
movq $0x0, -0x50(%rbp)
movq 0x20(%r12), %rax
testq %rax, %rax
je 0x3896c
movq %r12, %rsi
addq $0x20, %rsi
leaq -0x58(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movl $0x2, %edi
leaq -0x38(%rbp), %rdx
callq *%rax
jmp 0x38974
movq $0x0, -0x58(%rbp)
movups 0x30(%r12), %xmm0
movups %xmm0, 0x20(%r13)
movq -0x30(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x38a2c
movq -0x58(%rbp), %rax
testq %rax, %rax
je 0x389aa
movl $0x3, %edi
leaq -0x58(%rbp), %rsi
xorl %edx, %edx
callq *%rax
movq $0x0, -0x58(%rbp)
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0x389bf
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x92b0
addq $0x10, %r14
decq %rbx
jne 0x3890e
movq -0x30(%rbp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2f195
jmp 0x38a10
movq %rax, %r14
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0x38a1b
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x92b0
jmp 0x38a1b
jmp 0x38a18
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x2fb72
jmp 0x38a1b
movq %rax, %rdi
callq 0xf084
movq %rax, %r14
movq -0x30(%rbp), %rdi
callq 0x2ef64
movq %r14, %rdi
callq 0x9420
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Context::line_info(char const*) const
std::pair<size_t, size_t> line_info(const char *cur) const {
    std::call_once(source_line_index_init_, [this]() {
      for (size_t pos = 0; pos < l; pos++) {
        if (s[pos] == '\n') { source_line_index.push_back(pos); }
      }
      source_line_index.push_back(l);
    });

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0xb0(%rdi), %rax
leaq 0x98(%rdi), %r14
movq 0x98(%rdi), %rcx
movq 0xa0(%rdi), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
cmpq %rdx, %rax
ja 0x3c7f1
movq %rdi, %rbx
jne 0x3c772
xorl %r12d, %r12d
leaq -0x30(%rbp), %r15
movq %r12, (%r15)
movl $0xb0, %edi
callq 0x92a0
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x234b5(%rip), %rcx     # 0x5fbb8
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movq %r12, 0x60(%rax)
movq %rbx, 0x68(%rax)
leaq 0xa0(%rax), %rdx
movups %xmm0, 0x70(%rax)
movups %xmm0, 0x80(%rax)
movq %rdx, 0x90(%rax)
movq %r12, 0x98(%rax)
movb $0x0, 0xa0(%rax)
movq %rax, 0x8(%r15)
movq %rcx, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3c8ee
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x3c7b4
callq 0x13612
jmp 0x3c7b4
shlq $0x4, %rax
movq (%rcx,%rax), %r14
movq (%r14), %rsi
cmpq 0x8(%r14), %rsi
je 0x3c799
movq %r14, %rdi
callq 0x3cbbc
movq 0x28(%r14), %rax
cmpq 0x30(%r14), %rax
je 0x3c799
movq %rax, 0x30(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r14)
movups %xmm0, 0x70(%r14)
movq 0x40(%r14), %rax
cmpq 0x48(%r14), %rax
je 0x3c7b4
movq %rax, 0x48(%r14)
movq 0xb0(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xb0(%rbx)
movq (%rbx), %rcx
movq 0x98(%rbx), %rdx
shlq $0x4, %rax
movq (%rdx,%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x20(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x874c(%rip), %rdi      # 0x44f44
leaq 0x7eb6(%rip), %rsi      # 0x446b5
leaq 0x8765(%rip), %rcx      # 0x44f6b
movl $0x374, %edx            # imm = 0x374
callq 0x91b0
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x3c821
callq 0x13612
movq %rbx, %rdi
callq 0x9420
nop
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::SemanticValues::append(peg::SemanticValues&)
void append(SemanticValues &chvs) {
    sv_ = chvs.sv_;
    for (auto &v : chvs) {
      emplace_back(std::move(v));
    }
    for (auto &tag : chvs.tags) {
      tags.emplace_back(std::move(tag));
    }
    for (auto &tok : chvs.tokens) {
      tokens.emplace_back(std::move(tok));
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movups 0x60(%rsi), %xmm0
movups %xmm0, 0x60(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x3c863
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc6b4
addq $0x10, %r15
jmp 0x3c84d
movq 0x28(%r14), %r15
movq 0x30(%r14), %r13
cmpq %r13, %r15
je 0x3c8a1
leaq 0x28(%rbx), %r12
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
je 0x3c88d
movl (%r15), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x30(%rbx)
jmp 0x3c898
movq %r12, %rdi
movq %r15, %rdx
callq 0x3ed30
addq $0x4, %r15
cmpq %r13, %r15
jne 0x3c874
movq 0x40(%r14), %r15
movq 0x48(%r14), %r12
cmpq %r12, %r15
je 0x3c8de
leaq 0x40(%rbx), %r14
movq 0x48(%rbx), %rsi
cmpq 0x50(%rbx), %rsi
je 0x3c8ca
movups (%r15), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x48(%rbx)
jmp 0x3c8d5
movq %r14, %rdi
movq %r15, %rdx
callq 0x3ee52
addq $0x10, %r15
cmpq %r12, %r15
jne 0x3c8b2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Context::shift_capture_values()
void shift_capture_values() {
    assert(capture_scope_stack_size >= 2);
    auto curr = &capture_scope_stack[capture_scope_stack_size - 1];
    auto prev = curr - 1;
    for (const auto &[k, v] : *curr) {
      (*prev)[k] = v;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x130(%rdi), %rcx
cmpq $0x1, %rcx
jbe 0x3ccb5
movq 0x118(%rdi), %rax
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %r12
addq $-0x28, %r12
movq 0x10(%r12), %rbx
cmpq %r12, %rbx
je 0x3ccac
leaq (%rax,%rcx), %r14
addq $-0x60, %r14
leaq 0x20(%rbx), %rsi
leaq 0x30(%rbx), %r15
movq %r14, %rdi
callq 0x335de
movq %rax, %rdi
movq %r15, %rsi
callq 0x9170
movq %rbx, %rdi
callq 0x91f0
movq %rax, %rbx
cmpq %r12, %rax
jne 0x3cc81
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8306(%rip), %rdi      # 0x44fc2
leaq 0x79f2(%rip), %rsi      # 0x446b5
leaq 0x8316(%rip), %rcx      # 0x44fe0
movl $0x3a6, %edx            # imm = 0x3A6
callq 0x91b0
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::CharacterClass::in_range(std::pair<char32_t, char32_t> const&, char32_t) const
bool in_range(const std::pair<char32_t, char32_t> &range, char32_t cp) const {
    if (ignore_case_) {
      auto cpl = std::tolower(cp);
      return std::tolower(range.first) <= cpl &&
             cpl <= std::tolower(range.second);
    } else {
      return range.first <= cp && cp <= range.second;
    }
  }

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rdi), %rax
movq 0x58(%rdi), %rcx
movb 0xe9(%rcx), %r14b
leaq 0x20628(%rip), %rsi     # 0x5dce0
leaq 0x20641(%rip), %rdx     # 0x5dd00
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x9300
cmpb $0x1, %r14b
jne 0x3d706
testq %rax, %rax
je 0x3d748
movq 0xd8(%rbx), %rcx
movq 0x70(%rax), %rax
movq -0x18(%rcx), %rcx
shlq $0x4, %rax
movq (%rcx,%rax), %rdi
movq 0x8(%rcx,%rax), %rbx
testq %rbx, %rbx
je 0x3d715
movq 0x22874(%rip), %rax     # 0x5ff70
cmpb $0x0, (%rax)
je 0x3d711
incl 0x8(%rbx)
jmp 0x3d715
testq %rax, %rax
je 0x3d748
movq 0x68(%rax), %r14
jmp 0x3d740
lock
incl 0x8(%rbx)
leaq 0x205c4(%rip), %rsi     # 0x5dce0
leaq 0x205dd(%rip), %rdx     # 0x5dd00
xorl %ecx, %ecx
callq 0x9300
testq %rax, %rax
je 0x3d74d
movq 0x68(%rax), %r14
testq %rbx, %rbx
je 0x3d740
movq %rbx, %rdi
callq 0x13612
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x9470
callq 0x9470
movq %rax, %r14
testq %rbx, %rbx
je 0x3d762
movq %rbx, %rdi
callq 0x13612
movq %r14, %rdi
callq 0x9420
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::parser::get_no_ast_opt_rules[abi:cxx11]() const
std::vector<std::string> get_no_ast_opt_rules() const {
    std::vector<std::string> rules;
    for (auto &[name, rule] : *grammar_) {
      if (rule.no_ast_opt) { rules.push_back(name); }
    }
    return rules;
  }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movzbl 0x20(%rsi), %eax
leaq 0x1003(%rip), %rcx      # 0x441ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1e95(%rip), %rsi      # 0x45095
leaq 0x1e91(%rip), %rdx      # 0x45098
jmp 0x432ce
movq %rsi, %rdi
callq 0xeddc
movq %rax, %r15
movq %rax, %r14
negq %r14
cmovsq %rax, %r14
movl $0x1, %r12d
cmpq $0xa, %r14
jb 0x432e1
movl $0x4, %r12d
movabsq $0x346dc5d63886594b, %rsi # imm = 0x346DC5D63886594B
movq %r14, %rcx
cmpq $0x63, %rcx
jbe 0x432d8
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0x432de
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0x432e1
movq %rcx, %rax
mulq %rsi
shrq $0xb, %rdx
addl $0x4, %r12d
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0x43244
addl $-0x3, %r12d
jmp 0x432e1
movq %rsi, %rdi
callq 0x3bd6a
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
addq %rdx, %rax
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
jmp 0x432d1
movq %rsi, %rdi
callq 0xec8e
leaq 0x1de9(%rip), %rcx      # 0x45099
leaq 0x1de7(%rip), %rsi      # 0x4509e
testb %al, %al
cmovneq %rcx, %rsi
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movzbl %al, %edx
xorq $0x5, %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x12846
jmp 0x4330e
addl $-0x2, %r12d
jmp 0x432e1
decl %r12d
shrq $0x3f, %r15
leal (%r15,%r12), %esi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movl $0x2d, %edx
callq 0x9320
addq (%rbx), %r15
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x4331a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq