LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Lexer::skip_whitespaces_and_first_newline()
void skip_whitespaces_and_first_newline() {
    if (pos < m_in.size()) {
      while (pos < m_in.size() && (m_in[pos] == ' ' || m_in[pos] == '\t')) {
        pos += 1;
      }
    }

    if (pos < m_in.size()) {
      char ch = m_in[pos];
      if (ch == '\n') {
        pos += 1;
      } else if (ch == '\r') {
        pos += 1;
        if (pos < m_in.size() && m_in[pos] == '\n') {
          pos += 1;
        }
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq 0x28(%rdi), %rax
movq %rax, -0x18(%rbp)
addq $0x10, %rdi
callq 0x332e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x37ea4
jmp 0x37e17
movq -0x20(%rbp), %rdi
movq 0x28(%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x10, %rdi
callq 0x332e0
movq -0x30(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x21(%rbp)
jae 0x37e84
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq 0x28(%rax), %rsi
callq 0x374e0
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x31(%rbp)
je 0x37e7e
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq 0x28(%rax), %rsi
callq 0x374e0
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x37e8d
jmp 0x37ea2
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x37e17
jmp 0x37ea4
movq -0x20(%rbp), %rdi
movq 0x28(%rdi), %rax
movq %rax, -0x40(%rbp)
addq $0x10, %rdi
callq 0x332e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x37f65
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq 0x28(%rax), %rsi
callq 0x374e0
movb (%rax), %al
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
jne 0x37efd
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x37f63
movsbl -0x9(%rbp), %eax
cmpl $0xd, %eax
jne 0x37f61
movq -0x20(%rbp), %rdi
movq 0x28(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x28(%rdi)
movq 0x28(%rdi), %rax
movq %rax, -0x48(%rbp)
addq $0x10, %rdi
callq 0x332e0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x37f5f
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq 0x28(%rax), %rsi
callq 0x374e0
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x37f5f
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x37f61
jmp 0x37f63
jmp 0x37f65
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Lexer::scan_id()
Token scan_id() {
    for (;;) {
      if (pos >= m_in.size()) {
        break;
      }
      char ch = m_in[pos];
      if (!std::isalnum(ch) && ch != '.' && ch != '/' && ch != '_' && ch != '-') {
        break;
      }
      pos += 1;
    }
    return make_token(Token::Kind::Id);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0x28(%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x10, %rdi
callq 0x332e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jb 0x3827f
jmp 0x382e1
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq 0x28(%rax), %rsi
callq 0x374e0
movb (%rax), %al
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %edi
callq 0xb5a0
cmpl $0x0, %eax
jne 0x382cc
movsbl -0x9(%rbp), %eax
cmpl $0x2e, %eax
je 0x382cc
movsbl -0x9(%rbp), %eax
cmpl $0x2f, %eax
je 0x382cc
movsbl -0x9(%rbp), %eax
cmpl $0x5f, %eax
je 0x382cc
movsbl -0x9(%rbp), %eax
cmpl $0x2d, %eax
je 0x382cc
jmp 0x382e1
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x3825c
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdi
movl $0x9, %edx
callq 0x37430
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Lexer::scan_number()
Token scan_number() {
    for (;;) {
      if (pos >= m_in.size()) {
        break;
      }
      char ch = m_in[pos];
      // be very permissive in lexer (we'll catch errors when conversion happens)
      if (!std::isdigit(ch) && ch != '.' && ch != 'e' && ch != 'E' && ch != '+' && ch != '-') {
        break;
      }
      pos += 1;
    }
    return make_token(Token::Kind::Number);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0x28(%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x10, %rdi
callq 0x332e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jb 0x3833f
jmp 0x383aa
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq 0x28(%rax), %rsi
callq 0x374e0
movb (%rax), %al
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %edi
callq 0xb510
cmpl $0x0, %eax
jne 0x38395
movsbl -0x9(%rbp), %eax
cmpl $0x2e, %eax
je 0x38395
movsbl -0x9(%rbp), %eax
cmpl $0x65, %eax
je 0x38395
movsbl -0x9(%rbp), %eax
cmpl $0x45, %eax
je 0x38395
movsbl -0x9(%rbp), %eax
cmpl $0x2b, %eax
je 0x38395
movsbl -0x9(%rbp), %eax
cmpl $0x2d, %eax
je 0x38395
jmp 0x383aa
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x3831c
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdi
movl $0xa, %edx
callq 0x37430
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Lexer::scan_string()
Token scan_string() {
    bool escape {false};
    for (;;) {
      if (pos >= m_in.size()) {
        break;
      }
      char ch = m_in[pos++];
      if (ch == '\\') {
        escape = true;
      } else if (!escape && ch == m_in[tok_start]) {
        break;
      } else {
        escape = false;
      }
    }
    return make_token(Token::Kind::String);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x18(%rbp), %rdi
movq 0x28(%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x10, %rdi
callq 0x332e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jb 0x38413
jmp 0x38481
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq 0x28(%rax), %rsi
movq %rsi, %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
callq 0x374e0
movb (%rax), %al
movb %al, -0xa(%rbp)
movsbl -0xa(%rbp), %eax
cmpl $0x5c, %eax
jne 0x38446
movb $0x1, -0x9(%rbp)
jmp 0x3847c
testb $0x1, -0x9(%rbp)
jne 0x38476
movq -0x18(%rbp), %rax
movsbl -0xa(%rbp), %ecx
movl %ecx, -0x34(%rbp)
movq %rax, %rdi
addq $0x10, %rdi
movq 0x20(%rax), %rsi
callq 0x374e0
movq %rax, %rcx
movl -0x34(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x38476
jmp 0x38481
movb $0x0, -0x9(%rbp)
jmp 0x3847c
jmp 0x383f0
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdi
movl $0xb, %edx
callq 0x37430
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::get_source_location(std::basic_string_view<char, std::char_traits<char>>, unsigned long)
inline SourceLocation get_source_location(nonstd::string_view content, size_t pos) {
  // Get line and offset position (starts at 1:1)
  auto sliced = string_view::slice(content, 0, pos);
  std::size_t last_newline = sliced.rfind("\n");

  if (last_newline == nonstd::string_view::npos) {
    return {1, sliced.length() + 1};
  }

  // Count newlines
  size_t count_lines = 0;
  size_t search_start = 0;
  while (search_start <= sliced.size()) {
    search_start = sliced.find("\n", search_start) + 1;
    if (search_start == 0) {
      break;
    }
    count_lines += 1;
  }

  return {count_lines + 1, sliced.length() - last_newline};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rcx
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x37510
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
leaq 0x89e22(%rip), %rsi     # 0xc25fe
movq $-0x1, %rdx
callq 0x388a0
movq %rax, -0x50(%rbp)
cmpq $-0x1, -0x50(%rbp)
jne 0x3880e
movq $0x1, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x38900
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x3888b
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x332e0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
ja 0x3886e
movq -0x60(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq 0x89db4(%rip), %rsi     # 0xc25fe
callq 0x38920
addq $0x1, %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
jne 0x38860
jmp 0x3886e
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x3881e
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x38900
subq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Parser::load_file[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>)
std::string load_file(nonstd::string_view filename) {
    std::ifstream file;
    open_file_or_throw(static_cast<std::string>(filename), file);
    std::string text((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
    return text;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rdi, -0x2a0(%rbp)
movq %rdi, %rax
movq %rax, -0x298(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0x228(%rbp), %rdi
callq 0xb690
leaq -0x249(%rbp), %rdi
movq %rdi, -0x290(%rbp)
callq 0xba70
movq -0x290(%rbp), %rdx
leaq -0x248(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x31e70
jmp 0x3aed4
leaq -0x248(%rbp), %rdi
leaq -0x228(%rbp), %rsi
callq 0x590f0
jmp 0x3aee9
leaq -0x248(%rbp), %rdi
callq 0xbb98
leaq -0x249(%rbp), %rdi
callq 0xb600
movb $0x0, -0x25d(%rbp)
leaq -0x270(%rbp), %rdi
leaq -0x228(%rbp), %rsi
callq 0x59250
leaq -0x280(%rbp), %rdi
callq 0x592b0
leaq -0x281(%rbp), %rdi
movq %rdi, -0x2a8(%rbp)
callq 0xba70
movq -0x2a0(%rbp), %rdi
movq -0x2a8(%rbp), %r9
movq -0x270(%rbp), %rsi
movl -0x268(%rbp), %edx
movq -0x280(%rbp), %rcx
movl -0x278(%rbp), %r8d
callq 0x592e0
jmp 0x3af6a
leaq -0x281(%rbp), %rdi
callq 0xb600
movb $0x1, -0x25d(%rbp)
testb $0x1, -0x25d(%rbp)
jne 0x3aff4
jmp 0x3afe8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
jmp 0x3afba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
leaq -0x248(%rbp), %rdi
callq 0xbb98
leaq -0x249(%rbp), %rdi
callq 0xb600
jmp 0x3b010
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
leaq -0x281(%rbp), %rdi
callq 0xb600
jmp 0x3b010
movq -0x2a0(%rbp), %rdi
callq 0xbb98
leaq -0x228(%rbp), %rdi
callq 0xb100
movq -0x298(%rbp), %rax
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
leaq -0x228(%rbp), %rdi
callq 0xb100
movq -0x258(%rbp), %rdi
callq 0xba60
nopl (%rax,%rax)
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Parser::parse_into_template(inja::Template&, std::basic_string_view<char, std::char_traits<char>>)
void parse_into_template(Template& tmpl, nonstd::string_view filename) {
    nonstd::string_view path = filename.substr(0, filename.find_last_of("/\\") + 1);

    // StringRef path = sys::path::parent_path(filename);
    auto sub_parser = Parser(config, lexer.get_config(), template_storage, function_storage);
    sub_parser.parse_into(tmpl, path);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x260(%rbp)
leaq 0x8afeb(%rip), %rsi     # 0xc6098
leaq -0x10(%rbp), %rdi
movq %rdi, -0x270(%rbp)
movq $-0x1, %rdx
callq 0x5aa20
movq -0x270(%rbp), %rdi
movq %rax, %rdx
incq %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x36790
movq -0x260(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq (%rdi), %rax
movq %rax, -0x268(%rbp)
addq $0x8, %rdi
callq 0x5aa80
movq -0x268(%rbp), %rsi
movq %rax, %rdx
movq -0x260(%rbp), %rax
movq 0x38(%rax), %rcx
movq 0x40(%rax), %r8
leaq -0x228(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x2ee80
movq -0x258(%rbp), %rdi
movq -0x20(%rbp), %rsi
movups -0x30(%rbp), %xmm0
movaps %xmm0, -0x240(%rbp)
movq -0x240(%rbp), %rdx
movq -0x238(%rbp), %rcx
callq 0x31f40
jmp 0x3b153
leaq -0x228(%rbp), %rdi
callq 0x2f060
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x2f060
movq -0x248(%rbp), %rdi
callq 0xba60
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::detail::iterator_input_adapter<char const*>::get_character()
typename std::char_traits<char_type>::int_type get_character()
    {
        if (JSON_HEDLEY_LIKELY(current != end))
        {
            auto result = std::char_traits<char_type>::to_int_type(*current);
            std::advance(current, 1);
            return result;
        }
        else
        {
            return std::char_traits<char_type>::eof();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x42078
jmp 0x4209d
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x420f0
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl $0x1, %esi
callq 0x42110
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x420a5
callq 0x40770
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::assert_invariant() const
void assert_invariant() const noexcept
    {
        JSON_ASSERT(m_type != value_t::object || m_value.object != nullptr);
        JSON_ASSERT(m_type != value_t::array || m_value.array != nullptr);
        JSON_ASSERT(m_type != value_t::string || m_value.string != nullptr);
        JSON_ASSERT(m_type != value_t::binary || m_value.binary != nullptr);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movb $0x1, %al
cmpb $0x1, (%rcx)
movb %al, -0x9(%rbp)
jne 0x44ced
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x44cf6
jmp 0x44cf8
jmp 0x44d17
leaq 0x80308(%rip), %rdi     # 0xc5007
leaq 0x7dc67(%rip), %rsi     # 0xc296d
movl $0x4530, %edx           # imm = 0x4530
leaq 0x8032c(%rip), %rcx     # 0xc503e
callq 0xb410
movq -0x18(%rbp), %rcx
movb $0x1, %al
cmpb $0x2, (%rcx)
movb %al, -0x19(%rbp)
jne 0x44d34
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x44d3d
jmp 0x44d3f
jmp 0x44d5e
leaq 0x80465(%rip), %rdi     # 0xc51ab
leaq 0x7dc20(%rip), %rsi     # 0xc296d
movl $0x4531, %edx           # imm = 0x4531
leaq 0x802e5(%rip), %rcx     # 0xc503e
callq 0xb410
movq -0x18(%rbp), %rcx
movb $0x1, %al
cmpb $0x3, (%rcx)
movb %al, -0x1a(%rbp)
jne 0x44d7b
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x44d84
jmp 0x44d86
jmp 0x44da5
leaq 0x80453(%rip), %rdi     # 0xc51e0
leaq 0x7dbd9(%rip), %rsi     # 0xc296d
movl $0x4532, %edx           # imm = 0x4532
leaq 0x8029e(%rip), %rcx     # 0xc503e
callq 0xb410
movq -0x18(%rbp), %rcx
movb $0x1, %al
cmpb $0x8, (%rcx)
movb %al, -0x1b(%rbp)
jne 0x44dc2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
testb $0x1, %al
jne 0x44dcb
jmp 0x44dcd
jmp 0x44dec
leaq 0x80443(%rip), %rdi     # 0xc5217
leaq 0x7db92(%rip), %rsi     # 0xc296d
movl $0x4533, %edx           # imm = 0x4533
leaq 0x80257(%rip), %rcx     # 0xc503e
callq 0xb410
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::detail::iterator_input_adapter<char const*>>::get_token_string() const
std::string get_token_string() const
    {
        // escape control characters
        std::string result;
        for (const auto c : token_string)
        {
            if (static_cast<unsigned char>(c) <= '\x1F')
            {
                // escape control characters
                std::array<char, 9> cs{{}};
                (std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c));
                result += cs.data();
            }
            else
            {
                // add character as is
                result.push_back(static_cast<std::string::value_type>(c));
            }
        }

        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xb820
movq -0x58(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x42a80
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x42ab0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x54450
testb $0x1, %al
jne 0x44f2b
jmp 0x44fd2
leaq -0x28(%rbp), %rdi
callq 0x54490
movb (%rax), %al
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
cmpl $0x1f, %eax
jg 0x44fb1
movb $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x544b0
movq -0x70(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x544d0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
movzbl -0x31(%rbp), %ecx
leaq 0x802d4(%rip), %rdx     # 0xc524e
xorl %eax, %eax
callq 0xb940
movq -0x70(%rbp), %rdi
callq 0x544b0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0xb540
jmp 0x44f98
jmp 0x44fc2
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0xbb98
jmp 0x44ff2
movq -0x68(%rbp), %rdi
movsbl -0x31(%rbp), %esi
callq 0xb4c0
jmp 0x44fc0
jmp 0x44fc2
jmp 0x44fc4
leaq -0x28(%rbp), %rdi
callq 0x544e0
jmp 0x44f15
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x44fe5
movq -0x68(%rbp), %rdi
callq 0xbb98
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xba60
nopl (%rax,%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::end_array()
bool end_array()
    {
        bool keep = true;

        if (ref_stack.back())
        {
            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
            if (!keep)
            {
                // discard array
                *ref_stack.back() = discarded;
            }
        }

        JSON_ASSERT(!ref_stack.empty());
        JSON_ASSERT(!keep_stack.empty());
        ref_stack.pop_back();
        keep_stack.pop_back();

        // remove discarded value
        if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
        {
            ref_stack.back()->m_value.array->pop_back();
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movb $0x1, -0x9(%rbp)
addq $0x8, %rdi
callq 0x4a7b0
cmpq $0x0, (%rax)
je 0x49bef
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x80, %rax
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
callq 0x4a200
movq -0x28(%rbp), %rdi
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
addq $0x8, %rdi
callq 0x4a7b0
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq (%rax), %rcx
movl $0x3, %edx
callq 0x4a1b0
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x49bed
movq -0x28(%rbp), %rsi
addq $0xa8, %rsi
leaq -0x20(%rbp), %rdi
callq 0x4bc70
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x4a7b0
movq (%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x12800
leaq -0x20(%rbp), %rdi
callq 0x12460
jmp 0x49bef
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x4a890
xorb $-0x1, %al
testb $0x1, %al
jne 0x49c04
jmp 0x49c06
jmp 0x49c25
leaq 0x7a4a8(%rip), %rdi     # 0xc40b5
leaq 0x78d59(%rip), %rsi     # 0xc296d
movl $0x1621, %edx           # imm = 0x1621
leaq 0x7ae94(%rip), %rcx     # 0xc4ab4
callq 0xb410
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x4a0a0
xorb $-0x1, %al
testb $0x1, %al
jne 0x49c3a
jmp 0x49c3c
jmp 0x49c5b
leaq 0x7a321(%rip), %rdi     # 0xc3f64
leaq 0x78d23(%rip), %rsi     # 0xc296d
movl $0x1622, %edx           # imm = 0x1622
leaq 0x7ae5e(%rip), %rcx     # 0xc4ab4
callq 0xb410
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x4bdf0
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x4a190
testb $0x1, -0x9(%rbp)
jne 0x49cc0
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x4a890
testb $0x1, %al
jne 0x49cc0
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x4a7b0
movq (%rax), %rdi
callq 0x4a970
testb $0x1, %al
jne 0x49ca7
jmp 0x49cc0
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x4a7b0
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x51ec0
movb $0x1, %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::detail::json_sax_dom_parser<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::start_object(unsigned long)
bool start_object(std::size_t len)
    {
        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));

        if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
        {
            JSON_THROW(out_of_range::create(408,
                                            "excessive object size: " + std::to_string(len)));
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x78(%rbp)
movb $0x1, -0x19(%rbp)
leaq -0x19(%rbp), %rsi
callq 0x56b80
movq -0x78(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x56b50
xorl %eax, %eax
cmpq $-0x1, -0x10(%rbp)
movb %al, -0x6e(%rbp)
je 0x566b3
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
addq $0x8, %rdi
callq 0x4a7b0
movq (%rax), %rdi
callq 0x4a7f0
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
seta %al
movb %al, -0x6e(%rbp)
movb -0x6e(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x566c3
jmp 0x56784
movb $0x1, -0x6d(%rbp)
movl $0x20, %edi
callq 0xb2c0
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x38e90
jmp 0x566e7
leaq 0x6d85e(%rip), %rsi     # 0xc3f4c
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x34d50
jmp 0x566fd
movq -0x90(%rbp), %rdi
movl $0x198, %esi            # imm = 0x198
leaq -0x40(%rbp), %rdx
callq 0x49da0
jmp 0x56714
movq -0x90(%rbp), %rdi
movb $0x0, -0x6d(%rbp)
leaq 0xc5692(%rip), %rsi     # 0x11bdb8
leaq -0xc83d(%rip), %rdx     # 0x49ef0
callq 0xb9f0
jmp 0x5679a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x5676e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x56765
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xbb98
leaq -0x60(%rbp), %rdi
callq 0xbb98
testb $0x1, -0x6d(%rbp)
jne 0x56776
jmp 0x56782
movq -0x90(%rbp), %rdi
callq 0xb460
jmp 0x56791
movb $0x1, %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0xba60
nopw (%rax,%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const& nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::get_ref_impl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>&)
static ReferenceType get_ref_impl(ThisType& obj)
    {
        // delegate the call to get_ptr<>()
        auto ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();

        if (JSON_HEDLEY_LIKELY(ptr != nullptr))
        {
            return *ptr;
        }

        JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name())));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x58d90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x58c9e
jmp 0x58cab
movq -0x10(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movb $0x1, -0x65(%rbp)
movl $0x20, %edi
callq 0xb2c0
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rdi
callq 0x50ae0
movq %rax, -0x78(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xba70
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x10b90
jmp 0x58cea
leaq 0x6d349(%rip), %rsi     # 0xc603a
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x34d50
jmp 0x58d00
movq -0x80(%rbp), %rdi
movl $0x12f, %esi            # imm = 0x12F
leaq -0x30(%rbp), %rdx
callq 0x50990
jmp 0x58d14
movq -0x80(%rbp), %rdi
movb $0x0, -0x65(%rbp)
leaq 0xc3115(%rip), %rsi     # 0x11be38
leaq -0x81aa(%rip), %rdx     # 0x50b80
callq 0xb9f0
jmp 0x58d90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x58d6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x58d62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbb98
leaq -0x50(%rbp), %rdi
callq 0xbb98
leaq -0x51(%rbp), %rdi
callq 0xb600
testb $0x1, -0x65(%rbp)
jne 0x58d7c
jmp 0x58d85
movq -0x80(%rbp), %rdi
callq 0xb460
jmp 0x58d87
movq -0x60(%rbp), %rdi
callq 0xba60
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::open_file_or_throw(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::basic_ifstream<char, std::char_traits<char>>&)
inline void open_file_or_throw(const std::string &path, std::ifstream &file) {
  file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
  try {
    file.open(path);
  } catch (const std::ios_base::failure & /*e*/) {
    throw FileError("failed accessing file at '" + path + "'");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x78(%rbp)
movl $0x4, %edi
movl $0x1, %esi
callq 0x59370
movq -0x78(%rbp), %rdi
movl %eax, %esi
callq 0xb140
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x8, %edx
callq 0xb4d0
jmp 0x59143
jmp 0x5922f
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 0x59238
movq -0x18(%rbp), %rdi
callq 0xb1e0
movq %rax, -0x28(%rbp)
movb $0x1, -0x69(%rbp)
movl $0x60, %edi
callq 0xb2c0
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x6cee4(%rip), %rsi     # 0xc6072
leaq -0x68(%rbp), %rdi
callq 0x1ce80
jmp 0x59199
leaq 0x6c110(%rip), %rdx     # 0xc52b0
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1fa80
jmp 0x591af
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x59390
jmp 0x591be
movq -0x80(%rbp), %rdi
movb $0x0, -0x69(%rbp)
leaq 0xc2d53(%rip), %rsi     # 0x11bf20
leaq 0x26c(%rip), %rdx       # 0x59440
callq 0xb9f0
jmp 0x59249
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x59215
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x5920c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xbb98
leaq -0x68(%rbp), %rdi
callq 0xbb98
testb $0x1, -0x69(%rbp)
jne 0x5921d
jmp 0x59226
movq -0x80(%rbp), %rdi
callq 0xb460
callq 0xb980
jmp 0x5922d
jmp 0x59238
addq $0x80, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xba60
movq %rax, %rdi
callq 0x11df0
nopl (%rax)
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::JsonNode::convert_dot_to_json_ptr[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>)
static std::string convert_dot_to_json_ptr(nonstd::string_view ptr_name) {
    std::string result;
    do {
      nonstd::string_view part;
      std::tie(part, ptr_name) = string_view::split(ptr_name, '.');
      result.push_back('/');
      result.append(part.begin(), part.end());
    } while (!ptr_name.empty());
    return result;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xb820
leaq -0x30(%rbp), %rdi
callq 0x2f130
movups -0x18(%rbp), %xmm0
movaps %xmm0, -0x60(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x50(%rbp), %rdi
movl $0x2e, %ecx
callq 0x62740
jmp 0x6258a
leaq -0x80(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x62820
movq -0x98(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x62860
movq -0x90(%rbp), %rdi
movl $0x2f, %esi
callq 0xb4c0
jmp 0x625c5
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x432e0
movq -0xa8(%rbp), %rdi
movq %rax, -0xa0(%rbp)
callq 0x43300
movq -0x90(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq %rax, %rdx
callq 0x628e0
jmp 0x62600
jmp 0x62602
leaq -0x18(%rbp), %rdi
callq 0x37660
xorb $-0x1, %al
testb $0x1, %al
jne 0x62561
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x62647
jmp 0x6263b
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0xbb98
jmp 0x62657
movq -0x90(%rbp), %rdi
callq 0xbb98
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0xba60
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::string_view::split(std::basic_string_view<char, std::char_traits<char>>, char)
inline std::pair<nonstd::string_view, nonstd::string_view> split(nonstd::string_view view, char Separator) {
  size_t idx = view.find(Separator);
  if (idx == nonstd::string_view::npos) {
    return std::make_pair(view, nonstd::string_view());
  }
  return std::make_pair(slice(view, 0, idx), slice(view, idx + 1, nonstd::string_view::npos));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movb %cl, %al
movq %rdi, -0x78(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movb %al, -0x11(%rbp)
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x11(%rbp), %esi
callq 0x62950
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x62798
leaq -0x30(%rbp), %rdi
callq 0x2f130
movq -0x80(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x629f0
jmp 0x6280a
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rcx
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x37510
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq $-0x1, %rcx
callq 0x37510
movq -0x80(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x62a20
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::json_pointer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::replace_substring(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&)
static void replace_substring(std::string& s, const std::string& f,
                                  const std::string& t)
    {
        JSON_ASSERT(!f.empty());
        for (auto pos = s.find(f);                // find first occurrence of f
                pos != std::string::npos;         // make sure f was found
                s.replace(pos, f.size(), t),      // replace with t, and
                pos = s.find(f, pos + t.size()))  // find next occurrence of f
        {}
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb9a0
xorb $-0x1, %al
testb $0x1, %al
jne 0x636e5
jmp 0x636e7
jmp 0x63706
leaq 0x62b7d(%rip), %rdi     # 0xc626b
leaq 0x5f278(%rip), %rsi     # 0xc296d
movl $0x3042, %edx           # imm = 0x3042
leaq 0x62b75(%rip), %rcx     # 0xc6276
callq 0xb410
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xbb70
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x6378c
jmp 0x63724
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb440
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
callq 0xb180
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb440
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq %rax, %rdx
callq 0xbb70
movq %rax, -0x20(%rbp)
jmp 0x6371b
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Renderer::render_to(std::ostream&, inja::Template const&, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const&, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>*)
void render_to(std::ostream &os, const Template &tmpl, const json &data, json *loop_data = nullptr) {
    output_stream = &os;
    current_template = &tmpl;
    json_input = &data;
    if (loop_data) {
      json_additional_data = *loop_data;
      current_loop_data = &json_additional_data["loop"];
    }

    current_template->root.accept(*this);

    json_tmp_stack.clear();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
cmpq $0x0, -0x28(%rbp)
je 0x65159
movq -0x28(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x4bc70
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
leaq -0x38(%rbp), %rsi
callq 0x12800
leaq -0x38(%rbp), %rdi
callq 0x12460
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
leaq 0x611dd(%rip), %rsi     # 0xc6326
callq 0x65200
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x40(%rbp), %rsi
movq 0x10(%rsi), %rdi
callq 0x32be0
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
callq 0x808a0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Renderer::visit(inja::IfStatementNode const&)
void visit(const IfStatementNode& node) {
    auto result = eval_expression_list(node.condition);
    if (truthy(result.get())) {
      node.true_statement.accept(*this);
    } else if (node.has_false_statement) {
      node.false_statement.accept(*this);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movq -0x10(%rbp), %rdx
addq $0x10, %rdx
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x7f660
movq -0x40(%rbp), %rdi
callq 0x6cca0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x71800
movb %al, -0x2d(%rbp)
jmp 0x6a237
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x6a240
jmp 0x6a26c
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x32be0
jmp 0x6a253
jmp 0x6a290
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6c020
jmp 0x6a29f
movq -0x10(%rbp), %rax
testb $0x1, 0x91(%rax)
je 0x6a28e
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0x32be0
jmp 0x6a28c
jmp 0x6a28e
jmp 0x6a290
leaq -0x20(%rbp), %rdi
callq 0x6c020
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xba60
nopl (%rax,%rax)
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Renderer::visit(inja::IncludeStatementNode const&)
void visit(const IncludeStatementNode& node) {
    auto sub_renderer = Renderer(config, template_storage, function_storage);
    auto included_template_it = template_storage.find(node.file);

    if (included_template_it != template_storage.end()) {
      sub_renderer.render_to(*output_stream, included_template_it->second, *json_input, &json_additional_data);
    } else if (config.throw_at_missing_includes) {
      throw_renderer_error("include '" + node.file + "' not found", node);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x188(%rbp)
movq %rax, %rsi
addq $0x8, %rsi
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
leaq -0x118(%rbp), %rdi
callq 0x64fb0
movq -0x188(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x80580
movq %rax, -0x180(%rbp)
jmp 0x6a30a
movq -0x188(%rbp), %rax
movq -0x180(%rbp), %rcx
movq %rcx, -0x120(%rbp)
movq 0x18(%rax), %rdi
callq 0x805e0
movq %rax, -0x138(%rbp)
leaq -0x120(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x805b0
testb $0x1, %al
jne 0x6a348
jmp 0x6a3ad
movq -0x188(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x190(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x80610
movq -0x188(%rbp), %r8
movq -0x190(%rbp), %rsi
movq %rax, %rdx
addq $0x20, %rdx
movq 0x28(%r8), %rcx
addq $0x38, %r8
leaq -0x118(%rbp), %rdi
callq 0x650d0
jmp 0x6a391
jmp 0x6a46c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
jmp 0x6a481
movq -0x188(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x6a46a
movq -0x10(%rbp), %rdx
addq $0x10, %rdx
leaq 0x5d17e(%rip), %rsi     # 0xc754b
leaq -0x178(%rbp), %rdi
callq 0x1ce80
jmp 0x6a3db
leaq 0x5c2a4(%rip), %rdx     # 0xc6686
leaq -0x158(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0x1fa80
jmp 0x6a3f7
movq -0x188(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x158(%rbp), %rsi
callq 0x726f0
jmp 0x6a410
leaq -0x158(%rbp), %rdi
callq 0xbb98
leaq -0x178(%rbp), %rdi
callq 0xbb98
jmp 0x6a46a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
jmp 0x6a45c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
leaq -0x158(%rbp), %rdi
callq 0xbb98
leaq -0x178(%rbp), %rdi
callq 0xbb98
jmp 0x6a481
jmp 0x6a46c
leaq -0x118(%rbp), %rdi
callq 0x65180
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
leaq -0x118(%rbp), %rdi
callq 0x65180
movq -0x128(%rbp), %rdi
callq 0xba60
nopl (%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const_reference operator[](const typename object_t::key_type& key) const
    {
        // const operator[] only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
            return m_value.object->find(key)->second;
        }

        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4a990
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x6d090
jmp 0x6d121
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6da00
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rdi
callq 0x50060
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x50030
testb $0x1, %al
jne 0x6d0d2
jmp 0x6d0d4
jmp 0x6d0f3
leaq 0x59283(%rip), %rdi     # 0xc635e
leaq 0x5588b(%rip), %rsi     # 0xc296d
movl $0x4e9e, %edx           # imm = 0x4E9E
leaq 0x592a3(%rip), %rcx     # 0xc6391
callq 0xb410
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6da00
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x50090
addq $0x20, %rax
addq $0xa0, %rsp
popq %rbp
retq
movb $0x1, -0x7d(%rbp)
movl $0x20, %edi
callq 0xb2c0
movq -0x88(%rbp), %rdi
movq %rax, -0xa0(%rbp)
callq 0x50ae0
movq %rax, -0x98(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xba70
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x10b90
jmp 0x6d172
leaq 0x591b2(%rip), %rsi     # 0xc632b
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x34d50
jmp 0x6d188
movq -0xa0(%rbp), %rdi
movl $0x131, %esi            # imm = 0x131
leaq -0x48(%rbp), %rdx
callq 0x50990
jmp 0x6d19f
movq -0xa0(%rbp), %rdi
movb $0x0, -0x7d(%rbp)
leaq 0xaec87(%rip), %rsi     # 0x11be38
leaq -0x1c638(%rip), %rdx    # 0x50b80
callq 0xb9f0
jmp 0x6d221
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x6d1f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x6d1f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xbb98
leaq -0x68(%rbp), %rdi
callq 0xbb98
leaq -0x69(%rbp), %rdi
callq 0xb600
testb $0x1, -0x7d(%rbp)
jne 0x6d20a
jmp 0x6d216
movq -0xa0(%rbp), %rdi
callq 0xb460
jmp 0x6d218
movq -0x78(%rbp), %rdi
callq 0xba60
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Renderer::truthy(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const*) const
bool truthy(const json* data) const {
    if (data->is_boolean()) {
      return data->get<bool>();
    } else if (data->is_number()) {
      return (*data != 0);
    } else if (data->is_null()) {
      return false;
    }
    return !data->empty();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x73b40
testb $0x1, %al
jne 0x7181f
jmp 0x7182f
movq -0x18(%rbp), %rdi
callq 0x74250
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x71879
movq -0x18(%rbp), %rdi
callq 0x73b60
testb $0x1, %al
jne 0x7183e
jmp 0x71850
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x74280
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x71879
movq -0x18(%rbp), %rdi
callq 0x6a560
testb $0x1, %al
jne 0x7185f
jmp 0x71865
movb $0x0, -0x1(%rbp)
jmp 0x71879
jmp 0x71867
jmp 0x71869
movq -0x18(%rbp), %rdi
callq 0x742d0
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const> nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::find<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
const_iterator find(KeyT&& key) const
    {
        auto result = cend();

        if (is_object())
        {
            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
        }

        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x28(%rbp)
callq 0x75000
movq -0x28(%rbp), %rdi
callq 0x4a990
testb $0x1, %al
jne 0x730bb
jmp 0x730df
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6da00
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)