LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yhirose[P]fizzbuzzlang/fzbz.cc
// Function: eval_multiplicative(peg::AstBase<peg::EmptyType> const&, std::shared_ptr<Environment>)
Value eval_multiplicative(const Ast& ast, shared_ptr<Environment> env) {
  auto l = eval(*ast.nodes[0], env).get<long>();
  for (size_t i = 1; i < ast.nodes.size(); i += 2) {
    auto r = eval(*ast.nodes[i + 1], env).get<long>();
    l = l % r;
  }
  return Value(l);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdx, -0xc8(%rbp)
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x130c0
movq %rax, %rdi
callq 0x130e0
movq -0xc8(%rbp), %rsi
movq %rax, -0xc0(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x13110
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0xadb0
jmp 0xb382
leaq -0x48(%rbp), %rdi
callq 0x133d0
movq %rax, -0xe0(%rbp)
jmp 0xb394
leaq -0x48(%rbp), %rdi
callq 0x13210
leaq -0x58(%rbp), %rdi
callq 0x13230
movq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
callq 0x134a0
movq %rax, %rcx
movq -0xe8(%rbp), %rax
cmpq %rcx, %rax
jae 0xb4fc
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x130c0
movq %rax, %rdi
callq 0x130e0
movq -0xc8(%rbp), %rsi
movq %rax, -0xf8(%rbp)
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x13110
movq -0xf8(%rbp), %rsi
movq -0xf0(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
callq 0xadb0
jmp 0xb443
leaq -0xa0(%rbp), %rdi
callq 0x133d0
movq %rax, -0x100(%rbp)
jmp 0xb458
leaq -0xa0(%rbp), %rdi
callq 0x13210
leaq -0xb0(%rbp), %rdi
callq 0x13230
movq -0x100(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
cqto
idivq -0x78(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x70(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x70(%rbp)
jmp 0xb3b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xb4bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x13210
leaq -0x58(%rbp), %rdi
callq 0x13230
jmp 0xb51c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xb4ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x13210
leaq -0xb0(%rbp), %rdi
callq 0x13230
jmp 0xb51c
movq -0xd8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x134c0
movq -0xd0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
// File: yhirose[P]fizzbuzzlang/fzbz.cc
// Function: interpret(peg::AstBase<peg::EmptyType> const&)
Value interpret(const Ast& ast) {
  auto env = make_shared<Environment>();

  env->set_value("puts", Value(Function([](auto& val) {
                   cout << val.str() << endl;
                   return Value();
                 })));

  return eval(ast, env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x13a00
movq -0xb8(%rbp), %rdi
callq 0x134f0
movq %rax, -0xb0(%rbp)
leaq 0x96148(%rip), %rsi     # 0xa1bd6
leaq -0x30(%rbp), %rdi
callq 0x12a80
leaq -0x78(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x79(%rbp), %rsi
callq 0xbbc0
movq -0xa8(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x13a70
jmp 0xbabd
movq -0xb0(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x58(%rbp), %rcx
callq 0x13910
jmp 0xbad7
leaq -0x58(%rbp), %rdi
callq 0x13210
leaq -0x78(%rbp), %rdi
callq 0x13880
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x13110
movq -0xc8(%rbp), %rdi
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
callq 0xadb0
jmp 0xbb27
leaq -0xa0(%rbp), %rdi
callq 0x13230
leaq -0x20(%rbp), %rdi
callq 0x13230
movq -0xc0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xbb7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x13210
leaq -0x78(%rbp), %rdi
callq 0x13880
jmp 0xbba4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x13230
leaq -0x20(%rbp), %rdi
callq 0x13230
movq -0x88(%rbp), %rdi
callq 0xa650
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x48(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1e580
testb $0x1, %al
jne 0xdb27
jmp 0xdb95
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0x1e630
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x48(%rbp), %rsi
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x38(%rbp), %r9
movq -0x40(%rbp), %rax
movq %rax, (%rsp)
callq 0x1e6d0
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xdbb7
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1f020
jmp 0xdc4b
movq -0x10(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xdc62
jmp 0xdc64
jmp 0xdc83
leaq 0x94059(%rip), %rdi     # 0xa1cc4
leaq 0x9401f(%rip), %rsi     # 0xa1c91
movl $0x33f, %edx            # imm = 0x33F
leaq 0x94058(%rip), %rcx     # 0xa1cd6
callq 0xa290
movq -0x10(%rbp), %rax
cmpq $0x0, 0x130(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xdc9a
jmp 0xdc9c
jmp 0xdcbb
leaq 0x9404c(%rip), %rdi     # 0xa1cef
leaq 0x93fe7(%rip), %rsi     # 0xa1c91
movl $0x340, %edx            # imm = 0x340
leaq 0x94020(%rip), %rcx     # 0xa1cd6
callq 0xa290
movq -0x10(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x10e60
testb $0x1, %al
jne 0xdcd1
jmp 0xdcd3
jmp 0xdcf2
leaq 0x9402f(%rip), %rdi     # 0xa1d09
leaq 0x93fb0(%rip), %rsi     # 0xa1c91
movl $0x341, %edx            # imm = 0x341
leaq 0x93fe9(%rip), %rcx     # 0xa1cd6
callq 0xa290
movq -0x10(%rbp), %rdi
addq $0x290, %rdi            # imm = 0x290
callq 0x1b5a0
movq -0x10(%rbp), %rdi
addq $0x270, %rdi            # imm = 0x270
callq 0x1b5a0
movq -0x10(%rbp), %rdi
addq $0x248, %rdi            # imm = 0x248
callq 0xd9d0
movq -0x10(%rbp), %rdi
addq $0x230, %rdi            # imm = 0x230
callq 0xd9f0
movq -0x10(%rbp), %rdi
addq $0x210, %rdi            # imm = 0x210
callq 0xda10
movq -0x10(%rbp), %rdi
addq $0x1f0, %rdi            # imm = 0x1F0
callq 0xda30
movq -0x10(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x1b600
movq -0x10(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0x1b620
movq -0x10(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
callq 0x1b620
movq -0x10(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x1b620
movq -0x10(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x1b640
movq -0x10(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0xda50
movq -0x10(%rbp), %rdi
addq $0xf0, %rdi
callq 0xda50
movq -0x10(%rbp), %rdi
addq $0xd0, %rdi
callq 0x1b6a0
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
callq 0x1b700
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
callq 0x1b760
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x1b7c0
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x13bd0
nopl (%rax)
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::ErrorInfo::clear()
void clear() {
    error_pos = nullptr;
    expected_tokens.clear();
    message_pos = nullptr;
    message.clear();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq $0x0, (%rdi)
addq $0x8, %rdi
callq 0x196c0
movq -0x10(%rbp), %rdi
movq $0x0, 0x20(%rdi)
addq $0x28, %rdi
callq 0xa4e0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
addq $0x8, %rdi
leaq -0x18(%rbp), %rsi
callq 0x113a0
cmpq $0x0, %rax
je 0x11339
jmp 0x11394
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x113d0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
leaq -0x18(%rbp), %rsi
callq 0x113f0
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xded0
movq -0x28(%rbp), %rsi
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x48(%rax)
je 0x114e0
movq -0x10(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf870
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf8a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xf8d0
testb $0x1, %al
jne 0x1147f
jmp 0x114de
leaq -0x20(%rbp), %rdi
callq 0xf910
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xf930
movq -0x58(%rbp), %rdi
callq 0xded0
movq -0x50(%rbp), %rsi
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x114b3
leaq -0x38(%rbp), %rdi
callq 0xda50
leaq -0x20(%rbp), %rdi
callq 0xf9e0
jmp 0x1146c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xda50
jmp 0x114ee
jmp 0x114e8
movq -0x50(%rbp), %rax
movb $0x1, 0x9(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xa650
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x48(%rax)
je 0x115d1
movq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x115e0
movq -0x10(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf870
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf8a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xf8d0
testb $0x1, %al
jne 0x11570
jmp 0x115cf
leaq -0x20(%rbp), %rdi
callq 0xf910
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xf930
movq -0x58(%rbp), %rdi
callq 0xded0
movq -0x50(%rbp), %rsi
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x115a4
leaq -0x38(%rbp), %rdi
callq 0xda50
leaq -0x20(%rbp), %rdi
callq 0xf9e0
jmp 0x1155d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xda50
jmp 0x115d7
jmp 0x115d1
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xa650
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
addq $0x10, %rsi
callq 0x116e0
testb $0x1, %al
jne 0x1164f
jmp 0x11661
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x116cd
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x11770
cmpq $0x0, %rax
jne 0x116cb
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x117a0
movq %rax, -0x20(%rbp)
movb %dl, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x116c9
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x115e0
movq -0x28(%rbp), %rax
movb 0x68(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x116c7
jmp 0x116d5
jmp 0x116c9
jmp 0x116cb
jmp 0x116cd
movq -0x28(%rbp), %rax
movb $0x1, 0x68(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x0, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x70(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq 0x10(%rax), %rdi
callq 0x126f0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x127a6
movq -0x70(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x128a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x116e0
testb $0x1, %al
jne 0x12784
jmp 0x12796
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
movb $0x1, -0x11(%rbp)
jmp 0x127a6
jmp 0x12798
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x12737
testb $0x1, -0x11(%rbp)
jne 0x127ec
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x12610
cmpq $0x0, %rax
je 0x127ec
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x128c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xf870
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xf8a0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xf8d0
testb $0x1, %al
jne 0x12825
jmp 0x12884
leaq -0x40(%rbp), %rdi
callq 0xf910
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xf930
movq -0x80(%rbp), %rdi
callq 0xded0
movq -0x70(%rbp), %rsi
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x12859
leaq -0x58(%rbp), %rdi
callq 0xda50
leaq -0x40(%rbp), %rdi
callq 0xf9e0
jmp 0x12812
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xda50
jmp 0x1288d
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq 0x18(%rax), %rdi
callq 0x126d0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x12990
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x128a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x116e0
testb $0x1, %al
jne 0x1295d
jmp 0x12980
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xfbd0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rdi
callq 0x129d0
jmp 0x129bb
jmp 0x12982
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x12910
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
callq 0x12a00
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x12a30
leaq -0x30(%rbp), %rdi
callq 0x12a60
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x21f40
testb $0x1, %al
jne 0x12d6c
jmp 0x12eaa
movq -0xf8(%rbp), %rdi
callq 0x4f200
movq -0xf8(%rbp), %rsi
movq %rax, %rdi
addq $0x10, %rsi
callq 0x4f230
movq -0xf8(%rbp), %rsi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x108(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x100(%rbp)
addq $0x38, %rsi
leaq -0xe0(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x10520
movq -0x128(%rbp), %rdi
movq -0x120(%rbp), %rsi
movq -0x118(%rbp), %rdx
movq -0x110(%rbp), %rcx
movq -0x108(%rbp), %r8
movq -0x100(%rbp), %r9
movq %rsp, %rax
movq %rdi, (%rax)
leaq -0xc0(%rbp), %rdi
callq 0x9d320
jmp 0x12e22
leaq -0xe0(%rbp), %rdi
callq 0xd9d0
movq -0xf8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
callq 0x9d560
movb %al, -0x129(%rbp)
jmp 0x12e51
movb -0x129(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x77af0
jmp 0x12eae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0xd9d0
jmp 0x12ebc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x77af0
jmp 0x12ebc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0xe8(%rbp), %rdi
callq 0xa650
nopl (%rax,%rax)
// File: yhirose[P]fizzbuzzlang/fzbz.cc
// Function: std::function<Value (Value const&)> Value::get<std::function<Value (Value const&)>>() 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
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9f310
movq %rax, -0x30(%rbp)
jmp 0x1376a
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x82190
jmp 0x13779
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1380f
movq -0x18(%rbp), %rdi
callq 0xa160
movq %rax, -0x28(%rbp)
movl $0x10, %edi
callq 0xa1d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x8ed1a(%rip), %rsi     # 0xa24dd
callq 0xa150
jmp 0x137ca
movq -0x48(%rbp), %rdi
movq 0xe181b(%rip), %rsi     # 0xf4ff0
movq 0xe1774(%rip), %rdx     # 0xf4f50
callq 0xa620
jmp 0x13820
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xa300
jmp 0x13806
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xa600
jmp 0x1380d
jmp 0x1380f
movq -0x18(%rbp), %rdi
callq 0xa650
movq %rax, %rdi
callq 0x13bd0
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x80f60
movq %rax, %rcx
movq %rcx, -0x40(%rbp)
subq $0x3, %rax
ja 0x13388
movq -0x40(%rbp), %rax
leaq 0x8dd4b(%rip), %rcx     # 0xa1004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x48(%rbp), %rdi
callq 0x82380
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x82380
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1338a
movq -0x48(%rbp), %rdi
callq 0x13140
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13140
movb %al, %cl
movl -0x54(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1338a
movq -0x48(%rbp), %rdi
callq 0x133d0
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x133d0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1338a
movq -0x48(%rbp), %rdi
callq 0x824c0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x824c0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x82440
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1338a
ud2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0xd0, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
addq $0x10, %rdi
leaq -0x18(%rbp), %rsi
callq 0x82c10
movq -0xc0(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x10, %rdi
callq 0x82c70
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x82c40
testb $0x1, %al
jne 0x1356a
jmp 0x13580
leaq -0x28(%rbp), %rdi
callq 0x82ca0
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x13705
movq -0xc0(%rbp), %rdi
callq 0x82cc0
testb $0x1, %al
jne 0x13592
jmp 0x135c7
movq -0xc0(%rbp), %rdi
callq 0x134f0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x13510
movq %rax, -0x8(%rbp)
jmp 0x13705
jmp 0x135c9
movb $0x1, -0xb5(%rbp)
movl $0x10, %edi
callq 0xa1d0
movq %rax, -0xd0(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xa660
movq -0xc8(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x25050
jmp 0x1360d
leaq 0x8ef16(%rip), %rsi     # 0xa252a
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rdx
callq 0x82ce0
jmp 0x13626
leaq 0x8e1f0(%rip), %rdx     # 0xa181d
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xffe0
jmp 0x1363c
movq -0xd0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xa5e0
jmp 0x1364e
movq -0xd0(%rbp), %rdi
movb $0x0, -0xb5(%rbp)
movq 0xe198d(%rip), %rsi     # 0xf4ff0
movq 0xe18e6(%rip), %rdx     # 0xf4f50
callq 0xa620
jmp 0x1371e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x136e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x136d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x136cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xa250
leaq -0x80(%rbp), %rdi
callq 0xa250
leaq -0xa0(%rbp), %rdi
callq 0xa250
leaq -0xa1(%rbp), %rdi
callq 0xa410
testb $0x1, -0xb5(%rbp)
jne 0x136f7
jmp 0x13703
movq -0xd0(%rbp), %rdi
callq 0xa300
jmp 0x13712
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0xa650
nop
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x30(%rbp), %rdi
callq 0x862c0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x864c0
movq -0xa0(%rbp), %rax
movq $0x0, -0x60(%rbp)
addq $0x8, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0xf870
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0xf8a0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xf8d0
testb $0x1, %al
jne 0x13ce7
jmp 0x13d9d
leaq -0x70(%rbp), %rdi
callq 0xf910
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
callq 0xded0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x60(%rbp), %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
subq %rax, %rdx
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0xdaf0
movq %rax, -0xa8(%rbp)
jmp 0x13d2c
movq -0xa8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
callq 0xdbd0
testb $0x1, %al
jne 0x13d4c
jmp 0x13d80
movq -0x88(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x98(%rbp)
jmp 0x13dbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x86640
jmp 0x13dd4
movq -0x88(%rbp), %rax
addq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xf9e0
jmp 0x13cd1
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x864e0
jmp 0x13dac
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x98(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x86640
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0xa650
// File: 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
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x30(%rbp), %rdi
callq 0x881d0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x89d30
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
callq 0xded0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0xdaf0
movq %rax, -0x78(%rbp)
jmp 0x145ac
movq -0x78(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0xe9a0
testb $0x1, %al
jne 0x145c3
jmp 0x145eb
movq $0x0, -0x8(%rbp)
movl $0x1, -0x70(%rbp)
jmp 0x145fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x89d50
jmp 0x14610
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x70(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x89d50
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0xa650
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x30(%rbp), %rdi
callq 0x881d0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x89db0
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
callq 0xded0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0xdaf0
movq %rax, -0x78(%rbp)
jmp 0x146cc
movq -0x78(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0xe9a0
testb $0x1, %al
jne 0x146e3
jmp 0x1471e
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xd050
jmp 0x146f6
movq $-0x1, -0x8(%rbp)
movl $0x1, -0x70(%rbp)
jmp 0x1472d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x89dd0
jmp 0x14743
movq $0x0, -0x8(%rbp)
movl $0x1, -0x70(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x89dd0
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0xa650
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x1, -0x20(%rbp)
jae 0x1497d
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xd050
movq $-0x1, -0x8(%rbp)
jmp 0x14a61
movl $0x0, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0x48b30
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x48(%rbp)
addq $0x18, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x49a30
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x49a60
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4a540
testb $0x1, %al
jne 0x149d5
jmp 0x14a34
leaq -0x58(%rbp), %rdi
callq 0x4a580
movq -0x70(%rbp), %rdi
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
movl -0x3c(%rbp), %edx
callq 0x89e50
testb $0x1, %al
jne 0x149f8
jmp 0x14a27
movq -0x70(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0x14a1d
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xd050
movq $-0x1, -0x8(%rbp)
jmp 0x14a61
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14a61
jmp 0x14a29
leaq -0x58(%rbp), %rdi
callq 0x4a5a0
jmp 0x149c2
movq -0x70(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0x14a48
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14a61
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xd050
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x1, -0x20(%rbp)
jae 0x14b1a
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xd050
movq $-0x1, -0x8(%rbp)
jmp 0x14b65
movl $0x0, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0x48b30
movq -0x50(%rbp), %rcx
movq %rax, -0x48(%rbp)
movl -0x3c(%rbp), %eax
cmpl 0x18(%rcx), %eax
je 0x14b5d
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xd050
movq $-0x1, -0x8(%rbp)
jmp 0x14b65
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rax
testb $0x1, 0x100(%rax)
je 0x153af
movq $0x0, -0x8(%rbp)
jmp 0x15428
movq -0x30(%rbp), %rax
movb $0x1, 0x100(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8a360
movq -0x68(%rbp), %rdi
addq $0x8, %rdi
callq 0xded0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0xdaf0
movq %rax, -0x70(%rbp)
jmp 0x153fe
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8a380
jmp 0x15428
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8a380
jmp 0x15432
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xa650
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11a20
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11a90
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x11a50
testb $0x1, %al
jne 0x15dc4
jmp 0x15e6b
leaq -0x20(%rbp), %rdi
callq 0x11ac0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xf930
movq -0x58(%rbp), %rdi
callq 0xded0
movq -0x50(%rbp), %rsi
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x15df8
movq -0x50(%rbp), %rax
testb $0x1, 0x68(%rax)
je 0x15e22
movl $0x2, -0x48(%rbp)
jmp 0x15e47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xda50
jmp 0x15e71
movq -0x50(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x15e3e
movq -0x50(%rbp), %rax
movb $0x1, 0x68(%rax)
movl $0x2, -0x48(%rbp)
jmp 0x15e47
jmp 0x15e40
movl $0x0, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xda50
movl -0x48(%rbp), %eax
testl %eax, %eax
je 0x15e5b
jmp 0x15e59
jmp 0x15e6b
jmp 0x15e5d
leaq -0x20(%rbp), %rdi
callq 0x11ae0
jmp 0x15dae
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xa650
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11a20
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11a90
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x11a50
testb $0x1, %al
jne 0x15ed4
jmp 0x15f66
leaq -0x20(%rbp), %rdi
callq 0x11ac0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xf930
movq -0x58(%rbp), %rdi
callq 0xded0
movq -0x50(%rbp), %rsi
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x15f08
movq -0x50(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x15f3b
movq -0x50(%rbp), %rax
movb $0x1, 0x68(%rax)
movl $0x2, -0x48(%rbp)
jmp 0x15f42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xda50
jmp 0x15f6c
movl $0x0, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xda50
movl -0x48(%rbp), %eax
testl %eax, %eax
je 0x15f56
jmp 0x15f54
jmp 0x15f66
jmp 0x15f58
leaq -0x20(%rbp), %rdi
callq 0x11ae0
jmp 0x15ebe
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
nop
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::HasEmptyElement::visit(peg::Repetition&)
void visit(Repetition &ope) override {
    if (ope.min_ == 0) {
      set_error();
    } else {
      ope.ope_->accept(*this);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1657e
movq -0x18(%rbp), %rdi
callq 0x8eae0
jmp 0x16598
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xded0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x38(%rax), %rdi
callq 0x11e50
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x38(%rax), %rdi
callq 0x11e80
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x8ee20
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x38(%rax), %rdi
callq 0x11e80
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x11eb0
testb $0x1, %al
jne 0x1685d
jmp 0x1685f
jmp 0x168a5
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x168a5
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
movq -0x10(%rbp), %rdx
addq $0x20, %rdx
callq 0x11fb0
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x115e0
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x12030
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x70(%rbp)
callq 0x3f720
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jne 0x16c3d
movq -0x78(%rbp), %rax
movq 0x38(%rax), %rsi
movq 0x40(%rax), %rdx
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x8f210
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xded0
movq -0x80(%rbp), %rsi
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x16bf4
testb $0x1, -0x50(%rbp)
je 0x16c32
movq -0x78(%rbp), %rdi
movb $0x1, 0x8(%rdi)
movq -0x48(%rbp), %rax
movq %rax, 0x10(%rdi)
leaq -0x40(%rbp), %rsi
addq $0x18, %rdi
callq 0xa040
jmp 0x16c19
jmp 0x16c32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x163f0
jmp 0x16c60
leaq -0x58(%rbp), %rdi
callq 0x163f0
jmp 0x16c57
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xded0
movq -0x78(%rbp), %rsi
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xa650
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xf850
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x11a20
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x11a90
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x11a50
testb $0x1, %al
jne 0x17a5d
jmp 0x17acf
leaq -0x38(%rbp), %rdi
callq 0x11ac0
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xf930
movq -0x80(%rbp), %rdi
callq 0xded0
movq -0x78(%rbp), %rsi
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x17a91
movq -0x78(%rbp), %rsi
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
callq 0x8fc50
jmp 0x17aa4
leaq -0x50(%rbp), %rdi
callq 0xda50
leaq -0x38(%rbp), %rdi
callq 0x11ae0
jmp 0x17a4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xda50
jmp 0x17b16
leaq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x57250
jmp 0x17ade
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
leaq -0x70(%rbp), %rsi
callq 0x8fcc0
leaq -0x70(%rbp), %rdi
callq 0x3e620
leaq -0x28(%rbp), %rdi
callq 0xfad0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xfad0
movq -0x58(%rbp), %rdi
callq 0xa650
nopl (%rax,%rax)
// File: yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::FindReference::visit(peg::PrioritizedChoice&)
void visit(PrioritizedChoice &ope) override {
    std::vector<std::shared_ptr<Ope>> opes;
    for (auto o : ope.opes_) {
      o->accept(*this);
      opes.push_back(found_ope);
    }
    found_ope = std::make_shared<PrioritizedChoice>(opes);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xf850
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x11a20
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x11a90
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x11a50
testb $0x1, %al
jne 0x17b8d
jmp 0x17bff
leaq -0x38(%rbp), %rdi
callq 0x11ac0
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xf930
movq -0x80(%rbp), %rdi
callq 0xded0
movq -0x78(%rbp), %rsi
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x17bc1
movq -0x78(%rbp), %rsi
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
callq 0x8fc50
jmp 0x17bd4
leaq -0x50(%rbp), %rdi
callq 0xda50
leaq -0x38(%rbp), %rdi
callq 0x11ae0
jmp 0x17b7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xda50
jmp 0x17c46
leaq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x56580
jmp 0x17c0e
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
leaq -0x70(%rbp), %rsi
callq 0x90320
leaq -0x70(%rbp), %rdi
callq 0x40ee0
leaq -0x28(%rbp), %rdi
callq 0xfad0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xfad0
movq -0x58(%rbp), %rdi
callq 0xa650
nopl (%rax,%rax)