LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xab4b
testq %rax, %rax
jne 0xab6a
movq %rdi, %rbx
movq 0x138(%rdi), %rax
cmpq 0x148(%rdi), %rax
jne 0xab89
cmpl $0x0, 0x150(%rbx)
jne 0xab89
movq 0x290(%rbx), %rdi
testq %rdi, %rdi
je 0xa9d4
movq 0x2a0(%rbx), %rsi
subq %rdi, %rsi
callq 0x82b0
movq 0x270(%rbx), %rdi
testq %rdi, %rdi
je 0xa9ef
movq 0x280(%rbx), %rsi
subq %rdi, %rsi
callq 0x82b0
movq 0x258(%rbx), %rax
testq %rax, %rax
je 0xaa0c
leaq 0x248(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x230(%rbx), %rax
testq %rax, %rax
je 0xaa32
leaq 0x230(%rbx), %r14
movl $0x3, %edi
movq %r14, %rsi
xorl %edx, %edx
callq *%rax
movq $0x0, (%r14)
movq 0x220(%rbx), %rax
testq %rax, %rax
je 0xaa4f
leaq 0x210(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x200(%rbx), %rax
testq %rax, %rax
je 0xaa6c
leaq 0x1f0(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x1c0(%rbx), %rdi
callq 0x1235c
leaq 0x198(%rbx), %rdi
callq 0x12020
leaq 0x170(%rbx), %rdi
callq 0x12020
leaq 0x138(%rbx), %rdi
callq 0x12020
leaq 0x118(%rbx), %rdi
callq 0x11db4
movq 0x110(%rbx), %rdi
testq %rdi, %rdi
je 0xaab9
callq 0x123fc
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0xaaca
callq 0x123fc
leaq 0xd0(%rbx), %rdi
callq 0x11e0a
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0xaaf1
movq 0xc8(%rbx), %rsi
subq %rdi, %rsi
callq 0x82b0
leaq 0x98(%rbx), %rdi
callq 0x11e60
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0xab15
movq (%rax), %rsi
incq %rsi
callq 0x82b0
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0xab2d
movq (%rax), %rsi
incq %rsi
callq 0x82b0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xab46
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x82b0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x37b96(%rip), %rdi     # 0x426e8
leaq 0x37b5c(%rip), %rsi     # 0x426b5
leaq 0x37b9a(%rip), %rcx     # 0x426fa
movl $0x33f, %edx            # imm = 0x33F
callq 0x81b0
leaq 0x37ba2(%rip), %rdi     # 0x42713
leaq 0x37b3d(%rip), %rsi     # 0x426b5
leaq 0x37b7b(%rip), %rcx     # 0x426fa
movl $0x340, %edx            # imm = 0x340
callq 0x81b0
leaq 0x37b9d(%rip), %rdi     # 0x4272d
leaq 0x37b1e(%rip), %rsi     # 0x426b5
leaq 0x37b5c(%rip), %rcx     # 0x426fa
movl $0x341, %edx            # imm = 0x341
callq 0x81b0
jmp 0xabb4
jmp 0xabb4
jmp 0xabb4
jmp 0xabb4
jmp 0xabb4
jmp 0xabb4
movq %rax, %rdi
callq 0xe032
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa7b8
movq %rax, %r15
decq 0xe8(%rbx)
cmpq $-0x1, %rax
je 0xb23f
movq %r15, -0x48(%rbp)
movq %r14, -0x40(%rbp)
movq 0x48(%r12), %rsi
cmpq 0x50(%r12), %rsi
je 0xb248
movups -0x48(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x48(%r12)
jmp 0xb256
movq $-0x1, %r15
jmp 0xb292
leaq 0x40(%r12), %rdi
leaq -0x48(%rbp), %rdx
callq 0x3cd94
cmpq $0x0, 0xe8(%rbx)
jne 0xb292
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0xb292
addq %r15, %r14
subq %r15, %r13
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %rbx, %r8
movq -0x38(%rbp), %r9
callq 0xa7b8
addq %rax, %r15
cmpq $-0x1, %rax
cmoveq %rax, %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 0xb2af
movq %rax, %rdi
jmp 0xb2be
movq %rax, %rdi
decq 0xe8(%rbx)
movb -0x29(%rbp), %al
movb %al, 0x288(%rbx)
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3dcda
testq %rax, %rax
jne 0xcd3d
movq 0x20(%rbx), %r12
leaq -0x28(%rbp), %rsi
movq %r15, %rdi
callq 0x3dd3c
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_O3/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
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x48(%rsi)
jne 0xcdb4
movq 0x50(%rsi), %r15
movq 0x58(%rsi), %r12
cmpq %r12, %r15
je 0xcdb8
movq 0x511fb(%rip), %r13     # 0x5df70
movq (%r15), %rdi
movq 0x8(%r15), %r14
testq %r14, %r14
je 0xcd93
cmpb $0x0, (%r13)
je 0xcd8e
incl 0x8(%r14)
jmp 0xcd93
lock
incl 0x8(%r14)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
testq %r14, %r14
je 0xcda9
movq %r14, %rdi
callq 0x123fc
addq $0x10, %r15
cmpq %r12, %r15
jne 0xcd75
jmp 0xcdb8
movb $0x1, 0x9(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0xcdd7
movq %r14, %rdi
callq 0x123fc
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
cmpb $0x1, 0x48(%rsi)
jne 0xce5f
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), %r12
cmpq %r12, %r15
je 0xce5f
movq 0x5114e(%rip), %r13     # 0x5df70
movq (%r15), %rdi
movq 0x8(%r15), %r14
testq %r14, %r14
je 0xce40
cmpb $0x0, (%r13)
je 0xce3b
incl 0x8(%r14)
jmp 0xce40
lock
incl 0x8(%r14)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
testq %r14, %r14
je 0xce56
movq %r14, %rdi
callq 0x123fc
addq $0x10, %r15
cmpq %r12, %r15
jne 0xce22
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0xce7e
movq %r14, %rdi
callq 0x123fc
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsi), %r15
movq 0x28(%rsi), %rdx
cmpq 0x18(%rdi), %rdx
jne 0xcebe
testq %rdx, %rdx
je 0xcf05
movq 0x10(%rbx), %rsi
movq (%r15), %rdi
callq 0x82c0
testl %eax, %eax
je 0xcf05
leaq 0x30(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3dfe8
testq %rax, %rax
jne 0xcf0d
leaq -0x28(%rbp), %rdx
movq %r12, (%rdx)
movq %r12, %rdi
movq %r15, %rsi
callq 0x38f26
movq 0x68(%r14), %rax
testq %rax, %rax
je 0xcf0d
movq 0x1c0(%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
cmpb $0x0, 0x68(%rbx)
jne 0xcf0d
jmp 0xcf11
movq 0x40(%r14), %rax
movq %rax, 0x8(%rbx)
movb $0x1, 0x68(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %rbx
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8(%rsi), %r13
cmpq 0x10(%rsi), %r13
je 0xcfa2
movq %rsi, %r14
leaq 0x18(%rbx), %rax
movq %rax, -0x30(%rbp)
xorl %r12d, %r12d
movq (%r13), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
cmpb $0x0, 0x8(%rbx)
je 0xcfc3
movq 0x10(%rbx), %r15
leaq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x8170
movb %r12b, 0x8(%rbx)
movq $0x0, 0x20(%rbx)
movq 0x18(%rbx), %rax
movb %r12b, (%rax)
addq $0x10, %r13
cmpq 0x10(%r14), %r13
jne 0xcf5d
movb $0x1, %al
jmp 0xcfa7
xorl %eax, %eax
xorl %r15d, %r15d
movb %al, 0x8(%rbx)
movq %r15, 0x10(%rbx)
addq $0x18, %rbx
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x8170
jmp 0xd06f
addq $0x10, %r13
cmpq 0x10(%r14), %r13
je 0xd06f
leaq -0x70(%rbp), %r15
xorl %r12d, %r12d
movups 0x38(%rbx), %xmm0
leaq 0x4f7b5(%rip), %rax     # 0x5c798
movq %rax, -0x98(%rbp)
movb %r12b, -0x90(%rbp)
movq %r12, -0x88(%rbp)
movq %r15, -0x80(%rbp)
movq %r12, -0x78(%rbp)
movb %r12b, -0x70(%rbp)
movups %xmm0, -0x60(%rbp)
movq (%r13), %rdi
movq (%rdi), %rax
leaq -0x98(%rbp), %rsi
callq *0x18(%rax)
cmpb $0x1, -0x90(%rbp)
jne 0xd03e
movb $0x1, 0x8(%rbx)
movq -0x88(%rbp), %rax
movq %rax, 0x10(%rbx)
movq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x8170
leaq 0x4f753(%rip), %rax     # 0x5c798
movq %rax, -0x98(%rbp)
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0xd061
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x82b0
addq $0x10, %r13
cmpq 0x10(%r14), %r13
jne 0xcfd8
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xd088
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x82b0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd0c1
movq %rax, %rbx
leaq 0x4f6f5(%rip), %rax     # 0x5c798
movq %rax, -0x98(%rbp)
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0xd0c4
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x82b0
jmp 0xd0c4
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xd0dd
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x82b0
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq %r14, %rdx
callq 0x3e02c
movq 0x38(%rbx), %rcx
cmpq 0x8(%rcx), %rax
jne 0xd222
cmpq $0x0, 0x68(%r14)
je 0xd1ca
movq 0x40(%rbx), %rdi
leaq 0x20(%r14), %r15
movq %r15, %rsi
callq 0x3e192
testq %rax, %rax
je 0xd16b
movb 0x28(%rax), %al
movb %al, 0x8(%rbx)
jmp 0xd1ca
movq 0x38(%rbx), %rdi
leaq 0x40(%r14), %rsi
movq %r15, %rdx
callq 0xd24a
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 0xd1b7
movq (%rax), %rsi
incq %rsi
callq 0x82b0
movb 0x8(%rbx), %r12b
movq 0x40(%rbx), %rdi
movq %r15, %rsi
callq 0x3e29e
movb %r12b, (%rax)
cmpb $0x1, 0x48(%r14)
jne 0xd222
movq 0x50(%r14), %r15
movq 0x58(%r14), %r12
cmpq %r12, %r15
je 0xd222
movq 0x50d8b(%rip), %r13     # 0x5df70
movq (%r15), %rdi
movq 0x8(%r15), %r14
testq %r14, %r14
je 0xd203
cmpb $0x0, (%r13)
je 0xd1fe
incl 0x8(%r14)
jmp 0xd203
lock
incl 0x8(%r14)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
testq %r14, %r14
je 0xd219
movq %r14, %rdi
callq 0x123fc
addq $0x10, %r15
cmpq %r12, %r15
jne 0xd1e5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0xd241
movq %r14, %rdi
callq 0x123fc
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x30(%rbp)
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq (%rax), %r13
movq 0x8(%rax), %r14
subq %r13, %r14
je 0xd69e
sarq $0x5, %r14
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x28(%rax), %r12
cmpq $0x1, %r14
adcq $0x0, %r14
addq $0x8, %r13
xorl %r15d, %r15d
cmpq %r12, (%r13)
jne 0xd692
testq %r12, %r12
je 0xd6d2
movq -0x8(%r13), %rdi
movq -0x38(%rbp), %rsi
movq %r12, %rdx
callq 0x82c0
testl %eax, %eax
je 0xd6d2
incq %r15
addq $0x20, %r13
cmpq %r15, %r14
jne 0xd673
movq 0x8(%rbx), %rdi
movq -0x30(%rbp), %r14
leaq 0x20(%r14), %r15
movq %r15, %rsi
callq 0x3e722
testq %rax, %rax
je 0xd6da
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x3efb0
testq %rax, %rax
je 0xd73a
addq $0x28, %rax
movq %rax, 0x68(%r14)
jmp 0xd6da
movq -0x30(%rbp), %r14
movq %r15, 0x70(%r14)
movq 0x50(%r14), %r15
movq 0x58(%r14), %r12
cmpq %r12, %r15
je 0xd72b
movq 0x50882(%rip), %r13     # 0x5df70
movq (%r15), %rdi
movq 0x8(%r15), %r14
testq %r14, %r14
je 0xd70c
cmpb $0x0, (%r13)
je 0xd707
incl 0x8(%r14)
jmp 0xd70c
lock
incl 0x8(%r14)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
testq %r14, %r14
je 0xd722
movq %r14, %rdi
callq 0x123fc
addq $0x10, %r15
cmpq %r12, %r15
jne 0xd6ee
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x35941(%rip), %rdi     # 0x43082
callq 0x8370
movq %rax, %rbx
testq %r14, %r14
je 0xd756
movq %r14, %rdi
callq 0x123fc
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq 0x18(%rdi), %rax
movq (%rax), %r15
movq 0x8(%rax), %r14
subq %r15, %r14
je 0xd7dc
sarq $0x4, %r14
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rbx
movq -0x38(%rbp), %rax
movq 0x20(%rax), %r12
movq 0x28(%rax), %r13
cmpq $0x1, %r14
adcq $0x0, %r14
addq $0x8, %r15
addq $0x8, %rbx
cmpq %r13, (%rbx)
jne 0xd7cf
testq %r13, %r13
je 0xd82e
movq -0x8(%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x82c0
testl %eax, %eax
je 0xd82e
addq $0x10, %r15
addq $0x20, %rbx
decq %r14
jne 0xd7b2
movq -0x38(%rbp), %rsi
addq $0x8, %rsi
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x3eff4
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movups %xmm0, 0x8(%rax)
testq %rdi, %rdi
je 0xd81f
callq 0x123fc
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0xd81f
callq 0x123fc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x8(%r15), %rax
movq -0x30(%rbp), %rdi
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq %r15, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x130c6
// File: /workspace/github_cpp_makefile_star2_O3/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 $0xc8, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xda8e
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
leaq 0x10(%rbx), %rsi
movq %r8, -0x38(%rbp)
callq 0x2eb22
movq %rax, %r14
leaq 0x38(%rbx), %rsi
leaq -0x58(%rbp), %rdi
movq %rsi, -0x30(%rbp)
callq 0xc1b6
leaq -0x58(%rbp), %rax
movq %rax, (%rsp)
leaq -0xe0(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %rcx
movq %r12, %r8
movq -0x38(%rbp), %r9
callq 0x3fe5e
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0xda00
leaq -0x58(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
cmpq $0x0, 0x48(%rbx)
movb -0xe0(%rbp), %bl
je 0xda2e
testb $0x1, %bl
jne 0xda2e
leaq -0xd0(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0xc244
movb -0xe0(%rbp), %bl
leaq -0x78(%rbp), %rax
movb -0x67(%rax), %r14b
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xda4b
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x82b0
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xda6a
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x82b0
xorb $0x1, %r14b
movq -0xc8(%rbp), %rdi
testq %rdi, %rdi
je 0xda89
movq -0xb8(%rbp), %rsi
subq %rdi, %rsi
callq 0x82b0
andb %r14b, %bl
jmp 0xda90
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0x36f2a
jmp 0xdad4
jmp 0xdadc
movq %rax, %rbx
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0xdad4
leaq -0x58(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x8420
movq %rax, %rdi
callq 0xe032
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/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 0x40ca0
movb (%rax), %al
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0xdca2
movq %rbx, %rdi
callq 0x8110
movl $0x10, %edi
callq 0x8150
movq %rax, %r14
leaq 0x35292(%rip), %rsi     # 0x42f01
movq %rax, %rdi
callq 0x8100
movq 0x50372(%rip), %rsi     # 0x5dff0
movq 0x502bb(%rip), %rdx     # 0x5df40
movq %r14, %rdi
callq 0x8400
movq %rax, %rbx
jmp 0xdc9d
movq %rax, %rbx
movq %r14, %rdi
callq 0x8220
callq 0x83f0
movq %rbx, %rdi
callq 0x8420
movq %rax, %rdi
callq 0xe032
// File: /workspace/github_cpp_makefile_star2_O3/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 0x34308(%rip), %rcx     # 0x42004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x39c4e
movq %rax, %r14
movq %rbx, %rdi
callq 0x39c4e
jmp 0xdd27
callq 0xdd86
movq %rax, %r14
movq %rbx, %rdi
callq 0xdd86
cmpq %rax, %r14
sete %al
jmp 0xdd7b
callq 0x39cc8
movq %rax, %r14
movq %rdx, %r15
movq %rbx, %rdi
callq 0x39cc8
cmpq %rax, %r14
jne 0xdd5e
testq %r14, %r14
je 0xdd79
movq %r15, %rdi
movq %rdx, %rsi
movq %r14, %rdx
callq 0x82c0
testl %eax, %eax
je 0xdd79
xorl %eax, %eax
jmp 0xdd7b
callq 0xdc38
movl %eax, %r14d
movq %rbx, %rdi
callq 0xdc38
xorb %r14b, %al
xorb $0x1, %al
jmp 0xdd7b
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
addq $0x10, %rdi
movq %rax, %rsi
callq 0x39e78
leaq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0xde3c
addq $0x30, %rax
jmp 0xde51
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xde60
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xde02
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x8150
movq %rax, %rbx
movq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x38(%rbp), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x11634
leaq 0x3509f(%rip), %rsi     # 0x42f2f
leaq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x39dfd
leaq 0x3439a(%rip), %rsi     # 0x42241
leaq -0x98(%rbp), %rdi
callq 0x8480
leaq -0x68(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xded4
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0xdedf
movq %rdx, -0x78(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x68(%rbp)
movq 0x8(%rax), %rdx
leaq -0x78(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %r12b
movq %rbx, %rdi
callq 0x83d0
xorl %r12d, %r12d
movq 0x500e1(%rip), %rsi     # 0x5dff0
movq 0x5002a(%rip), %rdx     # 0x5df40
movq %rbx, %rdi
callq 0x8400
movq %rax, %r14
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0xdf3e
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x82b0
jmp 0xdf3e
movq %rax, %r14
movb $0x1, %r12b
leaq -0x88(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdf5d
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x82b0
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0xdf72
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x82b0
testb %r12b, %r12b
jne 0xdf96
jmp 0xdf9e
movq %rax, %r14
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0xdf96
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x82b0
jmp 0xdf96
movq %rax, %r14
movq %rbx, %rdi
callq 0x8220
movq %r14, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rdi, %r15
movq %r8, -0x30(%rbp)
movq %r8, %rdi
callq 0x3a5ca
movq %rax, %r12
movq 0x8(%r15), %r13
movq 0x10(%r15), %r14
xorl %r15d, %r15d
cmpq %r14, %r13
je 0xe0f8
movq (%r13), %rdi
leaq (%rbx,%r15), %rsi
movq -0x40(%rbp), %rdx
subq %r15, %rdx
movq %r12, %rcx
movq -0x30(%rbp), %r8
movq -0x48(%rbp), %r9
callq 0xa7b8
cmpq $-0x1, %rax
je 0xe106
addq %rax, %r15
addq $0x10, %r13
jmp 0xe0c5
movq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0x3a74e
jmp 0xe10d
movq $-0x1, %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 0xe12c
movq -0x30(%rbp), %rcx
decq 0xb0(%rcx)
movq %rax, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x38, %rsp
movq %r9, -0x60(%rbp)
movq %r8, %r14
movq %rcx, -0x48(%rbp)
movq %rdx, -0x58(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdi, %r12
cmpq $0x0, 0x18(%rdi)
movq %rdi, -0x40(%rbp)
je 0xe50b
leaq 0x130(%r14), %rax
movq %rax, -0x38(%rbp)
leaq 0xb0(%r14), %rax
movq %rax, -0x30(%rbp)
xorl %r15d, %r15d
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x11ce2
movq %r14, %rdi
callq 0x3a5ca
movq %r12, %rcx
movq %rax, %r12
movq 0x8(%rcx), %rdi
movq -0x50(%rbp), %rax
leaq (%rax,%r13), %rsi
movq -0x58(%rbp), %rdx
subq %r13, %rdx
movq %r12, %rcx
movq %r14, %r8
movq -0x60(%rbp), %r9
callq 0xa7b8
movq %rax, %rbx
cmpq $-0x1, %rax
je 0xe5a5
movq -0x48(%rbp), %rdi
movq %r12, %rsi
callq 0x3a74e
movq %r14, %rdi
callq 0x3ab5a
movq -0x38(%rbp), %rax
decq (%rax)
addq %r13, %rbx
movq -0x30(%rbp), %rax
decq (%rax)
incq %r15
movq %rbx, %r13
movq -0x40(%rbp), %r12
cmpq 0x18(%r12), %r15
jb 0xe48e
jmp 0xe510
xorl %ebx, %ebx
xorl %r15d, %r15d
cmpq 0x20(%r12), %r15
jae 0xe5ba
leaq 0x130(%r14), %rax
movq %rax, -0x38(%rbp)
leaq 0xb0(%r14), %rax
movq %rax, -0x30(%rbp)
movq %r14, %rdi
callq 0x11ce2
movq %r14, %rdi
callq 0x3a5ca
movq %rax, %r13
movq 0x8(%r12), %rdi
movq -0x50(%rbp), %rax
leaq (%rax,%rbx), %rsi
movq -0x58(%rbp), %rdx
subq %rbx, %rdx
movq %r13, %rcx
movq %r14, %r8
movq -0x60(%rbp), %r9
callq 0xa7b8
movq %rax, %r12
cmpq $-0x1, %rax
je 0xe5ac
movq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x3a74e
movq %r14, %rdi
callq 0x3ab5a
movq -0x38(%rbp), %rax
decq (%rax)
movq -0x30(%rbp), %rax
decq (%rax)
addq %r12, %rbx
incq %r15
movq -0x40(%rbp), %r12
cmpq 0x20(%r12), %r15
jb 0xe531
jmp 0xe5ba
movq $-0x1, %rbx
movq -0x38(%rbp), %rax
decq (%rax)
movq -0x30(%rbp), %rax
decq (%rax)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe5ce
movq -0x38(%rbp), %rcx
decq (%rcx)
movq -0x30(%rbp), %rcx
decq (%rcx)
movq %rax, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11ce2
movq %rbx, %rdi
callq 0x3a5ca
movq 0x8(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
movq %rbx, %r8
movq %r14, %r9
callq 0xa7b8
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 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11ce2
movq %rbx, %rdi
callq 0x3a5ca
movq 0x8(%r13), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
movq %rbx, %r8
movq %r15, %r9
callq 0xa7b8
cmpq $-0x1, %rax
je 0xe755
movq $-0x1, %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xa1fe
jmp 0xe758
xorl %r15d, %r15d
decq 0x130(%rbx)
decq 0xb0(%rbx)
movq %r15, %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 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::CharacterClass::CharacterClass(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool)
CharacterClass(const std::string &s, bool negated, bool ignore_case)
      : negated_(negated), ignore_case_(ignore_case) {
    auto chars = decode(s.data(), s.length());
    auto i = 0u;
    while (i < chars.size()) {
      if (i + 2 < chars.size() && chars[i + 1] == '-') {
        auto cp1 = chars[i];
        auto cp2 = chars[i + 2];
        ranges_.emplace_back(std::pair(cp1, cp2));
        i += 3;
      } else {
        auto cp = chars[i];
        ranges_.emplace_back(std::pair(cp, cp));
        i += 1;
      }
    }
    assert(!ranges_.empty());
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x304da(%rip), %rax     # 0x5bfd8
movq %rax, (%rdi)
leaq 0x18(%rdi), %r14
movups %xmm0, 0x18(%rdi)
movq $0x0, 0x28(%rdi)
movb %dl, 0x30(%rdi)
movb %cl, 0x31(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x2bc3c
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x2bb98
xorl %r12d, %r12d
leaq -0x28(%rbp), %r15
leal 0x2(%r12), %ecx
movq -0x48(%rbp), %rdx
cmpq %rcx, %rax
jbe 0x2bb72
leal 0x1(%r12), %eax
cmpl $0x2d, (%rdx,%rax,4)
jne 0x2bb72
movl (%rdx,%r12,4), %eax
movl (%rdx,%rcx,4), %ecx
movl %eax, -0x28(%rbp)
movl %ecx, -0x24(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2bda4
movl $0x3, %eax
jmp 0x2bb8c
movl (%rdx,%r12,4), %eax
movl %eax, -0x28(%rbp)
movl %eax, -0x24(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2bda4
movl $0x1, %eax
addl %eax, %r12d
movq -0x40(%rbp), %rax
cmpq %r12, %rax
ja 0x2bb3a
movq 0x18(%rbx), %rax
cmpq 0x20(%rbx), %rax
je 0x2bbcd
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2bbc0
movq -0x38(%rbp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x82b0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16ef9(%rip), %rdi     # 0x42acd
leaq 0x16ada(%rip), %rsi     # 0x426b5
leaq 0x16efc(%rip), %rcx     # 0x42ade
movl $0x4da, %edx            # imm = 0x4DA
callq 0x81b0
movq %rax, %r15
jmp 0x2bc14
jmp 0x2bbf3
movq %rax, %r15
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2bc14
movq -0x38(%rbp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x82b0
leaq 0x8(%rbx), %r12
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2bc2c
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x82b0
movq %r12, %rdi
callq 0x2bde6
movq %r15, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/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
testq %rdx, %rdx
je 0xea71
movq %rdi, %r15
movzbl (%rsi), %r12d
testb %r12b, %r12b
movq %rsi, -0x38(%rbp)
movq %r8, -0x30(%rbp)
js 0xea79
movl $0x1, %r13d
jmp 0xeb36
movq %r8, %rdi
jmp 0xeb73
movl %r12d, %eax
andl $-0x20, %eax
cmpl $0xc0, %eax
jne 0xeaa8
cmpq $0x1, %rdx
je 0xeb30
andl $0x1f, %r12d
shll $0x6, %r12d
movl $0x2, %r13d
movl $0x1, %ecx
movl %r12d, %eax
jmp 0xeb22
movl %r12d, %eax
andl $-0x10, %eax
cmpl $0xe0, %eax
jne 0xeadd
cmpq $0x3, %rdx
jb 0xeb30
andl $0xf, %r12d
shll $0xc, %r12d
movzbl 0x1(%rsi), %eax
andl $0x3f, %eax
shll $0x6, %eax
orl %r12d, %eax
movl $0x3, %r13d
movl $0x2, %ecx
jmp 0xeb22
movl %r12d, %eax
andl $-0x8, %eax
cmpl $0xf0, %eax
setne %al
cmpq $0x4, %rdx
setb %cl
orb %al, %cl
jne 0xeb30
andl $0x7, %r12d
shll $0x12, %r12d
movzbl 0x1(%rsi), %ecx
andl $0x3f, %ecx
shll $0xc, %ecx
orl %r12d, %ecx
movzbl 0x2(%rsi), %eax
andl $0x3f, %eax
shll $0x6, %eax
orl %ecx, %eax
movl $0x4, %r13d
movl $0x3, %ecx
movzbl (%rsi,%rcx), %r12d
andl $0x3f, %r12d
orl %eax, %r12d
jmp 0xeb36
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x18(%r15), %r14
movq 0x20(%r15), %rbx
cmpq %rbx, %r14
je 0xeb5b
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x3af7e
testb %al, %al
jne 0xeb64
addq $0x8, %r14
jmp 0xeb3e
cmpb $0x0, 0x30(%r15)
je 0xeb6b
jmp 0xeb81
cmpb $0x1, 0x30(%r15)
jne 0xeb81
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0xa1fe
movq $-0x1, %r13
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::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 0xecf2
movzbl (%rsi), %ecx
testb %cl, %cl
js 0xec40
movl $0x1, %eax
jmp 0xeced
movl %ecx, %eax
andl $-0x20, %eax
cmpl $0xc0, %eax
jne 0xec6b
cmpq $0x1, %rdx
je 0xece9
andl $0x1f, %ecx
shll $0x6, %ecx
movl $0x2, %eax
movl $0x1, %r9d
movl %ecx, %edx
jmp 0xecdd
movl %ecx, %eax
andl $-0x10, %eax
cmpl $0xe0, %eax
jne 0xec9c
cmpq $0x3, %rdx
jb 0xece9
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 0xecdd
movl %ecx, %eax
andl $-0x8, %eax
cmpl $0xf0, %eax
setne %al
cmpq $0x4, %rdx
setb %dl
orb %al, %dl
jne 0xece9
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 0xeced
xorl %ecx, %ecx
xorl %eax, %eax
cmpl 0x18(%rdi), %ecx
je 0xed03
movq %r8, %rdi
xorl %edx, %edx
callq 0xa1fe
movq $-0x1, %rax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::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 0xf318
xorl %eax, %eax
jmp 0xf333
movq %r8, %rbx
movb $0x1, 0x100(%r8)
movq 0x8(%rdi), %rdi
callq 0xa7b8
movb $0x0, 0x100(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movb $0x0, 0x100(%rbx)
movq %rax, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf8d0
movq %rdi, %rbx
movq 0x4e70b(%rip), %r13     # 0x5df70
movq (%r15), %rdi
movq 0x8(%r15), %r14
testq %r14, %r14
je 0xf883
cmpb $0x0, (%r13)
je 0xf87e
incl 0x8(%r14)
jmp 0xf883
lock
incl 0x8(%r14)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
cmpb $0x0, 0x68(%rbx)
jne 0xf8b5
cmpq $0x0, 0x8(%rbx)
jne 0xf8b1
testq %r14, %r14
je 0xf8a6
movq %r14, %rdi
callq 0x123fc
addq $0x10, %r15
cmpq %r12, %r15
jne 0xf865
jmp 0xf8d0
movb $0x1, 0x68(%rbx)
testq %r14, %r14
je 0xf8d0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x123fc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0xf8ef
movq %r14, %rdi
callq 0x123fc
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf982
movq %rdi, %rbx
movq 0x4e653(%rip), %r13     # 0x5df70
movq (%r15), %rdi
movq 0x8(%r15), %r14
testq %r14, %r14
je 0xf93b
cmpb $0x0, (%r13)
je 0xf936
incl 0x8(%r14)
jmp 0xf93b
lock
incl 0x8(%r14)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
cmpq $0x0, 0x8(%rbx)
jne 0xf963
testq %r14, %r14
je 0xf958
movq %r14, %rdi
callq 0x123fc
addq $0x10, %r15
cmpq %r12, %r15
jne 0xf91d
jmp 0xf982
movb $0x1, 0x68(%rbx)
testq %r14, %r14
je 0xf982
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x123fc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0xf9a1
movq %r14, %rdi
callq 0x123fc
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3c40e
movq 0x38(%rbx), %rdi
cmpq 0x8(%rdi), %rax
je 0xfe23
popq %rbx
popq %r14
popq %rbp
retq
cmpq $0x0, 0x68(%r14)
je 0xfe1e
leaq 0x40(%r14), %rsi
leaq 0x20(%r14), %rdx
callq 0xd24a
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 0xfe1e
movq (%rax), %rsi
incq %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x82b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1004f
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 0x4c64e(%rip), %r15     # 0x5c6a8
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 0x100ac
leaq -0x48(%rbp), %rsi
movb $0x1, 0x8(%rbx)
movq -0x8(%rsi), %rax
movq %rax, 0x10(%rbx)
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x8170
movq %r15, -0x60(%rbp)
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x100c5
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x82b0
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 0x100ec
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x82b0
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10843
leaq 0x8(%rbx), %r14
movq (%r13), %rdi
movq 0x8(%r13), %r12
testq %r12, %r12
je 0x10818
movq 0x4d76a(%rip), %rax     # 0x5df70
cmpb $0x0, (%rax)
je 0x10812
incl 0x8(%r12)
jmp 0x10818
lock
incl 0x8(%r12)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x3c726
testq %r12, %r12
je 0x1083a
movq %r12, %rdi
callq 0x123fc
addq $0x10, %r13
cmpq %r15, %r13
jne 0x107f2
leaq -0x38(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x40(%rbp), %rsi
leaq -0x29(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0x2f738
movaps -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x40(%rbp)
movq 0x10(%rbx), %rdi
movups %xmm0, 0x8(%rbx)
testq %rdi, %rdi
je 0x1088b
callq 0x123fc
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x1088b
callq 0x123fc
leaq -0x60(%rbp), %rdi
callq 0xbb18
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x108b8
movq %rax, %rbx
testq %r12, %r12
je 0x108b8
movq %r12, %rdi
callq 0x123fc
leaq -0x60(%rbp), %rdi
callq 0xbb18
movq %rbx, %rdi
callq 0x8420
nop