LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::HasEmptyElement::visit(peg::Reference&)
inline void HasEmptyElement::visit(Reference &ope) {
  auto it = std::find_if(refs_.begin(), refs_.end(),
                         [&](const std::pair<const char *, std::string> &ref) {
                           return ope.name_ == ref.second;
                         });
  if (it != refs_.end()) { return; }

  if (ope.rule_) {
    refs_.emplace_back(ope.s_, ope.name_);
    ope.rule_->accept(*this);
    refs_.pop_back();
  }
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpq $-0x1, 0x20(%rsi)
je 0xeda1
movq 0x8(%rsi), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
movq %rbx, %rsi
addq $0x48, %rsp
popq %rbx
popq %rbp
jmpq *%rax
movups 0x38(%rbx), %xmm0
leaq 0x4c8c4(%rip), %rax     # 0x5b670
leaq -0x28(%rbp), %rcx
movq %rax, -0x28(%rcx)
xorl %eax, %eax
movb %al, -0x20(%rcx)
andq $0x0, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb %al, (%rcx)
movups %xmm0, 0x10(%rcx)
movq 0x8(%rsi), %rdi
movq (%rdi), %rax
leaq -0x50(%rbp), %rsi
callq *0x18(%rax)
cmpb $0x1, -0x48(%rbp)
jne 0xedfd
leaq -0x38(%rbp), %rsi
movb $0x1, 0x8(%rbx)
movq -0x8(%rsi), %rax
movq %rax, 0x10(%rbx)
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x9190
leaq -0x50(%rbp), %rdi
callq 0xe9fa
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xe9fa
movq %rbx, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::FindReference::visit(peg::Sequence&)
void visit(Sequence &ope) override {
    std::vector<std::shared_ptr<Ope>> opes;
    for (auto o : ope.opes_) {
      o->accept(*this);
      opes.push_back(found_ope);
    }
    found_ope = std::make_shared<Sequence>(opes);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq 0x8(%rsi), %r13
movq 0x10(%rsi), %r15
leaq 0x8(%rdi), %rbx
leaq -0x38(%rbp), %r12
cmpq %r15, %r13
je 0xf4d9
movq %r12, %rdi
movq %r13, %rsi
callq 0x117ce
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
leaq -0x50(%rbp), %rdi
movq %rbx, %rsi
callq 0x33700
leaq -0x30(%rbp), %rdi
callq 0x1106c
addq $0x10, %r13
jmp 0xf4a1
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x26580
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x338a8
leaq -0x30(%rbp), %rdi
callq 0x1106c
leaq -0x50(%rbp), %rdi
callq 0xbb2a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xf524
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x1106c
leaq -0x50(%rbp), %rdi
callq 0xbb2a
movq %rbx, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::FindReference::visit(peg::PrioritizedChoice&)
void visit(PrioritizedChoice &ope) override {
    std::vector<std::shared_ptr<Ope>> opes;
    for (auto o : ope.opes_) {
      o->accept(*this);
      opes.push_back(found_ope);
    }
    found_ope = std::make_shared<PrioritizedChoice>(opes);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq 0x8(%rsi), %r13
movq 0x10(%rsi), %r15
leaq 0x8(%rdi), %rbx
leaq -0x38(%rbp), %r12
cmpq %r15, %r13
je 0xf5a1
movq %r12, %rdi
movq %r13, %rsi
callq 0x117ce
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
leaq -0x50(%rbp), %rdi
movq %rbx, %rsi
callq 0x33700
leaq -0x30(%rbp), %rdi
callq 0x1106c
addq $0x10, %r13
jmp 0xf569
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x26223
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x338e2
leaq -0x30(%rbp), %rdi
callq 0x1106c
leaq -0x50(%rbp), %rdi
callq 0xbb2a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xf5ec
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x1106c
leaq -0x50(%rbp), %rdi
callq 0xbb2a
movq %rbx, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::AssignIDToDefinition::visit(peg::Reference&)
inline void AssignIDToDefinition::visit(Reference &ope) {
  if (ope.rule_) {
    for (auto arg : ope.args_) {
      arg->accept(*this);
    }
    ope.rule_->accept(*this);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, 0x68(%rsi)
je 0xfda6
movq %rdi, %rbx
movq 0x50(%rsi), %r12
movq %rsi, -0x30(%rbp)
movq 0x58(%rsi), %r14
leaq -0x38(%rbp), %r15
leaq -0x40(%rbp), %r13
cmpq %r14, %r12
je 0xfd8e
movq %r13, %rdi
movq %r12, %rsi
callq 0x117ce
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq %r15, %rdi
callq 0x1106c
addq $0x10, %r12
jmp 0xfd63
movq -0x30(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x1c0(%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x1106c
movq %rbx, %rdi
callq 0x9430
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::AnyCharacter::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 len = codepoint_length(s, n);
    if (len < 1) {
      c.set_error_pos(s);
      return static_cast<size_t>(-1);
    }
    return len;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rsi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x11d84
testq %rax, %rax
jne 0xfe85
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xa79a
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Definition::is_token() const::'lambda'()::operator()() const
bool is_token() const {
    std::call_once(is_token_init_, [this]() {
      is_token_ = TokenChecker::is_token(*get_core_operator());
    });
    return is_token_;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rbx
leaq -0x20(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x101ac
movq (%r14), %rdi
callq 0x10384
movb %al, 0x1d4(%rbx)
leaq -0x18(%rbp), %rdi
callq 0x1106c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x18(%rbp), %rdi
callq 0x1106c
movq %rbx, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::TokenChecker::is_token(peg::Ope&)
static bool is_token(Ope &ope) {
    if (IsLiteralToken::check(ope)) { return true; }

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x130(%rdi), %rsi
addq $0x118, %rdi            # imm = 0x118
movq 0x118(%rbx), %rcx
movq 0x120(%rbx), %rax
subq %rcx, %rax
pushq $0x30
popq %r8
cqto
idivq %r8
cmpq %rax, %rsi
ja 0x1082b
jne 0x10806
leaq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x40(%rbp), %rsi
callq 0x10b18
leaq -0x40(%rbp), %rdi
callq 0x10dc0
jmp 0x1081d
imulq $0x30, %rsi, %rax
cmpq $0x0, 0x28(%rcx,%rax)
je 0x1081d
addq %rax, %rcx
movq %rcx, %rdi
callq 0x10e3c
incq 0x130(%rbx)
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
leaq 0x28e4c(%rip), %rdi     # 0x3967e
leaq 0x28e7c(%rip), %rsi     # 0x396b5
leaq 0x28e80(%rip), %rcx     # 0x396c0
movl $0x398, %edx            # imm = 0x398
callq 0x91d0
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x10dc0
movq %rbx, %rdi
callq 0x9430
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Context::is_traceable(peg::Ope const&) const
inline bool Context::is_traceable(const Ope &ope) const {
  if (tracer_enter && tracer_leave) {
    if (ignore_trace_state) { return false; }
    return !dynamic_cast<const peg::Reference *>(&ope);
  }
  return false;
}

// Assembly:
xorl %eax, %eax
cmpq $0x0, 0x200(%rdi)
je 0x11189
cmpq $0x0, 0x220(%rdi)
je 0x11189
cmpb $0x0, 0x288(%rdi)
je 0x1118a
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x49b4b(%rip), %rax     # 0x5ace0
leaq 0x49b64(%rip), %rdx     # 0x5ad00
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x92f0
testq %rax, %rax
sete %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::line_info(char const*, char const*)
inline std::pair<size_t, size_t> line_info(const char *start, const char *cur) {
  auto p = start;
  auto col_ptr = p;
  auto no = 1;

  while (p < cur) {
    if (*p == '\n') {
      no++;
      col_ptr = p + 1;
    }
    p++;
  }

  auto col = codepoint_count(col_ptr, p - col_ptr) + 1;

  return std::pair(no, col);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rax
pushq $0x1
popq %rbx
movq %rdi, %rcx
cmpq %rsi, %rcx
jae 0x11c25
xorl %edx, %edx
cmpb $0xa, (%rcx)
leaq 0x1(%rcx), %rcx
cmoveq %rcx, %rdi
sete %dl
addl %edx, %ebx
incq %rax
jmp 0x11c09
subq %rdi, %rax
movq %rax, %rsi
callq 0x11e3d
leaq 0x1(%rax), %rdx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::ErrorInfo::heuristic_error_token[abi:cxx11](char const*, unsigned long, char const*) const
std::string heuristic_error_token(const char *s, size_t n,
                                    const char *pos) const {
    auto len = n - std::distance(s, pos);
    if (len) {
      size_t i = 0;
      auto c = cast_char(pos[i++]);
      if (!std::ispunct(c) && !std::isspace(c)) {
        while (i < len && !std::ispunct(cast_char(pos[i])) &&
               !std::isspace(cast_char(pos[i]))) {
          i++;
        }
      }

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdi, %rbx
movq %r8, %rax
subq %rdx, %rax
subq %rax, %r15
jne 0x11c72
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x11d08
movq %r8, %r14
movzbl (%r8), %r12d
movl %r12d, %edi
callq 0x94b0
pushq $0x1
popq %r13
testl %eax, %eax
jne 0x11cd5
movl %r12d, %edi
callq 0x9040
testl %eax, %eax
jne 0x11cd5
movq %rbx, -0x30(%rbp)
cmpq $0x1, %r15
movq %r15, %r13
adcq $0x0, %r13
pushq $0x1
popq %rbx
cmpq %r15, %rbx
jae 0x11cd1
movzbl (%r14,%rbx), %r12d
movl %r12d, %edi
callq 0x94b0
testl %eax, %eax
jne 0x11cce
movl %r12d, %edi
callq 0x9040
testl %eax, %eax
jne 0x11cce
incq %rbx
jmp 0x11ca7
movq %rbx, %r13
movq -0x30(%rbp), %rbx
pushq $-0x20
popq %r12
xorl %r15d, %r15d
testq %r12, %r12
je 0x11cfa
movq %r13, %rsi
subq %r15, %rsi
jbe 0x11cfa
leaq (%r14,%r15), %rdi
callq 0x11d84
addq %rax, %r15
incq %r12
jmp 0x11cdc
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x11e7d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::ErrorInfo::replace_all(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::string replace_all(std::string str, const std::string &from,
                          const std::string &to) const {
    size_t pos = 0;
    while ((pos = str.find(from, pos)) != std::string::npos) {
      str.replace(pos, from.length(), to);
      pos += to.length();
    }
    return str;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x94d0
cmpq $-0x1, %rax
je 0x11d67
movq %rax, %r13
movq 0x8(%r12), %rdx
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rcx
callq 0x90e0
addq 0x8(%r15), %r13
jmp 0x11d37
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9330
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::codepoint_length(char const*, unsigned long)
inline size_t codepoint_length(const char *s8, size_t l) {
  if (l) {
    auto b = static_cast<uint8_t>(s8[0]);
    if ((b & 0x80) == 0) {
      return 1;
    } else if ((b & 0xE0) == 0xC0 && l >= 2) {
      return 2;
    } else if ((b & 0xF0) == 0xE0 && l >= 3) {
      return 3;
    } else if ((b & 0xF8) == 0xF0 && l >= 4) {
      return 4;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x11e00
movzbl (%rdi), %eax
testb %al, %al
js 0x11da0
movabsq $0x1, %rax
jmp 0x11e02
movl %eax, %ecx
andl $-0x20, %ecx
cmpl $0xc0, %ecx
sete %cl
cmpq $0x1, %rsi
setne %dl
testb %cl, %dl
je 0x11dc5
movabsq $0x2, %rax
jmp 0x11e02
movl %eax, %ecx
andl $-0x10, %ecx
cmpl $0xe0, %ecx
sete %cl
cmpq $0x3, %rsi
setae %dl
testb %cl, %dl
je 0x11dea
movabsq $0x3, %rax
jmp 0x11e02
andl $-0x8, %eax
cmpl $0xf0, %eax
sete %al
cmpq $0x4, %rsi
setae %cl
testb %al, %cl
jne 0x11e04
xorl %eax, %eax
popq %rbp
retq
movabsq $0x4, %rax
jmp 0x11e02
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::codepoint_count(char const*, unsigned long)
inline size_t codepoint_count(const char *s8, size_t l) {
  size_t count = 0;
  for (size_t i = 0; i < l;) {
    auto len = codepoint_length(s8 + i, l - i);
    if (len == 0) {
      // Invalid UTF-8 byte, treat as single byte to avoid infinite loop
      len = 1;
    }
    i += len;
    count++;
  }
  return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %rbx, %rsi
subq %r12, %rsi
jbe 0x11e71
leaq (%r14,%r12), %rdi
callq 0x11d84
cmpq $0x1, %rax
adcq %rax, %r12
incq %r15
jmp 0x11e54
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::escape_characters[abi:cxx11](char const*, unsigned long)
inline std::string escape_characters(const char *s, size_t n) {
  std::string str;
  for (size_t i = 0; i < n; i++) {
    auto c = s[i];
    switch (c) {
    case '\f': str += "\\f"; break;
    case '\n': str += "\\n"; break;
    case '\r': str += "\\r"; break;
    case '\t': str += "\\t"; break;
    case '\v': str += "\\v"; break;
    default: str += c; break;
    }
  }
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
xorl %r12d, %r12d
leaq 0x2af62(%rip), %r13     # 0x3ce10
cmpq %r12, %r14
je 0x11ee4
movb (%r15,%r12), %al
leal -0x9(%rax), %ecx
cmpb $0x5, %cl
jae 0x11ed4
movzbl %cl, %eax
movslq (%r13,%rax,4), %rsi
addq %r13, %rsi
movq %rbx, %rdi
callq 0x9490
jmp 0x11edf
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9260
incq %r12
jmp 0x11eae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x9140
movq %r14, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::parser::load_grammar(char const*, unsigned long, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<peg::Ope>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<peg::Ope>>>> const&, std::basic_string_view<char, std::char_traits<char>>)
bool load_grammar(const char *s, size_t n, const Rules &rules,
                    std::string_view start = {}) {
    auto cxt = ParserGenerator::parse(s, n, rules, log_, start);
    grammar_ = cxt.grammar;
    start_ = cxt.start;
    enablePackratParsing_ = cxt.enablePackratParsing;
    return grammar_ != nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, -0x30(%rbp)
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x38(%rdi), %rsi
leaq -0x60(%rbp), %rdi
callq 0xbff0
movq %r15, -0x40(%rbp)
movq %r14, -0x38(%rbp)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq -0x98(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq -0x30(%rbp), %rcx
leaq -0x60(%rbp), %r8
callq 0x120c0
leaq -0x60(%rbp), %rdi
callq 0x3209c
leaq -0x98(%rbp), %rsi
movq %rbx, %rdi
callq 0x30386
leaq -0x88(%rbp), %rsi
leaq 0x10(%rbx), %rdi
callq 0x9190
leaq -0x98(%rbp), %rdi
movb 0x30(%rdi), %al
movb %al, 0x30(%rbx)
cmpq $0x0, (%rbx)
setne %bl
callq 0x1216c
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x1216c
jmp 0x120b8
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3209c
movq %rbx, %rdi
callq 0x9430
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3863a(%rip), %rax     # 0x5afa0
movq %rax, (%rdi)
leaq 0x18(%rdi), %r14
movups %xmm0, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
movb %dl, 0x30(%rdi)
movb %cl, 0x31(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
leaq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x22a69
xorl %r12d, %r12d
leaq -0x30(%rbp), %r15
pushq $0x1
popq %r13
movl %r12d, %r12d
movq -0x48(%rbp), %rdx
cmpq %r12, %rdx
jbe 0x229f9
leal 0x2(%r12), %eax
movq -0x50(%rbp), %rcx
cmpq %rax, %rdx
jbe 0x229dc
leal 0x1(%r12), %edx
cmpl $0x2d, (%rcx,%rdx,4)
jne 0x229dc
movl (%rcx,%r12,4), %edx
movl (%rcx,%rax,4), %eax
movl %edx, -0x30(%rbp)
movl %eax, -0x2c(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x22af2
pushq $0x3
popq %rax
jmp 0x229f4
movl (%rcx,%r12,4), %eax
movl %eax, -0x30(%rbp)
movl %eax, -0x2c(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x22af2
movl %r13d, %eax
addl %eax, %r12d
jmp 0x2299a
movq 0x18(%rbx), %rax
cmpq 0x20(%rbx), %rax
je 0x22a1b
leaq -0x50(%rbp), %rdi
callq 0x22b34
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x170ab(%rip), %rdi     # 0x39acd
leaq 0x16c8c(%rip), %rsi     # 0x396b5
leaq 0x170ae(%rip), %rcx     # 0x39ade
movl $0x4da, %edx            # imm = 0x4DA
callq 0x91d0
movq %rax, %r15
jmp 0x22a4d
jmp 0x22a41
movq %rax, %r15
leaq -0x50(%rbp), %rdi
callq 0x22b34
movq %r14, %rdi
callq 0x22344
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x22654
movq %r15, %rdi
callq 0x9430
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::decode[abi:cxx11](char const*, unsigned long)
inline std::u32string decode(const char *s8, size_t l) {
  std::u32string out;
  size_t i = 0;
  while (i < l) {
    auto beg = i++;
    while (i < l && (s8[i] & 0xc0) == 0x80) {
      i++;
    }
    out += decode_codepoint(&s8[beg], (i - beg));
  }
  return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
andl $0x0, 0x10(%rdi)
xorl %eax, %eax
cmpq %r14, %rax
jae 0x22ad2
movq %rax, %rcx
leaq 0x1(%rcx), %r12
cmpq %r14, %r12
jae 0x22ab1
movb 0x1(%r15,%rcx), %cl
andb $-0x40, %cl
negb %cl
movq %r12, %rcx
jo 0x22a97
jmp 0x22ab4
movq %r14, %r12
leaq (%r15,%rax), %rdi
movq %r12, %rsi
subq %rax, %rsi
callq 0x22b47
movq %rbx, %rdi
movl %eax, %esi
callq 0x22c6e
movq %r12, %rax
jmp 0x22a8f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x22b34
movq %r14, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::decode_codepoint(char const*, unsigned long, unsigned long&, char32_t&)
inline bool decode_codepoint(const char *s8, size_t l, size_t &bytes,
                             char32_t &cp) {
  if (l) {
    auto b = static_cast<uint8_t>(s8[0]);
    if ((b & 0x80) == 0) {
      bytes = 1;
      cp = b;
      return true;
    } else if ((b & 0xE0) == 0xC0) {
      if (l >= 2) {
        bytes = 2;
        cp = ((static_cast<char32_t>(s8[0] & 0x1F)) << 6) |
             (static_cast<char32_t>(s8[1] & 0x3F));
        return true;
      }
    } else if ((b & 0xF0) == 0xE0) {
      if (l >= 3) {
        bytes = 3;
        cp = ((static_cast<char32_t>(s8[0] & 0x0F)) << 12) |
             ((static_cast<char32_t>(s8[1] & 0x3F)) << 6) |
             (static_cast<char32_t>(s8[2] & 0x3F));
        return true;
      }
    } else if ((b & 0xF8) == 0xF0) {
      if (l >= 4) {
        bytes = 4;
        cp = ((static_cast<char32_t>(s8[0] & 0x07)) << 18) |
             ((static_cast<char32_t>(s8[1] & 0x3F)) << 12) |
             ((static_cast<char32_t>(s8[2] & 0x3F)) << 6) |
             (static_cast<char32_t>(s8[3] & 0x3F));
        return true;
      }
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x22c6a
movzbl (%rdi), %eax
testb %al, %al
js 0x22baf
movq $0x1, (%rdx)
movl %eax, (%rcx)
movb $0x1, %al
jmp 0x22c6c
movl %eax, %r8d
andl $-0x20, %r8d
cmpl $0xc0, %r8d
jne 0x22bdf
cmpq $0x1, %rsi
je 0x22c6a
movq $0x2, (%rdx)
movzbl (%rdi), %edx
andl $0x1f, %edx
shll $0x6, %edx
movzbl 0x1(%rdi), %eax
jmp 0x22c15
movl %eax, %r8d
andl $-0x10, %r8d
cmpl $0xe0, %r8d
jne 0x22c1c
cmpq $0x3, %rsi
jb 0x22c6a
movq $0x3, (%rdx)
movzbl (%rdi), %eax
andl $0xf, %eax
shll $0xc, %eax
movzbl 0x1(%rdi), %edx
andl $0x3f, %edx
shll $0x6, %edx
orl %eax, %edx
movzbl 0x2(%rdi), %eax
andl $0x3f, %eax
orl %edx, %eax
jmp 0x22ba6
andl $-0x8, %eax
cmpl $0xf0, %eax
setne %al
cmpq $0x4, %rsi
setb %sil
orb %al, %sil
jne 0x22c6a
movq $0x4, (%rdx)
movzbl (%rdi), %eax
andl $0x7, %eax
shll $0x12, %eax
movzbl 0x1(%rdi), %edx
andl $0x3f, %edx
shll $0xc, %edx
orl %eax, %edx
movzbl 0x2(%rdi), %esi
andl $0x3f, %esi
shll $0x6, %esi
orl %edx, %esi
movzbl 0x3(%rdi), %eax
andl $0x3f, %eax
orl %esi, %eax
jmp 0x22ba6
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: std::any peg::call<peg::ParserGenerator::setup_actions()::'lambda24'(peg::SemanticValues const&), peg::SemanticValues&>(peg::ParserGenerator::setup_actions()::'lambda24'(peg::SemanticValues const&), peg::SemanticValues&)
std::any call(F fn, Args &&...args) {
  using R = decltype(fn(std::forward<Args>(args)...));
  if constexpr (std::is_void<R>::value) {
    fn(std::forward<Args>(args)...);
    return std::any();
  } else if constexpr (std::is_same<typename std::remove_cv<R>::type,
                                    std::any>::value) {
    return fn(std::forward<Args>(args)...);
  } else {
    return std::any(fn(std::forward<Args>(args)...));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0x1f112
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26206
leaq -0x18(%rbp), %rdi
callq 0x1106c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x18(%rbp), %rdi
callq 0x1106c
movq %rbx, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: std::vector<std::shared_ptr<peg::Ope>, std::allocator<std::shared_ptr<peg::Ope>>> peg::SemanticValues::transform<std::shared_ptr<peg::Ope>>(unsigned long, unsigned long) const
std::vector<T> transform(size_t beg = 0,
                           size_t end = static_cast<size_t>(-1)) const {
    std::vector<T> r;
    end = (std::min)(end, size());
    for (size_t i = beg; i < end; i++) {
      r.emplace_back(std::any_cast<T>((*this)[i]));
    }
    return r;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movq %rdi, -0x30(%rbp)
movups %xmm0, (%rdi)
movq 0x8(%rsi), %r12
subq (%rsi), %r12
sarq $0x4, %r12
cmpq %rcx, %r12
cmovaeq %rcx, %r12
movq %rdx, %r14
shlq $0x4, %r14
leaq -0x40(%rbp), %r13
cmpq %r12, %rbx
jae 0x2c6b2
movq (%r15), %rsi
addq %r14, %rsi
movq %r13, %rdi
callq 0x242e6
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0xba96
leaq -0x38(%rbp), %rdi
callq 0x1106c
incq %rbx
addq $0x10, %r14
jmp 0x2c681
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x1106c
jmp 0x2c6d6
movq %rax, %r14
movq -0x30(%rbp), %rdi
callq 0xbb2a
movq %r14, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Trie::Trie(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, bool)
Trie(const std::vector<std::string> &items, bool ignore_case)
      : ignore_case_(ignore_case) {
    size_t id = 0;
    for (const auto &item : items) {
      const auto &s = ignore_case ? to_lower(item) : item;
      for (size_t len = 1; len <= item.size(); len++) {
        auto last = len == item.size();
        std::string_view sv(s.data(), len);
        auto it = dic_.find(sv);
        if (it == dic_.end()) {
          dic_.emplace(sv, Info{last, last, id});
        } else if (last) {
          it->second.match = true;
        } else {
          it->second.done = false;
        }
      }
      id++;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %rax
movq %rax, 0x18(%rdi)
movq %rax, -0x48(%rbp)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movl %edx, -0x2c(%rbp)
movb %dl, 0x30(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
leaq -0xa8(%rbp), %r14
leaq -0x88(%rbp), %r12
cmpq -0x40(%rbp), %r15
je 0x294ab
cmpb $0x0, -0x2c(%rbp)
je 0x29415
movq %r14, %rdi
movq %r15, %rsi
callq 0x9360
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xfef0
movq %r14, %rdi
callq 0x9140
jmp 0x29420
movq %r12, %rdi
movq %r15, %rsi
callq 0x9360
pushq $0x1
popq %r14
movq 0x8(%r15), %r12
cmpq %r12, %r14
ja 0x29488
sete %r13b
movq -0x88(%rbp), %rax
movq %r14, -0x68(%rbp)
movq %rax, -0x60(%rbp)
movq %rbx, %rdi
leaq -0x68(%rbp), %rsi
callq 0x1001e
cmpq -0x48(%rbp), %rax
je 0x2945d
cmpq %r12, %r14
jne 0x2947f
movb $0x1, 0x41(%rax)
jmp 0x29483
movb %r13b, -0x58(%rbp)
movb %r13b, -0x57(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rbx, %rdi
leaq -0x68(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x294e6
jmp 0x29483
movb $0x0, 0x40(%rax)
incq %r14
jmp 0x29424
incq -0x38(%rbp)
leaq -0x88(%rbp), %r12
movq %r12, %rdi
callq 0x9140
addq $0x20, %r15
leaq -0xa8(%rbp), %r14
jmp 0x293e2
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x294bf
movq %rax, %r14
jmp 0x294d5
jmp 0x294c6
movq %rax, %r14
leaq -0x88(%rbp), %rdi
callq 0x9140
movq %rbx, %rdi
callq 0x29784
movq %r14, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::parse_hex_number(char const*, unsigned long, unsigned long)
inline std::pair<int, size_t> parse_hex_number(const char *s, size_t n,
                                               size_t i) {
  int ret = 0;
  int val;
  while (i < n && is_hex(s[i], val)) {
    ret = static_cast<int>(ret * 16 + val);
    i++;
  }
  return std::pair(ret, i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
xorl %r15d, %r15d
leaq -0x2c(%rbp), %r13
cmpq %r14, %rbx
jae 0x29c7e
movsbl (%r12,%rbx), %edi
movq %r13, %rsi
callq 0x29d0d
testb %al, %al
je 0x29c7e
shll $0x4, %r15d
addl -0x2c(%rbp), %r15d
incq %rbx
jmp 0x29c5b
movl %r15d, %eax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::parse_octal_number(char const*, unsigned long, unsigned long)
inline std::pair<int, size_t> parse_octal_number(const char *s, size_t n,
                                                 size_t i) {
  int ret = 0;
  int val;
  while (i < n && is_digit(s[i], val)) {
    ret = static_cast<int>(ret * 8 + val);
    i++;
  }
  return std::pair(ret, i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdx, %rcx
cmpq %rsi, %rdx
movq %rsi, %rdx
cmovaq %rcx, %rdx
xorl %eax, %eax
cmpq %rsi, %rcx
jae 0x29d0b
movzbl (%rdi,%rcx), %r8d
leal -0x30(%r8), %r9d
cmpb $0x9, %r9b
ja 0x29d08
leal (%r8,%rax,8), %eax
addl $-0x30, %eax
incq %rcx
jmp 0x29ce8
movq %rcx, %rdx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::is_hex(char, int&)
inline bool is_hex(char c, int &v) {
  if ('0' <= c && c <= '9') {
    v = c - '0';
    return true;
  } else if ('a' <= c && c <= 'f') {
    v = c - 'a' + 10;
    return true;
  } else if ('A' <= c && c <= 'F') {
    v = c - 'A' + 10;
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x30(%rdi), %eax
cmpb $0xa, %al
jae 0x29d1f
movl $0xffffffd0, %eax       # imm = 0xFFFFFFD0
jmp 0x29d39
leal -0x61(%rdi), %eax
cmpb $0x6, %al
jae 0x29d2d
movl $0xffffffa9, %eax       # imm = 0xFFFFFFA9
jmp 0x29d39
leal -0x41(%rdi), %eax
cmpb $0x5, %al
ja 0x29d41
movl $0xffffffc9, %eax       # imm = 0xFFFFFFC9
addl %edi, %eax
movl %eax, (%rsi)
movb $0x1, %al
popq %rbp
retq
xorl %eax, %eax
jmp 0x29d3f
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::encode_codepoint(char32_t, char*)
inline size_t encode_codepoint(char32_t cp, char *buff) {
  if (cp < 0x0080) {
    buff[0] = static_cast<char>(cp & 0x7F);
    return 1;
  } else if (cp < 0x0800) {
    buff[0] = static_cast<char>(0xC0 | ((cp >> 6) & 0x1F));
    buff[1] = static_cast<char>(0x80 | (cp & 0x3F));
    return 2;
  } else if (cp < 0xD800) {
    buff[0] = static_cast<char>(0xE0 | ((cp >> 12) & 0xF));
    buff[1] = static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
    buff[2] = static_cast<char>(0x80 | (cp & 0x3F));
    return 3;
  } else if (cp < 0xE000) {
    // D800 - DFFF is invalid...
    return 0;
  } else if (cp < 0x10000) {
    buff[0] = static_cast<char>(0xE0 | ((cp >> 12) & 0xF));
    buff[1] = static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
    buff[2] = static_cast<char>(0x80 | (cp & 0x3F));
    return 3;
  } else if (cp < 0x110000) {
    buff[0] = static_cast<char>(0xF0 | ((cp >> 18) & 0x7));
    buff[1] = static_cast<char>(0x80 | ((cp >> 12) & 0x3F));
    buff[2] = static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
    buff[3] = static_cast<char>(0x80 | (cp & 0x3F));
    return 4;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x7f, %edi
ja 0x29d5d
movb %dil, (%rsi)
movabsq $0x1, %rax
jmp 0x29dc5
cmpl $0x7ff, %edi            # imm = 0x7FF
ja 0x29d86
movl %edi, %eax
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x1(%rsi)
movabsq $0x2, %rax
jmp 0x29dc5
cmpl $0xd7ff, %edi           # imm = 0xD7FF
ja 0x29dbb
movl %edi, %eax
shrl $0xc, %eax
orb $-0x20, %al
movb %al, (%rsi)
movl %edi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x2(%rsi)
movabsq $0x3, %rax
jmp 0x29dc5
cmpl $0xe000, %edi           # imm = 0xE000
jae 0x29dc7
xorl %eax, %eax
popq %rbp
retq
cmpl $0xffff, %edi           # imm = 0xFFFF
jbe 0x29d8e
cmpl $0x10ffff, %edi         # imm = 0x10FFFF
ja 0x29dc3
movl %edi, %eax
shrl $0x12, %eax
orb $-0x10, %al
movb %al, (%rsi)
movl %edi, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsi)
movl %edi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x3(%rsi)
movabsq $0x4, %rax
jmp 0x29dc5
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Context::line_info(char const*) const
std::pair<size_t, size_t> line_info(const char *cur) const {
    std::call_once(source_line_index_init_, [this]() {
      for (size_t pos = 0; pos < l; pos++) {
        if (s[pos] == '\n') { source_line_index.push_back(pos); }
      }
      source_line_index.push_back(l);
    });

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x28c, %rdi            # imm = 0x28C
leaq -0x20(%rbp), %r15
movq %r14, (%r15)
movq %r15, %rsi
callq 0x2aa20
subq 0x8(%r14), %rbx
movq %rbx, (%r15)
movq 0x290(%r14), %rdi
movq 0x298(%r14), %rsi
leaq -0x20(%rbp), %rbx
movq %rbx, %rdx
callq 0x2ac21
movq 0x290(%r14), %rdx
movq (%rbx), %rcx
subq %rdx, %rax
je 0x2aa06
movq -0x8(%rdx,%rax), %rdx
notq %rdx
jmp 0x2aa08
xorl %edx, %edx
sarq $0x3, %rax
incq %rax
addq %rcx, %rdx
incq %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::ParserGenerator::detect_infiniteLoop(peg::ParserGenerator::Data const&, peg::Definition&, std::function<void (unsigned long, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)> const&, char const*) const
bool detect_infiniteLoop(const Data &data, Definition &rule, const Log &log,
                           const char *s) const {
    std::vector<std::pair<const char *, std::string>> refs;
    std::unordered_map<std::string, bool> has_error_cache;
    DetectInfiniteLoop vis(data.start_pos, rule.name, refs, has_error_cache);
    rule.accept(vis);
    if (vis.has_error) {
      if (log) {
        auto line = line_info(s, vis.error_s);
        log(line.first, line.second,
            "infinite loop is detected in '" + vis.error_name + "'.", "");
      }
      return true;
    }
    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %rbx
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rcx
andq $0x0, 0x10(%rcx)
movaps %xmm0, (%rcx)
leaq -0xf0(%rbp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq 0x30(%rsi), %rsi
leaq -0xe8(%rbp), %rdi
leaq -0x120(%rbp), %r8
callq 0x2fc04
movq 0x1c0(%rbx), %rdi
movq (%rdi), %rax
leaq -0xe8(%rbp), %rsi
callq *0x18(%rax)
movb -0xe0(%rbp), %bl
cmpb $0x1, %bl
jne 0x2e223
cmpq $0x0, 0x10(%r14)
je 0x2e223
movq -0xd8(%rbp), %rsi
movq %r15, %rdi
callq 0x11bfa
movq %rax, %r15
movq %rdx, %r12
leaq -0xd0(%rbp), %rdx
leaq 0xbcfa(%rip), %rsi      # 0x39eb2
leaq -0x80(%rbp), %rdi
callq 0xbd74
leaq 0xbc95(%rip), %rdx      # 0x39e5d
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xbd4b
leaq 0xb7fb(%rip), %rsi      # 0x399da
leaq -0x60(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0xff44
leaq -0xa0(%rbp), %rcx
leaq -0x60(%rbp), %r8
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x11e10
leaq -0x60(%rbp), %rdi
callq 0x9140
leaq -0xa0(%rbp), %rdi
callq 0x9140
leaq -0x80(%rbp), %rdi
callq 0x9140
leaq -0xe8(%rbp), %rdi
callq 0xcac6
leaq -0x120(%rbp), %rdi
callq 0x2fc9c
leaq -0x40(%rbp), %rdi
callq 0x2fc70
movl %ebx, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x9140
jmp 0x2e267
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x9140
jmp 0x2e278
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x9140
jmp 0x2e28a
jmp 0x2e287
jmp 0x2e287
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0xcac6
jmp 0x2e29b
movq %rax, %rbx
leaq -0x120(%rbp), %rdi
callq 0x2fc9c
leaq -0x40(%rbp), %rdi
callq 0x2fc70
movq %rbx, %rdi
callq 0x9430
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Definition::initialize_definition_ids() const::'lambda'()::operator()() const
void initialize_definition_ids() const {
    std::call_once(definition_ids_init_, [&]() {
      AssignIDToDefinition vis;
      holder_->accept(vis);
      if (whitespaceOpe) { whitespaceOpe->accept(vis); }
      if (wordOpe) { wordOpe->accept(vis); }
      definition_ids_.swap(vis.ids);
    });
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %rbx
leaq 0x2c5c7(%rip), %rax     # 0x5bb20
leaq -0x10(%rbp), %rcx
movq %rax, -0x38(%rcx)
movq %rcx, -0x30(%rcx)
movq $0x1, -0x28(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rcx)
movl $0x3f800000, -0x10(%rcx) # imm = 0x3F800000
movups %xmm0, -0x8(%rcx)
movq 0x1c0(%rbx), %rdi
movq (%rdi), %rax
leaq -0x48(%rbp), %rsi
callq *0x18(%rax)
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x2f5a6
movq (%rdi), %rax
leaq -0x48(%rbp), %rsi
callq *0x18(%rax)
movq 0xd8(%rbx), %rdi
testq %rdi, %rdi
je 0x2f5bc
movq (%rdi), %rax
leaq -0x48(%rbp), %rsi
callq *0x18(%rax)
leaq -0x40(%rbp), %rsi
addq $0x1e0, %rbx            # imm = 0x1E0
movq %rbx, %rdi
callq 0x2f5f4
leaq -0x48(%rbp), %rdi
callq 0xfb20
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xfb20
movq %rbx, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Context::push_semantic_values_scope()
SemanticValues &push_semantic_values_scope() {
    assert(value_stack_size <= value_stack.size());
    if (value_stack_size == value_stack.size()) {
      value_stack.emplace_back(std::make_shared<SemanticValues>(this));
    } else {
      auto &vs = *value_stack[value_stack_size];
      if (!vs.empty()) {
        vs.clear();
        if (!vs.tags.empty()) { vs.tags.clear(); }
      }
      vs.sv_ = std::string_view();
      vs.choice_count_ = 0;
      vs.choice_ = 0;
      if (!vs.tokens.empty()) { vs.tokens.clear(); }
    }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0xb0(%rdi), %rax
leaq 0x98(%rdi), %r14
movq 0x98(%rdi), %rcx
movq 0xa0(%rdi), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
cmpq %rdx, %rax
ja 0x31564
movq %rdi, %rbx
jne 0x314e7
leaq -0x30(%rbp), %rsi
movq %rbx, (%rsi)
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x3167a
movq %r14, %rdi
movq %r15, %rsi
callq 0x31624
leaq -0x20(%rbp), %rdi
callq 0x1106c
jmp 0x31529
shlq $0x4, %rax
movq (%rcx,%rax), %r14
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0x3150e
movq %r14, %rdi
callq 0x3169a
movq 0x28(%r14), %rax
cmpq 0x30(%r14), %rax
je 0x3150e
movq %rax, 0x30(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r14)
movups %xmm0, 0x70(%r14)
movq 0x40(%r14), %rax
cmpq 0x48(%r14), %rax
je 0x31529
movq %rax, 0x48(%r14)
movq 0xb0(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xb0(%rbx)
movq (%rbx), %rcx
movq 0x98(%rbx), %rdx
shlq $0x4, %rax
movq (%rdx,%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x20(%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x89d9(%rip), %rdi      # 0x39f44
leaq 0x8143(%rip), %rsi      # 0x396b5
leaq 0x89f2(%rip), %rcx      # 0x39f6b
movl $0x374, %edx            # imm = 0x374
callq 0x91d0
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x1106c
movq %rbx, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::SemanticValues::append(peg::SemanticValues&)
void append(SemanticValues &chvs) {
    sv_ = chvs.sv_;
    for (auto &v : chvs) {
      emplace_back(std::move(v));
    }
    for (auto &tag : chvs.tags) {
      tags.emplace_back(std::move(tag));
    }
    for (auto &tok : chvs.tokens) {
      tokens.emplace_back(std::move(tok));
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movups 0x60(%rsi), %xmm0
movups %xmm0, 0x60(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x315d1
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb6fc
addq $0x10, %r15
jmp 0x315bb
movq 0x28(%r14), %r15
movq 0x30(%r14), %r13
leaq 0x28(%rbx), %r12
cmpq %r13, %r15
je 0x315f3
movq %r12, %rdi
movq %r15, %rsi
callq 0xb742
addq $0x4, %r15
jmp 0x315dd
movq 0x40(%r14), %r15
movq 0x48(%r14), %r14
addq $0x40, %rbx
cmpq %r14, %r15
je 0x31615
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb372
addq $0x10, %r15
jmp 0x315ff
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Context::shift_capture_values()
void shift_capture_values() {
    assert(capture_scope_stack_size >= 2);
    auto curr = &capture_scope_stack[capture_scope_stack_size - 1];
    auto prev = curr - 1;
    for (const auto &[k, v] : *curr) {
      (*prev)[k] = v;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x130(%rdi), %rax
cmpq $0x1, %rax
jbe 0x31b69
movq 0x118(%rdi), %rcx
imulq $0x30, %rax, %rax
leaq (%rcx,%rax), %rbx
addq $-0x60, %rbx
movq 0x48(%rbx), %r14
leaq (%rcx,%rax), %r12
addq $-0x28, %r12
cmpq %r12, %r14
je 0x31b60
leaq 0x20(%r14), %rsi
leaq 0x30(%r14), %r15
movq %rbx, %rdi
callq 0x28822
movq %rax, %rdi
movq %r15, %rsi
callq 0x9190
movq %r14, %rdi
callq 0x9200
movq %rax, %r14
jmp 0x31b33
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8452(%rip), %rdi      # 0x39fc2
leaq 0x7b3e(%rip), %rsi      # 0x396b5
leaq 0x8462(%rip), %rcx      # 0x39fe0
movl $0x3a6, %edx            # imm = 0x3A6
callq 0x91d0
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::CharacterClass::in_range(std::pair<char32_t, char32_t> const&, char32_t) const
bool in_range(const std::pair<char32_t, char32_t> &range, char32_t cp) const {
    if (ignore_case_) {
      auto cpl = std::tolower(cp);
      return std::tolower(range.first) <= cpl &&
             cpl <= std::tolower(range.second);
    } else {
      return range.first <= cp && cp <= range.second;
    }
  }

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0x18(%rdi), %rax
movq 0x58(%rdi), %rcx
movb 0xe9(%rcx), %r14b
leaq 0x28742(%rip), %rsi     # 0x5ace0
leaq 0x2875b(%rip), %rdx     # 0x5ad00
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x92f0
cmpb $0x1, %r14b
jne 0x32605
testq %rax, %rax
je 0x3261a
movq 0xd8(%rbx), %rcx
movq 0x70(%rax), %rsi
shlq $0x4, %rsi
addq -0x18(%rcx), %rsi
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
callq 0x117ce
movq (%rbx), %rdi
leaq 0x286fd(%rip), %rsi     # 0x5ace0
leaq 0x28716(%rip), %rdx     # 0x5ad00
xorl %ecx, %ecx
callq 0x92f0
testq %rax, %rax
je 0x3261f
movq 0x68(%rax), %rbx
leaq -0x18(%rbp), %rdi
callq 0x1106c
jmp 0x3260e
testq %rax, %rax
je 0x3261a
movq 0x68(%rax), %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x9480
callq 0x9480
movq %rax, %rbx
leaq -0x18(%rbp), %rdi
callq 0x1106c
movq %rbx, %rdi
callq 0x9430