LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/fzbz.cc
// Function: main
int main(int argc, const char** argv) {
  if (argc < 2) {
    cerr << "usage: fzbz [source file path]" << endl;
    return 1;
  }

  ifstream file{argv[1]};
  if (!file) {
    cerr << "can't open the source file." << endl;
    return 2;
  }

  auto source =
      string(istreambuf_iterator<char>(file), istreambuf_iterator<char>());

  auto ast = parse(source, cerr);
  if (!ast) {
    return 3;
  }

  try {
    interpret(*ast);
  } catch (const exception& e) {
    cerr << e.what() << endl;
    return 4;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x270, %rsp            # imm = 0x270
cmpl $0x1, %edi
jg 0xa817
movq 0x5580e(%rip), %rbx     # 0x5ffe0
leaq 0x39e26(%rip), %rsi     # 0x445ff
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x9310
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9280
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9030
movq %rax, %rdi
callq 0x91e0
movl $0x1, %ebx
jmp 0xa932
movq 0x8(%rsi), %rsi
leaq -0x278(%rbp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x9450
movq (%rbx), %rax
movq -0x18(%rax), %rcx
testb $0x5, -0x258(%rbp,%rcx)
je 0xa890
movq 0x55799(%rip), %rbx     # 0x5ffe0
leaq 0x39dd0(%rip), %rsi     # 0x4461e
movl $0x1b, %edx
movq %rbx, %rdi
callq 0x9310
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x9280
movsbl %al, %esi
movq 0x55767(%rip), %rdi     # 0x5ffe0
callq 0x9030
movl $0x2, %ebx
movq %rax, %rdi
callq 0x91e0
jmp 0xa926
movq -0x18(%rax), %rax
movq -0x190(%rbp,%rax), %rsi
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
leaq -0x48(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x4339a
movq 0x5571f(%rip), %rdx     # 0x5ffe0
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x981c
movq -0x28(%rbp), %rsi
testq %rsi, %rsi
je 0xa8fe
leaq -0x70(%rbp), %rdi
callq 0xa621
leaq -0x70(%rbp), %rsi
movzbl 0x20(%rsi), %eax
leaq 0x55201(%rip), %rcx     # 0x5faf0
leaq -0x11(%rbp), %rdi
callq *(%rcx,%rax,8)
movb $-0x1, -0x50(%rbp)
xorl %ebx, %ebx
jmp 0xa903
movl $0x3, %ebx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xa911
callq 0x13612
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0xa926
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x92b0
leaq -0x278(%rbp), %rdi
callq 0x90a0
movl %ebx, %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0xf084
movq %rax, %rbx
cmpl $0x1, %edx
jne 0xa994
movq %rbx, %rdi
callq 0x9110
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x55678(%rip), %rdi     # 0x5ffe0
movq %rax, %rsi
callq 0x9290
movq %rax, %rdi
callq 0x9140
movl $0x4, %ebx
callq 0x93f0
jmp 0xa903
movq %rax, %rbx
jmp 0xa994
movq %rax, %rbx
callq 0x93f0
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xa9a9
callq 0x13612
jmp 0xa9a9
jmp 0xa940
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0xa9c5
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x92b0
jmp 0xa9c5
jmp 0xa9c2
movq %rax, %rbx
leaq -0x278(%rbp), %rdi
callq 0x90a0
movq %rbx, %rdi
callq 0x9420
nop
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Trie::match(char const*, unsigned long, unsigned long&) const
size_t match(const char *text, size_t text_len, size_t &id) const {
    std::string lower_text;
    if (ignore_case_) {
      lower_text = to_lower(text);
      text = lower_text.data();
    }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, -0x90(%rbp)
movq %rdx, -0x48(%rbp)
movq %rsi, %r12
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rdi, -0x40(%rbp)
cmpb $0x1, 0x30(%rdi)
jne 0xb140
leaq -0x68(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %r12, %rsi
callq 0x12808
movq -0x60(%rbp), %rbx
testq %rbx, %rbx
je 0xb0ab
movq -0x68(%rbp), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0x9380
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0xb095
leaq -0xa0(%rbp), %r15
movq %r15, -0x10(%r15)
leaq -0x58(%rbp), %r14
movq -0x10(%r14), %rax
cmpq %r14, %rax
je 0xb0d7
movq %rax, -0xb0(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0xb0df
movups (%r14), %xmm0
movups %xmm0, (%r15)
movq -0x60(%rbp), %rax
leaq -0xb0(%rbp), %rbx
movq %rax, 0x8(%rbx)
movq %r14, -0x68(%rbp)
movq $0x0, -0x60(%rbp)
movb $0x0, -0x58(%rbp)
leaq -0x88(%rbp), %rdi
movq %rbx, %rsi
callq 0x9330
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xb124
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0xb139
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x88(%rbp), %r12
cmpq $0x0, -0x48(%rbp)
je 0xb1ce
movq -0x40(%rbp), %rax
leaq 0x8(%rax), %r13
movl $0x2, %r14d
xorl %r15d, %r15d
movq $0x0, -0x38(%rbp)
leaq -0x1(%r14), %rbx
movq %rbx, -0xb0(%rbp)
movq %r12, -0xa8(%rbp)
movq -0x40(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x128e0
cmpq %r13, %rax
je 0xb1b6
cmpb $0x1, 0x41(%rax)
jne 0xb1a3
movq 0x48(%rax), %rcx
movq -0x90(%rbp), %rdx
movq %rcx, (%rdx)
movq %rbx, -0x38(%rbp)
movzbl %r15b, %r15d
cmpb $0x0, 0x40(%rax)
movl $0x1, %eax
cmovnel %eax, %r15d
jmp 0xb1b9
movb $0x1, %r15b
testb $0x1, %r15b
jne 0xb1d6
leaq 0x1(%r14), %rax
cmpq -0x48(%rbp), %r14
movq %rax, %r14
jbe 0xb164
jmp 0xb1d6
movq $0x0, -0x38(%rbp)
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0xb1f2
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x38(%rbp), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb20a
movq %rax, %rbx
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0xb229
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x92b0
movq %rbx, %rdi
callq 0x9420
nop
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Context::set_error_pos(char const*, char const*)
inline void Context::set_error_pos(const char *a_s, const char *literal) {
  if (log) {
    if (error_info.error_pos <= a_s) {
      if (error_info.error_pos < a_s || !error_info.keep_previous_token) {
        error_info.error_pos = a_s;
        error_info.expected_tokens.clear();
      }

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, 0x258(%rdi)
je 0xb32b
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
cmpq %rsi, 0x18(%rdi)
ja 0xb32b
movq %rdx, %r14
jb 0xb271
cmpb $0x0, 0x88(%r15)
jne 0xb283
movq %rsi, 0x18(%r15)
movq 0x20(%r15), %rax
cmpq %rax, 0x28(%r15)
je 0xb283
movq %rax, 0x28(%r15)
testq %r14, %r14
je 0xb2d6
movq %rbx, -0x30(%rbp)
movq 0xb8(%r15), %rbx
movq 0xc0(%r15), %r13
cmpq %r13, %rbx
je 0xb311
addq $0x8, %rbx
leaq -0x40(%rbp), %r12
movq -0x8(%rbx), %r15
leaq 0x1d0(%r15), %rdi
movq %r15, -0x40(%rbp)
movq %r12, %rsi
callq 0x12a60
cmpb $0x0, 0x1d4(%r15)
jne 0xb314
leaq 0x8(%rbx), %rax
cmpq %r13, %rbx
movq %rax, %rbx
jne 0xb2a7
jmp 0xb314
movq 0xc0(%r15), %rax
cmpq %rax, 0xb8(%r15)
je 0xb33a
movq -0x8(%rax), %rax
movq 0x1c0(%rax), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %r12
testq %r12, %r12
je 0xb348
movq 0x54c6b(%rip), %rax     # 0x5ff70
cmpb $0x0, (%rax)
je 0xb342
incl 0x8(%r12)
jmp 0xb348
xorl %r15d, %r15d
movq %r14, %rax
orq %r15, %rax
movq -0x30(%rbp), %rdi
je 0xb32b
movq %r14, %rsi
movq %r15, %rdx
callq 0x129f8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
jmp 0xb288
lock
incl 0x8(%r12)
leaq 0x53141(%rip), %rax     # 0x5e490
leaq -0x40(%rbp), %rsi
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x38(%rbp), %rax
xorl %r14d, %r14d
testq %rax, %rax
je 0xb377
cmpb $0x0, (%rax)
cmovneq %rax, %r14
testq %r12, %r12
je 0xb288
movq %r12, %rdi
callq 0x13612
jmp 0xb288
movq %rax, %rbx
testq %r12, %r12
je 0xb39d
movq %r12, %rdi
callq 0x13612
movq %rbx, %rdi
callq 0x9420
nop
// File: /workspace/github_cpp_makefile_star2_O1/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Ope::parse(char const*, unsigned long, peg::SemanticValues&, peg::Context&, std::any&) const
inline size_t Ope::parse(const char *s, size_t n, SemanticValues &vs,
                         Context &c, std::any &dt) const {
  if (c.is_traceable(*this)) {
    c.trace_enter(*this, s, n, vs, dt);
    auto len = parse_core(s, n, vs, c, dt);
    c.trace_leave(*this, s, n, vs, dt, len);
    return len;
  }
  return parse_core(s, n, vs, c, dt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r10
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
cmpq $0x0, 0x200(%r8)
je 0xb853
cmpq $0x0, 0x220(%rbx)
je 0xb853
cmpb $0x0, 0x288(%rbx)
jne 0xb853
leaq 0x524ab(%rip), %rsi     # 0x5dce0
leaq 0x524c4(%rip), %rdx     # 0x5dd00
movq %r14, %rdi
xorl %ecx, %ecx
movq %r10, -0x30(%rbp)
callq 0x9300
movq -0x30(%rbp), %r10
testq %rax, %rax
je 0xb87c
movq (%r14), %rax
movq 0x10(%rax), %rax
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
movq %r10, %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq 0x268(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x268(%rbx)
movq %rax, -0x38(%rbp)
movq 0x278(%rbx), %rsi
cmpq 0x280(%rbx), %rsi
je 0xb8b2
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x278(%rbx)
jmp 0xb8c6
leaq 0x270(%rbx), %rdi
leaq -0x38(%rbp), %rdx
callq 0x1367e
movq -0x30(%rbp), %r10
movq %r13, -0x38(%rbp)
movq %r12, -0x48(%rbp)
cmpq $0x0, 0x200(%rbx)
je 0xb96c
leaq 0x1f0(%rbx), %rdi
leaq 0x230(%rbx), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %r14, %rsi
movq %r15, %r8
movq %rbx, %r9
pushq %rax
pushq %r10
callq *0x208(%rbx)
addq $0x10, %rsp
movq (%r14), %rax
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq *0x10(%rax)
leaq 0x210(%rbx), %rdi
subq $0x8, %rsp
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %rbx, %r9
pushq -0x40(%rbp)
movq %rax, %r14
pushq %rax
pushq -0x30(%rbp)
callq 0x137a0
addq $0x20, %rsp
addq $-0x8, 0x278(%rbx)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x90f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbb77
testq %rax, %rax
jne 0xbb96
movq %rdi, %rbx
movq 0x138(%rdi), %rax
cmpq 0x148(%rdi), %rax
jne 0xbbb5
cmpl $0x0, 0x150(%rbx)
jne 0xbbb5
movq 0x290(%rbx), %rdi
testq %rdi, %rdi
je 0xba00
movq 0x2a0(%rbx), %rsi
subq %rdi, %rsi
callq 0x92b0
movq 0x270(%rbx), %rdi
testq %rdi, %rdi
je 0xba1b
movq 0x280(%rbx), %rsi
subq %rdi, %rsi
callq 0x92b0
movq 0x258(%rbx), %rax
testq %rax, %rax
je 0xba38
leaq 0x248(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x230(%rbx), %rax
testq %rax, %rax
je 0xba5e
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 0xba7b
leaq 0x210(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x200(%rbx), %rax
testq %rax, %rax
je 0xba98
leaq 0x1f0(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x1c0(%rbx), %rdi
callq 0x13572
leaq 0x198(%rbx), %rdi
callq 0x13234
leaq 0x170(%rbx), %rdi
callq 0x13234
leaq 0x138(%rbx), %rdi
callq 0x13234
leaq 0x118(%rbx), %rdi
callq 0x12fda
movq 0x110(%rbx), %rdi
testq %rdi, %rdi
je 0xbae5
callq 0x13612
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0xbaf6
callq 0x13612
leaq 0xd0(%rbx), %rdi
callq 0x1302a
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0xbb1d
movq 0xc8(%rbx), %rsi
subq %rdi, %rsi
callq 0x92b0
leaq 0x98(%rbx), %rdi
callq 0x1307a
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0xbb41
movq (%rax), %rsi
incq %rsi
callq 0x92b0
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0xbb59
movq (%rax), %rsi
incq %rsi
callq 0x92b0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xbb72
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x92b0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x38b6a(%rip), %rdi     # 0x446e8
leaq 0x38b30(%rip), %rsi     # 0x446b5
leaq 0x38b6e(%rip), %rcx     # 0x446fa
movl $0x33f, %edx            # imm = 0x33F
callq 0x91b0
leaq 0x38b76(%rip), %rdi     # 0x44713
leaq 0x38b11(%rip), %rsi     # 0x446b5
leaq 0x38b4f(%rip), %rcx     # 0x446fa
movl $0x340, %edx            # imm = 0x340
callq 0x91b0
leaq 0x38b71(%rip), %rdi     # 0x4472d
leaq 0x38af2(%rip), %rsi     # 0x446b5
leaq 0x38b30(%rip), %rcx     # 0x446fa
movl $0x341, %edx            # imm = 0x341
callq 0x91b0
jmp 0xbbe0
jmp 0xbbe0
jmp 0xbbe0
jmp 0xbbe0
jmp 0xbbe0
jmp 0xbbe0
movq %rax, %rdi
callq 0xf084
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb7ee
movq %rax, %r15
decq 0xe8(%rbx)
cmpq $-0x1, %rax
je 0xc2a3
movq %r15, -0x48(%rbp)
movq %r14, -0x40(%rbp)
movq 0x48(%r12), %rsi
cmpq 0x50(%r12), %rsi
je 0xc259
movups -0x48(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x48(%r12)
jmp 0xc267
leaq 0x40(%r12), %rdi
leaq -0x48(%rbp), %rdx
callq 0x3ee52
cmpq $0x0, 0xe8(%rbx)
jne 0xc2a3
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0xc2a3
addq %r15, %r14
subq %r15, %r13
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %rbx, %r8
movq -0x38(%rbp), %r9
callq 0xb7ee
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 0xc2c0
movq %rax, %rdi
jmp 0xc2cf
movq %rax, %rdi
decq 0xe8(%rbx)
movb -0x29(%rbp), %al
movb %al, 0x288(%rbx)
callq 0x9420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3fe06
testq %rax, %rax
jne 0xdd3d
movq 0x20(%rbx), %r12
leaq -0x28(%rbp), %rsi
movq %r15, %rdi
callq 0x3fe92
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_O1/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 0xddb4
movq 0x50(%rsi), %r15
movq 0x58(%rsi), %r12
cmpq %r12, %r15
je 0xddb8
movq 0x521fb(%rip), %r13     # 0x5ff70
movq (%r15), %rdi
movq 0x8(%r15), %r14
testq %r14, %r14
je 0xdd93
cmpb $0x0, (%r13)
je 0xdd8e
incl 0x8(%r14)
jmp 0xdd93
lock
incl 0x8(%r14)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
testq %r14, %r14
je 0xdda9
movq %r14, %rdi
callq 0x13612
addq $0x10, %r15
cmpq %r12, %r15
jne 0xdd75
jmp 0xddb8
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 0xddd7
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::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 0xde5f
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 0xde5f
movq 0x5214e(%rip), %r13     # 0x5ff70
movq (%r15), %rdi
movq 0x8(%r15), %r14
testq %r14, %r14
je 0xde40
cmpb $0x0, (%r13)
je 0xde3b
incl 0x8(%r14)
jmp 0xde40
lock
incl 0x8(%r14)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
testq %r14, %r14
je 0xde56
movq %r14, %rdi
callq 0x13612
addq $0x10, %r15
cmpq %r12, %r15
jne 0xde22
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0xde7e
movq %r14, %rdi
callq 0x13612
movq %rbx, %rdi
callq 0x9420
// File: /workspace/github_cpp_makefile_star2_O1/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 0xdebe
testq %rdx, %rdx
je 0xdf05
movq 0x10(%rbx), %rsi
movq (%r15), %rdi
callq 0x92c0
testl %eax, %eax
je 0xdf05
leaq 0x30(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x40124
testq %rax, %rax
jne 0xdf0d
leaq -0x28(%rbp), %rdx
movq %r12, (%rdx)
movq %r12, %rdi
movq %r15, %rsi
callq 0x3afa6
movq 0x68(%r14), %rax
testq %rax, %rax
je 0xdf0d
movq 0x1c0(%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
cmpb $0x0, 0x68(%rbx)
jne 0xdf0d
jmp 0xdf11
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_O1/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 0xdfa2
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 0xdfc3
movq 0x10(%rbx), %r15
leaq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9170
movb %r12b, 0x8(%rbx)
movq $0x0, 0x20(%rbx)
movq 0x18(%rbx), %rax
movb %r12b, (%rax)
addq $0x10, %r13
cmpq 0x10(%r14), %r13
jne 0xdf5d
movb $0x1, %al
jmp 0xdfa7
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 0x9170
jmp 0xe06f
addq $0x10, %r13
cmpq 0x10(%r14), %r13
je 0xe06f
leaq -0x70(%rbp), %r15
xorl %r12d, %r12d
movups 0x38(%rbx), %xmm0
leaq 0x5077d(%rip), %rax     # 0x5e760
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 0xe03e
movb $0x1, 0x8(%rbx)
movq -0x88(%rbp), %rax
movq %rax, 0x10(%rbx)
movq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x9170
leaq 0x5071b(%rip), %rax     # 0x5e760
movq %rax, -0x98(%rbp)
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0xe061
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x92b0
addq $0x10, %r13
cmpq 0x10(%r14), %r13
jne 0xdfd8
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xe088
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x92b0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe0c1
movq %rax, %rbx
leaq 0x506bd(%rip), %rax     # 0x5e760
movq %rax, -0x98(%rbp)
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0xe0c4
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x92b0
jmp 0xe0c4
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xe0dd
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x92b0
movq %rbx, %rdi
callq 0x9420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40168
movq 0x38(%rbx), %rcx
cmpq 0x8(%rcx), %rax
jne 0xe222
cmpq $0x0, 0x68(%r14)
je 0xe1ca
movq 0x40(%rbx), %rdi
leaq 0x20(%r14), %r15
movq %r15, %rsi
callq 0x402ba
testq %rax, %rax
je 0xe16b
movb 0x28(%rax), %al
movb %al, 0x8(%rbx)
jmp 0xe1ca
movq 0x38(%rbx), %rdi
leaq 0x40(%r14), %rsi
movq %r15, %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 0xe1b7
movq (%rax), %rsi
incq %rsi
callq 0x92b0
movb 0x8(%rbx), %r12b
movq 0x40(%rbx), %rdi
movq %r15, %rsi
callq 0x403c6
movb %r12b, (%rax)
cmpb $0x1, 0x48(%r14)
jne 0xe222
movq 0x50(%r14), %r15
movq 0x58(%r14), %r12
cmpq %r12, %r15
je 0xe222
movq 0x51d8b(%rip), %r13     # 0x5ff70
movq (%r15), %rdi
movq 0x8(%r15), %r14
testq %r14, %r14
je 0xe203
cmpb $0x0, (%r13)
je 0xe1fe
incl 0x8(%r14)
jmp 0xe203
lock
incl 0x8(%r14)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
testq %r14, %r14
je 0xe219
movq %r14, %rdi
callq 0x13612
addq $0x10, %r15
cmpq %r12, %r15
jne 0xe1e5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0xe241
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::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 %rdi, -0x30(%rbp)
movq 0x10(%rdi), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
subq %r12, %r13
movq %rsi, -0x38(%rbp)
je 0xe6bc
sarq $0x5, %r13
movq 0x20(%rsi), %rax
movq %rax, -0x40(%rbp)
cmpq $0x1, %r13
adcq $-0x1, %r13
movq 0x28(%rsi), %r15
addq $0x8, %r12
xorl %r14d, %r14d
xorl %ebx, %ebx
movq (%r12), %rdx
cmpq %r15, %rdx
jne 0xe691
testq %rdx, %rdx
je 0xe695
movq -0x8(%r12), %rdi
movq -0x40(%rbp), %rsi
callq 0x92c0
movq -0x38(%rbp), %rsi
testl %eax, %eax
sete %al
jmp 0xe697
xorl %eax, %eax
jmp 0xe697
movb $0x1, %al
testb %al, %al
je 0xe6a2
movq %rbx, 0x70(%rsi)
movb $0x1, %r14b
cmpq %rbx, %r13
leaq 0x1(%rbx), %rbx
sete %cl
orb %cl, %al
addq $0x20, %r12
cmpb $0x1, %al
jne 0xe66a
testb $0x1, %r14b
jne 0xe6fa
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x20(%rsi), %r15
movq %r15, %rsi
callq 0x40842
movq -0x38(%rbp), %rsi
testq %rax, %rax
je 0xe6fa
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq %r15, %rsi
callq 0x410e0
testq %rax, %rax
je 0xe75e
addq $0x28, %rax
movq -0x38(%rbp), %rsi
movq %rax, 0x68(%rsi)
movq 0x50(%rsi), %rbx
movq 0x58(%rsi), %r15
cmpq %r15, %rbx
movq -0x30(%rbp), %r13
je 0xe74f
movq 0x5185e(%rip), %r12     # 0x5ff70
movq (%rbx), %rdi
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0xe730
cmpb $0x0, (%r12)
je 0xe72b
incl 0x8(%r14)
jmp 0xe730
lock
incl 0x8(%r14)
movq (%rdi), %rax
movq %r13, %rsi
callq *0x18(%rax)
testq %r14, %r14
je 0xe746
movq %r14, %rdi
callq 0x13612
addq $0x10, %rbx
cmpq %r15, %rbx
jne 0xe712
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3691d(%rip), %rdi     # 0x45082
callq 0x9370
movq %rax, %rbx
testq %r14, %r14
je 0xe77a
movq %r14, %rdi
callq 0x13612
movq %rbx, %rdi
callq 0x9420
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq 0x18(%rdi), %rax
movq (%rax), %r15
movq 0x8(%rax), %rsi
subq %r15, %rsi
setne %r13b
je 0xe85c
sarq $0x4, %rsi
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %r14
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0x50(%rbp)
xorl %ecx, %ecx
cmpq $0x1, %rsi
sbbq %rsi, %rcx
movq 0x28(%rax), %rdi
addq $0x8, %r15
addq $0x8, %r14
movl $0x1, %r12d
movq %rsi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq (%r14), %rdx
cmpq %rdi, %rdx
jne 0xe81d
testq %rdx, %rdx
je 0xe83e
movq -0x8(%r14), %rdi
movq -0x50(%rbp), %rsi
movq %rcx, %rbx
callq 0x92c0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rbx, %rcx
testl %eax, %eax
je 0xe83e
cmpq %rsi, %r12
setb %r13b
addq $0x10, %r15
leaq (%rcx,%r12), %rax
incq %rax
incq %r12
addq $0x20, %r14
cmpq $0x1, %rax
jne 0xe7f1
jmp 0xe85c
movq -0x8(%r15), %rax
movq -0x30(%rbp), %rcx
movq %rax, 0x8(%rcx)
leaq 0x10(%rcx), %rdi
movq %r15, %rsi
callq 0x1432c
testb $0x1, %r13b
jne 0xe89f
movq -0x38(%rbp), %rsi
addq $0x8, %rsi
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x41124
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 0xe891
callq 0x13612
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0xe89f
callq 0x13612
addq $0x38, %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: 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, %r12
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xeae7
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
leaq 0x10(%r12), %rsi
movq %r8, -0x38(%rbp)
callq 0x3073a
movq %rax, %rbx
leaq 0x38(%r12), %rsi
leaq -0x58(%rbp), %rdi
movq %rsi, -0x30(%rbp)
callq 0xd1a0
leaq -0x58(%rbp), %rax
movq %rax, (%rsp)
leaq -0xe0(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq %r15, %r8
movq -0x38(%rbp), %r9
callq 0x41fa6
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0xea62
leaq -0x58(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
cmpq $0x0, 0x48(%r12)
je 0xea89
cmpb $0x0, -0xe0(%rbp)
jne 0xea89
leaq -0xd0(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0xd22e
leaq -0x78(%rbp), %rax
movb -0x67(%rax), %bl
xorb $0x1, %bl
andb -0x68(%rax), %bl
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xeaab
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x92b0
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xeaca
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0xc8(%rbp), %rdi
testq %rdi, %rdi
je 0xeae9
movq -0xb8(%rbp), %rsi
subq %rdi, %rsi
callq 0x92b0
jmp 0xeae9
xorl %ebx, %ebx
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 0x38f62
jmp 0xeb2a
jmp 0xeb32
movq %rax, %rbx
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0xeb2a
leaq -0x58(%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/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 0x42e04
movb (%rax), %al
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0xecf8
movq %rbx, %rdi
callq 0x9110
movl $0x10, %edi
callq 0x9150
movq %rax, %r14
leaq 0x3623c(%rip), %rsi     # 0x44f01
movq %rax, %rdi
callq 0x9100
movq 0x5131c(%rip), %rsi     # 0x5fff0
movq 0x51265(%rip), %rdx     # 0x5ff40
movq %r14, %rdi
callq 0x9400
movq %rax, %rbx
jmp 0xecf3
movq %rax, %rbx
movq %r14, %rdi
callq 0x9220
callq 0x93f0
movq %rbx, %rdi
callq 0x9420
movq %rax, %rdi
callq 0xf084
// File: /workspace/github_cpp_makefile_star2_O1/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 0x352b2(%rip), %rcx     # 0x44004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x3bcf0
movq %rax, %r14
movq %rbx, %rdi
callq 0x3bcf0
jmp 0xed7d
callq 0xeddc
movq %rax, %r14
movq %rbx, %rdi
callq 0xeddc
cmpq %rax, %r14
sete %al
jmp 0xedd1
callq 0x3bd6a
movq %rax, %r14
movq %rdx, %r15
movq %rbx, %rdi
callq 0x3bd6a
cmpq %rax, %r14
jne 0xedcb
testq %r14, %r14
je 0xedcf
movq %r15, %rdi
movq %rdx, %rsi
movq %r14, %rdx
callq 0x92c0
testl %eax, %eax
jmp 0xed80
callq 0xec8e
movl %eax, %r14d
movq %rbx, %rdi
callq 0xec8e
xorb %r14b, %al
xorb $0x1, %al
jmp 0xedd1
xorl %eax, %eax
jmp 0xedd1
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3bf1a
leaq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0xee92
addq $0x30, %rax
jmp 0xeea7
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xeebc
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xee58
xorl %ecx, %ecx
testb %cl, %cl
jne 0xeec0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %cl
jmp 0xeea9
movl $0x10, %edi
callq 0x9150
movq %rax, %rbx
movq -0x30(%rbp), %rsi
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x38(%rbp), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0x12846
leaq 0x3603f(%rip), %rsi     # 0x44f2f
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x3be9f
leaq 0x3533a(%rip), %rsi     # 0x44241
leaq -0x98(%rbp), %rdi
callq 0x9480
leaq -0x48(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xef34
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0xef3f
movq %rdx, -0x58(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x48(%rbp)
movq 0x8(%rax), %rdx
leaq -0x58(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %r12b
movq %rbx, %rdi
callq 0x93d0
xorl %r12d, %r12d
movq 0x51081(%rip), %rsi     # 0x5fff0
movq 0x50fca(%rip), %rdx     # 0x5ff40
movq %rbx, %rdi
callq 0x9400
movq %rax, %r14
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0xef9e
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x92b0
jmp 0xef9e
movq %rax, %r14
movb $0x1, %r12b
leaq -0x88(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xefc5
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x92b0
jmp 0xefc5
movq %rax, %r14
movb $0x1, %r12b
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0xefe2
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x92b0
jmp 0xefe2
movq %rax, %r14
movb $0x1, %r12b
testb %r12b, %r12b
je 0xefef
movq %rbx, %rdi
callq 0x9220
movq %r14, %rdi
callq 0x9420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, -0x50(%rbp)
movq %rcx, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
movq %r8, -0x30(%rbp)
movq %r8, %rdi
callq 0x3c696
movq %rax, -0x38(%rbp)
movq 0x8(%rbx), %r12
movq 0x10(%rbx), %r13
cmpq %r13, %r12
sete %r15b
je 0xf165
xorl %ebx, %ebx
movq (%r12), %rdi
leaq (%r14,%rbx), %rsi
movq -0x48(%rbp), %rdx
subq %rbx, %rdx
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x50(%rbp), %r9
callq 0xb7ee
cmpq $-0x1, %rax
movl $0x0, %ecx
cmovneq %rax, %rcx
addq %rcx, %rbx
cmpq $-0x1, %rax
je 0xf167
addq $0x10, %r12
cmpq %r13, %r12
sete %r15b
jne 0xf120
jmp 0xf167
xorl %ebx, %ebx
movq $-0x1, %rax
testb $0x1, %r15b
je 0xf184
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3c82a
movq %rbx, %rax
movq -0x30(%rbp), %rcx
decq 0xb0(%rcx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf1a0
movq -0x30(%rbp), %rcx
decq 0xb0(%rcx)
movq %rax, %rdi
callq 0x9420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, -0x58(%rbp)
movq %r8, %rbx
movq %rcx, -0x38(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %rdi, -0x40(%rbp)
cmpq 0x18(%r14), %r12
jae 0xf562
movq %rbx, %rdi
callq 0x12f02
movq %rbx, %rdi
callq 0x3c696
movq %rax, %r13
movq 0x8(%r14), %rdi
movq -0x48(%rbp), %rax
leaq (%rax,%r15), %rsi
movq -0x50(%rbp), %rdx
subq %r15, %rdx
movq %r13, %rcx
movq %rbx, %r8
movq -0x58(%rbp), %r9
callq 0xb7ee
movq %rax, %r14
cmpq $-0x1, %rax
je 0xf541
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x3c82a
movq %rbx, %rdi
callq 0x3cc40
addq %r14, %r15
incq %r12
jmp 0xf545
movq %r14, -0x30(%rbp)
decq 0x130(%rbx)
decq 0xb0(%rbx)
cmpq $-0x1, %r14
movq -0x40(%rbp), %r14
jne 0xf4e1
jmp 0xf5e4
movq %r15, -0x30(%rbp)
cmpq 0x20(%r14), %r12
jae 0xf5e4
movq %rbx, %rdi
callq 0x12f02
movq %rbx, %rdi
callq 0x3c696
movq %rax, %r13
movq 0x8(%r14), %rdi
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %r15
leaq (%rax,%r15), %rsi
movq -0x50(%rbp), %rdx
subq %r15, %rdx
movq %r13, %rcx
movq %rbx, %r8
movq -0x58(%rbp), %r9
callq 0xb7ee
movq %rax, %r14
cmpq $-0x1, %rax
je 0xf5cc
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x3c82a
movq %rbx, %rdi
callq 0x3cc40
addq %r14, %r15
movq %r15, -0x30(%rbp)
incq %r12
decq 0x130(%rbx)
decq 0xb0(%rbx)
cmpq $-0x1, %r14
movq -0x40(%rbp), %r14
jne 0xf566
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf5f9
movq %rax, %rdi
decq 0x130(%rbx)
decq 0xb0(%rbx)
callq 0x9420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12f02
movq %rbx, %rdi
callq 0x3c696
movq 0x8(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
movq %rbx, %r8
movq %r14, %r9
callq 0xb7ee
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 0x9420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12f02
movq %rbx, %rdi
callq 0x3c696
movq 0x8(%r13), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
movq %rbx, %r8
movq %r15, %r9
callq 0xb7ee
cmpq $-0x1, %rax
je 0xf781
movq $-0x1, %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xb232
jmp 0xf784
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 0x9420
// File: /workspace/github_cpp_makefile_star2_O1/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 0x308d8(%rip), %rax     # 0x5dfa0
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 0x2d80a
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x2d766
xorl %r12d, %r12d
leaq -0x28(%rbp), %r15
leal 0x2(%r12), %ecx
cmpq %rcx, %rax
jbe 0x2d73c
leal 0x1(%r12), %edx
movq -0x48(%rbp), %rax
cmpl $0x2d, (%rax,%rdx,4)
jne 0x2d73c
movl (%rax,%r12,4), %edx
movl (%rax,%rcx,4), %eax
movl %edx, -0x28(%rbp)
movl %eax, -0x24(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2d972
movl $0x3, %eax
jmp 0x2d75a
movq -0x48(%rbp), %rax
movl (%rax,%r12,4), %eax
movl %eax, -0x28(%rbp)
movl %eax, -0x24(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2d972
movl $0x1, %eax
addl %eax, %r12d
movq -0x40(%rbp), %rax
cmpq %r12, %rax
ja 0x2d704
movq 0x18(%rbx), %rax
cmpq 0x20(%rbx), %rax
je 0x2d79b
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d78e
movq -0x38(%rbp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x92b0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1732b(%rip), %rdi     # 0x44acd
leaq 0x16f0c(%rip), %rsi     # 0x446b5
leaq 0x1732e(%rip), %rcx     # 0x44ade
movl $0x4da, %edx            # imm = 0x4DA
callq 0x91b0
movq %rax, %r15
jmp 0x2d7e2
jmp 0x2d7c1
movq %rax, %r15
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d7e2
movq -0x38(%rbp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x92b0
leaq 0x8(%rbx), %r12
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2d7fa
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x92b0
movq %r12, %rdi
callq 0x2d9ac
movq %r15, %rdi
callq 0x9420