LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rcx
movq 0x28(%rsi), %r8
movq 0x20(%rsi), %rdx
xorl %edi, %edi
cmpq %rax, %r8
jae 0x194a6
leaq 0x1(%r8), %r9
movq %r9, 0x28(%rsi)
movb (%rcx,%r8), %r8b
cmpb $0x5c, %r8b
sete %r10b
orb %r10b, %dil
testb $0x1, %dil
jne 0x1949e
cmpb (%rcx,%rdx), %r8b
je 0x194a6
movq %r9, %r8
movl %r10d, %edi
jmp 0x19476
pushq $0xb
popq %rdx
movq %rbx, %rdi
callq 0x18ec0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rcx
xorl %edx, %edx
callq 0x18ef7
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x2d2f9(%rip), %rsi     # 0x4691a
pushq $-0x1
popq %rdx
callq 0x1968a
cmpq $-0x1, %rax
je 0x19665
movq %rax, %r14
pushq $0x1
popq %rbx
xorl %eax, %eax
leaq 0x2d2dc(%rip), %r15     # 0x4691a
leaq 0x8(%rsp), %r12
movq 0x8(%rsp), %rdx
cmpq %rdx, %rax
ja 0x19677
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x196b6
incq %rax
je 0x19672
incq %rbx
jmp 0x19643
movq 0x8(%rsp), %rdx
incq %rdx
pushq $0x1
popq %rbx
jmp 0x1967a
movq 0x8(%rsp), %rdx
subq %r14, %rdx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %rdx, (%r14)
movq %rcx, 0x8(%r14)
leaq 0x40(%rsp), %rdi
callq 0x94a0
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x1690a
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x22d24
leaq 0x10(%rsp), %rdi
callq 0x9898
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
movq 0x128(%rsp,%rax), %rsi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
movl %edx, %r8d
callq 0x22f98
leaq 0x40(%rsp), %rdi
callq 0x90c0
movq %rbx, %rax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r14
retq
jmp 0x1a0c3
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9898
jmp 0x1a0c6
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x90c0
movq %rbx, %rdi
callq 0x97a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %rdx, (%r15)
movq %rcx, 0x8(%r15)
leaq 0x2f5b9(%rip), %rsi     # 0x496b6
pushq $-0x1
popq %rdx
movq %r15, %rdi
callq 0x234fa
leaq 0x1(%rax), %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x189aa
movq %rax, %r15
movq %rdx, %r12
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x38(%r14), %rcx
movq 0x40(%r14), %r8
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x15d36
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x1696a
leaq 0x10(%rsp), %rdi
callq 0x15e26
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x15e26
movq %rbx, %rdi
callq 0x97a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movb (%rdi), %al
cmpb $0x1, %al
sete %dl
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x1d255
testq %rcx, %rcx
sete %dl
cmpb $0x2, %al
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x1d274
testq %rcx, %rcx
sete %dl
cmpb $0x3, %al
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x1d293
testq %rcx, %rcx
sete %cl
cmpb $0x8, %al
sete %al
andb %cl, %al
cmpb $0x1, %al
je 0x1d2b2
popq %rax
retq
leaq 0x2b929(%rip), %rdi     # 0x48b85
leaq 0x29a26(%rip), %rsi     # 0x46c89
leaq 0x2b952(%rip), %rcx     # 0x48bbc
movl $0x4530, %edx           # imm = 0x4530
callq 0x92f0
leaq 0x2baae(%rip), %rdi     # 0x48d29
leaq 0x29a07(%rip), %rsi     # 0x46c89
leaq 0x2b933(%rip), %rcx     # 0x48bbc
movl $0x4531, %edx           # imm = 0x4531
callq 0x92f0
leaq 0x2bac4(%rip), %rdi     # 0x48d5e
leaq 0x299e8(%rip), %rsi     # 0x46c89
leaq 0x2b914(%rip), %rcx     # 0x48bbc
movl $0x4532, %edx           # imm = 0x4532
callq 0x92f0
leaq 0x2badc(%rip), %rdi     # 0x48d95
leaq 0x299c9(%rip), %rsi     # 0x46c89
leaq 0x2b8f5(%rip), %rcx     # 0x48bbc
movl $0x4533, %edx           # imm = 0x4533
callq 0x92f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x38(%rsi), %r13
movq 0x40(%rsi), %rbp
leaq 0x2ba86(%rip), %r14     # 0x48dcc
leaq 0x8(%rsp), %r15
pushq $0x9
popq %r12
cmpq %rbp, %r13
je 0x1d396
movzbl (%r13), %ecx
cmpl $0x1f, %ecx
ja 0x1d386
movb $0x0, 0x10(%rsp)
andq $0x0, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x96f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9830
jmp 0x1d391
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x9360
incq %r13
jmp 0x1d34f
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d3aa
movq %rax, %r14
movq %rbx, %rdi
callq 0x9898
movq %r14, %rdi
callq 0x97a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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>>>>::start_object(unsigned long)
bool start_object(std::size_t len)
    {
        // check callback for object start
        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
        keep_stack.push_back(keep);

        auto val = handle_value(BasicJsonType::value_t::object, true);
        ref_stack.push_back(val.second);

        // check object limit
        if (ref_stack.back() && 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
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x80, %rdi
leaq 0x8(%rbx), %r15
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
leaq 0xa8(%rbx), %rcx
xorl %edx, %edx
callq 0x1eefa
leaq 0x20(%rbx), %rdi
movzbl %al, %esi
callq 0x1e21e
leaq 0x8(%rsp), %rsi
movb $0x1, (%rsi)
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x1ef1e
leaq 0x50(%rsp), %rsi
movb %al, -0x8(%rsi)
movq %rdx, (%rsi)
movq %r15, %rdi
callq 0x1f130
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rdi
testq %rdi, %rdi
sete %al
cmpq $-0x1, %r14
sete %cl
orb %al, %cl
jne 0x1e848
callq 0x1f14e
cmpq %r14, %rax
jb 0x1e855
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x9200
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x19a10
leaq 0x299f4(%rip), %rsi     # 0x48268
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x17df0
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x1ed9e
xorl %ebp, %ebp
leaq 0x526c7(%rip), %rsi     # 0x70f68
leaq 0x31ae(%rip), %rdx      # 0x21a56
movq %rbx, %rdi
callq 0x9760
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x9898
jmp 0x1e8c5
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x9898
testb %bpl, %bpl
jne 0x1e8d9
jmp 0x1e8e1
movq %rax, %r14
movq %rbx, %rdi
callq 0x9320
movq %r14, %rdi
callq 0x97a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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>>>>::start_array(unsigned long)
bool start_array(std::size_t len)
    {
        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
        keep_stack.push_back(keep);

        auto val = handle_value(BasicJsonType::value_t::array, true);
        ref_stack.push_back(val.second);

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

        return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x80, %rdi
leaq 0x8(%rbx), %r15
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
leaq 0xa8(%rbx), %rcx
pushq $0x2
popq %rdx
callq 0x1eefa
leaq 0x20(%rbx), %rdi
movzbl %al, %esi
callq 0x1e21e
leaq 0x8(%rsp), %rsi
movb $0x2, (%rsi)
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x1ef1e
leaq 0x50(%rsp), %rsi
movb %al, -0x8(%rsi)
movq %rdx, (%rsi)
movq %r15, %rdi
callq 0x1f130
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rdi
testq %rdi, %rdi
sete %al
cmpq $-0x1, %r14
sete %cl
orb %al, %cl
jne 0x1ebbf
callq 0x1f14e
cmpq %r14, %rax
jb 0x1ebcc
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x9200
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x19a10
leaq 0x29a30(%rip), %rsi     # 0x4861b
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x17df0
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x1ed9e
xorl %ebp, %ebp
leaq 0x52350(%rip), %rsi     # 0x70f68
leaq 0x2e37(%rip), %rdx      # 0x21a56
movq %rbx, %rdi
callq 0x9760
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x9898
jmp 0x1ec3c
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x9898
testb %bpl, %bpl
jne 0x1ec50
jmp 0x1ec58
movq %rax, %r14
movq %rbx, %rdi
callq 0x9320
movq %r14, %rdi
callq 0x97a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq -0x8(%rsi), %rcx
movb $0x1, %bpl
testq %rcx, %rcx
je 0x1ecc4
leaq 0x80(%rbx), %rdi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
decl %esi
pushq $0x3
popq %rdx
callq 0x1eefa
testb %al, %al
jne 0x1ecc4
leaq 0xa8(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x1f4fc
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rdi
movq %r14, %rsi
callq 0xceca
movq %r14, %rdi
callq 0xccf0
xorl %ebp, %ebp
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x1ed1b
movq 0x20(%rbx), %rcx
cmpq 0x30(%rbx), %rcx
jne 0x1ecde
cmpl $0x0, 0x38(%rbx)
je 0x1ed3a
leaq 0x30(%rbx), %rdi
addq $-0x8, %rax
movq %rax, 0x10(%rbx)
callq 0x1e5e0
testb %bpl, %bpl
jne 0x1ed10
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x1ed10
movq -0x8(%rax), %rax
cmpb $0x2, (%rax)
jne 0x1ed10
movq 0x8(%rax), %rdi
callq 0x20970
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x296af(%rip), %rdi     # 0x483d1
leaq 0x27f60(%rip), %rsi     # 0x46c89
leaq 0x29902(%rip), %rcx     # 0x48632
movl $0x1621, %edx           # imm = 0x1621
callq 0x92f0
leaq 0x2953f(%rip), %rdi     # 0x48280
leaq 0x27f41(%rip), %rsi     # 0x46c89
leaq 0x298e3(%rip), %rcx     # 0x48632
movl $0x1622, %edx           # imm = 0x1622
callq 0x92f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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>>>>::operator->() const
pointer operator->() const
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_type)
        {
            case value_t::object:
            {
                JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
                return &(m_it.object_iterator->second);
            }

            case value_t::array:
            {
                JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
                return &*m_it.array_iterator;
            }

            default:
            {
                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
                {
                    return m_object;
                }

                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x1f643
movzbl (%rax), %ecx
cmpl $0x2, %ecx
je 0x1f5b8
cmpl $0x1, %ecx
jne 0x1f5e5
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq 0x8(%rdi), %rax
cmpq %rcx, %rax
je 0x1f662
addq $0x40, %rax
jmp 0x1f5ec
movq 0x8(%rax), %rcx
movq 0x10(%rdi), %rax
cmpq 0x8(%rcx), %rax
jne 0x1f5ec
leaq 0x28f5f(%rip), %rdi     # 0x4852c
leaq 0x276b5(%rip), %rsi     # 0x46c89
leaq 0x28ea0(%rip), %rcx     # 0x4847b
movl $0x2b33, %edx           # imm = 0x2B33
callq 0x92f0
cmpq $0x0, 0x18(%rdi)
jne 0x1f5f5
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x9200
movq %rax, %rbx
leaq 0x28f5b(%rip), %rsi     # 0x48562
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xc0a4
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0xd6, %esi
callq 0x2006c
xorl %ebp, %ebp
leaq 0x5194c(%rip), %rsi     # 0x70f80
leaq 0x241b(%rip), %rdx      # 0x21a56
movq %rbx, %rdi
callq 0x9760
leaq 0x28e1d(%rip), %rdi     # 0x48467
leaq 0x27638(%rip), %rsi     # 0x46c89
leaq 0x28e23(%rip), %rcx     # 0x4847b
movl $0x2b27, %edx           # imm = 0x2B27
callq 0x92f0
leaq 0x28e8b(%rip), %rdi     # 0x484f4
leaq 0x27619(%rip), %rsi     # 0x46c89
leaq 0x28e04(%rip), %rcx     # 0x4847b
movl $0x2b2d, %edx           # imm = 0x2B2D
callq 0x92f0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x9898
testb %bpl, %bpl
jne 0x1f698
jmp 0x1f6a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x9320
movq %r14, %rdi
callq 0x97a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
leaq 0x8(%rsp), %rsi
movb $0x1, (%rsi)
callq 0x21d90
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x21e72
cmpq $-0x1, %r14
je 0x21b45
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rdi
callq 0x1f14e
cmpq %r14, %rax
jb 0x21b52
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x9200
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x19a10
leaq 0x266f7(%rip), %rsi     # 0x48268
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x17df0
movb $0x1, %bpl
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x1ed9e
xorl %ebp, %ebp
leaq 0x4f3ca(%rip), %rsi     # 0x70f68
leaq -0x14f(%rip), %rdx      # 0x21a56
movq %rbx, %rdi
callq 0x9760
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x9898
jmp 0x21bc2
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x9898
testb %bpl, %bpl
jne 0x21bd6
jmp 0x21bde
movq %rax, %r14
movq %rbx, %rdi
callq 0x9320
movq %r14, %rdi
callq 0x97a0
// File: /workspace/github_cpp_makefile_star2_O2/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>>>* 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>>>>::handle_value<nlohmann::detail::value_t>(nlohmann::detail::value_t&&)
JSON_HEDLEY_RETURNS_NON_NULL
    BasicJsonType* handle_value(Value&& v)
    {
        if (ref_stack.empty())
        {
            root = BasicJsonType(std::forward<Value>(v));
            return &root;
        }

        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());

        if (ref_stack.back()->is_array())
        {
            ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
            return &(ref_stack.back()->m_value.array->back());
        }

        JSON_ASSERT(ref_stack.back()->is_object());
        JSON_ASSERT(object_element);
        *object_element = BasicJsonType(std::forward<Value>(v));
        return object_element;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x21dd4
movq -0x8(%rax), %rax
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x21dfc
cmpl $0x2, %ecx
jne 0x21e33
movq 0x8(%rax), %rdi
callq 0x21f6e
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
addq $-0x10, %rax
jmp 0x21e2b
movzbl (%rsi), %esi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x1d7d8
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xceca
movq %r14, %rdi
callq 0xccf0
movq (%rbx), %rax
jmp 0x21e2b
cmpq $0x0, 0x20(%rbx)
je 0x21e52
movzbl (%rsi), %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1d7d8
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xceca
movq %r14, %rdi
callq 0xccf0
movq 0x20(%rbx), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x26532(%rip), %rdi     # 0x4836c
leaq 0x24e48(%rip), %rsi     # 0x46c89
leaq 0x27385(%rip), %rcx     # 0x491cd
movl $0x1563, %edx           # imm = 0x1563
callq 0x92f0
leaq 0x26569(%rip), %rdi     # 0x483c2
leaq 0x24e29(%rip), %rsi     # 0x46c89
leaq 0x27366(%rip), %rcx     # 0x491cd
movl $0x156c, %edx           # imm = 0x156C
callq 0x92f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
cmpb $0x3, (%rdi)
jne 0x22c0c
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x22c0c
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x9200
movq %rax, %rbx
movq %r14, %rdi
callq 0x20438
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0xc0a4
leaq 0x26a20(%rip), %rsi     # 0x49658
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x17df0
movb $0x1, %bpl
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
movl $0x12f, %esi            # imm = 0x12F
callq 0x20382
xorl %ebp, %ebp
leaq 0x4e383(%rip), %rsi     # 0x70fe8
leaq -0x1216(%rip), %rdx     # 0x21a56
movq %rbx, %rdi
callq 0x9760
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x9898
jmp 0x22c89
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x9898
testb %bpl, %bpl
jne 0x22c9d
jmp 0x22ca5
movq %rax, %r14
movq %rbx, %rdi
callq 0x9320
movq %r14, %rdi
callq 0x97a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rax
movq -0x18(%rax), %rdi
addq %rsi, %rdi
pushq $0x5
popq %rsi
callq 0x90f0
pushq $0x8
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9370
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x22e06
movq %r14, %rdi
callq 0x9170
pushq $0x60
popq %rdi
callq 0x9200
movq %rax, %rbx
leaq 0x2690b(%rip), %rsi     # 0x49690
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0xfdb9
leaq 0x26095(%rip), %rdx     # 0x48e2e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1093d
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x22e16
xorl %ebp, %ebp
leaq 0x4e2cf(%rip), %rsi     # 0x71090
leaq 0x9d70(%rip), %rdx      # 0x2cb38
movq %rbx, %rdi
callq 0x9760
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x9898
jmp 0x22de5
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x9898
testb %bpl, %bpl
jne 0x22df9
jmp 0x22e01
movq %rax, %r14
movq %rbx, %rdi
callq 0x9320
callq 0x9730
movq %r14, %rdi
callq 0x97a0
movq %rax, %rdi
callq 0xc99e
// File: /workspace/github_cpp_makefile_star2_O2/Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::FunctionStorage::find_function(std::basic_string_view<char, std::char_traits<char>>, int) const
FunctionData find_function(nonstd::string_view name, int num_args) const {
    auto it = function_storage.find(std::make_pair(static_cast<std::string>(name), num_args));
    if (it != function_storage.end()) {
      return it->second;

    // Find variadic function
    } else if (num_args > 0) {
      it = function_storage.find(std::make_pair(static_cast<std::string>(name), VARIADIC));
      if (it != function_storage.end()) {
        return it->second;
      }
    }

    return FunctionData { Operation::None };
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %rsi
movq %rdx, (%rsi)
movq %rcx, 0x8(%rsi)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1690a
leaq 0x8(%r14), %r15
leaq 0x40(%rsp), %rcx
movq %rcx, -0x10(%rcx)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0x24242
movq %rdx, 0x30(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x40(%rsp)
jmp 0x24248
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x18(%rsp), %rcx
movq %rax, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
leaq 0x30(%rsp), %rsi
movq %rcx, 0x8(%rsi)
movb $0x0, 0x20(%rsp)
movl %ebp, 0x20(%rsi)
movq %r15, %rdi
callq 0x25d6a
movq %rax, %r12
leaq 0x30(%rsp), %rdi
callq 0x9898
leaq 0x10(%rsp), %rdi
callq 0x9898
leaq 0x10(%r14), %rax
cmpq %rax, %r12
je 0x242a5
addq $0x48, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x15b88
jmp 0x2432d
testl %ebp, %ebp
jle 0x24305
leaq 0x10(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0xf(%rsp), %rdx
callq 0x1690a
leaq 0x30(%rsp), %r13
leaq 0x10(%rsp), %rsi
movq %r13, %rdi
movq %r14, %rdx
callq 0x25de0
movq %r15, %rdi
movq %r13, %rsi
callq 0x25d6a
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x9898
leaq 0x10(%rsp), %rdi
callq 0x9898
cmpq %r12, %r14
je 0x24305
addq $0x48, %r14
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x2429b
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x2e, (%rbx)
leaq 0x8(%rbx), %rdi
callq 0x15730
leaq 0x30(%rsp), %rdi
callq 0x33e76
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x33e76
jmp 0x2436e
jmp 0x24352
jmp 0x2436b
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x9898
leaq 0x10(%rsp), %rdi
callq 0x9898
jmp 0x2436e
movq %rax, %rbx
movq %rbx, %rdi
callq 0x97a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
pushq $0x2f
popq %r15
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
pushq $0x2e
popq %rcx
callq 0x252a5
movq 0x8(%rsp), %r14
movq 0x10(%rsp), %rbp
movq 0x18(%rsp), %r13
movq 0x20(%rsp), %r12
movq %rbx, %rdi
movl %r15d, %esi
callq 0x9360
addq %rbp, %r14
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x25332
testq %r13, %r13
jne 0x251eb
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25247
movq %rax, %r14
movq %rbx, %rdi
callq 0x9898
movq %r14, %rdi
callq 0x97a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movl %ecx, %esi
xorl %edx, %edx
callq 0x25348
cmpq $-0x1, %rax
je 0x25314
movq %rax, %r14
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x18ef7
movq %rax, %r15
movq %rdx, %r12
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
incq %r14
pushq $-0x1
popq %rcx
movq %r14, %rdx
callq 0x18ef7
movq %r15, (%rbx)
movq %r12, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
jmp 0x25323
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, 0x30(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x28(%rdi)
testq %r8, %r8
je 0x25f81
movq %rsp, %r14
movq %r14, %rdi
movq %r8, %rsi
callq 0x1f4fc
leaq 0x38(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xceca
movq %r14, %rdi
callq 0xccf0
leaq 0x239d3(%rip), %rsi     # 0x49944
movq %r15, %rdi
callq 0x25fdc
movq %rax, 0x48(%rbx)
movq 0x10(%rbx), %rdx
movq (%rbx), %rax
movq %rbx, %rdi
movq %rdx, %rsi
callq *(%rax)
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x300f6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Renderer::visit(inja::JsonNode const&)
void visit(const JsonNode& node) {
    if (json_additional_data.contains(node.ptr)) {
      json_eval_stack.push(&(json_additional_data[node.ptr]));
    
    } else if (json_input->contains(node.ptr)) {
      json_eval_stack.push(&(*json_input)[node.ptr]);
    
    } else {
      // Try to evaluate as a no-argument callback
      auto function_data = function_storage.find_function(node.name, 0);
      if (function_data.operation == FunctionStorage::Operation::Callback) {
        Arguments empty_args {};
        auto value = std::make_shared<json>(function_data.callback(empty_args));
        json_tmp_stack.push_back(value);
        json_eval_stack.push(value.get());

      } else {
        json_eval_stack.push(nullptr);
        not_found_stack.emplace(&node);
      }
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rdi), %r12
leaq 0x30(%rsi), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2917a
testb %al, %al
je 0x261f5
addq $0x68, %rbx
movq %r15, %rdi
movq %r12, %rsi
callq 0x298a4
jmp 0x26215
movq 0x28(%rbx), %rsi
movq %r15, %rdi
callq 0x2917a
testb %al, %al
je 0x2622a
movq 0x28(%rbx), %rsi
addq $0x68, %rbx
movq %r15, %rdi
callq 0x29f9c
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x28eb8
jmp 0x262ec
movq 0x20(%rbx), %rsi
movq 0x10(%r14), %rcx
movq 0x18(%r14), %rdx
leaq 0x40(%rsp), %r15
movq %r15, %rdi
xorl %r8d, %r8d
callq 0x241e4
cmpl $0x2b, (%r15)
jne 0x262b9
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
leaq 0x48(%rsp), %rsi
movq %rsp, %rdi
callq 0x29136
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x29118
movq %rsp, %rdi
callq 0xccf0
leaq 0x50(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2914e
addq $0x68, %rbx
movq 0x10(%rsp), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x28eb8
leaq 0x18(%rsp), %rdi
callq 0xd76e
leaq 0x20(%rsp), %rdi
callq 0x2a44e
jmp 0x262e2
leaq 0x68(%rbx), %rdi
leaq 0x20(%rsp), %rsi
andq $0x0, (%rsi)
callq 0x28eb8
addq $0xb8, %rbx
leaq 0x20(%rsp), %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x2a482
leaq 0x48(%rsp), %rdi
callq 0x33e76
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x262fa
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xd76e
jmp 0x26320
jmp 0x26318
movq %rax, %rbx
movq %rsp, %rdi
callq 0xccf0
jmp 0x26320
movq %rax, %rbx
jmp 0x2632a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2a44e
leaq 0x48(%rsp), %rdi
callq 0x33e76
movq %rbx, %rdi
callq 0x97a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsi), %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2fbba
movq (%r15), %rsi
movq %r14, %rdi
callq 0x2a930
testb %al, %al
je 0x2869a
pushq $0x38
jmp 0x286a5
cmpb $0x1, 0x91(%rbx)
jne 0x286b4
pushq $0x60
popq %rax
addq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
leaq 0x8(%rsp), %rdi
callq 0xd76e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xd76e
movq %rbx, %rdi
callq 0x97a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %rcx
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x25e82
movq 0x18(%rbx), %rdi
leaq 0x10(%r14), %r12
movq %r12, %rsi
callq 0x30080
movq 0x18(%rbx), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x2874a
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rsi
addq $0x40, %rax
addq $0x38, %rbx
leaq 0x40(%rsp), %rdi
movq %rax, %rdx
movq %rbx, %r8
callq 0x25f28
jmp 0x28798
cmpb $0x1, (%r15)
jne 0x28798
leaq 0x22027(%rip), %rsi     # 0x4a77e
movq %rsp, %rdi
movq %r12, %rdx
callq 0xfdb9
leaq 0x2153b(%rip), %rdx     # 0x49ca4
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x1093d
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2b03a
leaq 0x20(%rsp), %rdi
callq 0x9898
movq %rsp, %rdi
callq 0x9898
leaq 0x40(%rsp), %rdi
callq 0x25fa2
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9898
jmp 0x287c3
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9898
jmp 0x287d2
jmp 0x287cf
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x25fa2
movq %rbx, %rdi
callq 0x97a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0x292fa
movq %rsi, %rbx
movq 0x8(%r14), %rdi
callq 0x29790
movq 0x8(%r14), %rdi
leaq 0x8(%rdi), %rcx
cmpq %rcx, %rax
je 0x29362
movq %rbx, %rsi
callq 0x29790
addq $0x40, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x9200
movq %rax, %rbx
movq %r14, %rdi
callq 0x20438
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0xc0a4
leaq 0x20623(%rip), %rsi     # 0x49949
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x17df0
movb $0x1, %bpl
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
callq 0x20382
xorl %ebp, %ebp
leaq 0x47c95(%rip), %rsi     # 0x70fe8
leaq -0x7904(%rip), %rdx     # 0x21a56
movq %rbx, %rdi
callq 0x9760
leaq 0x20613(%rip), %rdi     # 0x4997c
leaq 0x1d919(%rip), %rsi     # 0x46c89
leaq 0x20638(%rip), %rcx     # 0x499af
movl $0x4e9e, %edx           # imm = 0x4E9E
callq 0x92f0
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x9898
jmp 0x29396
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x9898
testb %bpl, %bpl
jne 0x293aa
jmp 0x293b2
movq %rax, %r14
movq %rbx, %rdi
callq 0x9320
movq %r14, %rdi
callq 0x97a0
// File: /workspace/github_cpp_makefile_star2_O2/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>>>::at(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const_reference at(const typename object_t::key_type& key) const
    {
        // at only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            JSON_TRY
            {
                return m_value.object->at(key);
            }
            JSON_CATCH (std::out_of_range&)
            {
                // create better exception explanation
                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0x2b249
movq %rsi, %r15
movq 0x8(%r14), %rdi
callq 0x2cc24
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x9200
movq %rax, %rbx
movq %r14, %rdi
callq 0x20438
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0xc0a4
leaq 0x1ece1(%rip), %rsi     # 0x49f56
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x17df0
movb $0x1, %bpl
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x130, %esi            # imm = 0x130
callq 0x20382
xorl %ebp, %ebp
leaq 0x45d46(%rip), %rsi     # 0x70fe8
leaq -0x9853(%rip), %rdx     # 0x21a56
movq %rbx, %rdi
callq 0x9760
jmp 0x2b329
movq %rax, %r14
cmpl $0x1, %edx
jne 0x2b39a
movq %r14, %rdi
callq 0x9170
pushq $0x20
popq %rdi
callq 0x9200
movq %rax, %rbx
leaq 0x1ec77(%rip), %rsi     # 0x49f50
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0xfdb9
leaq 0x1e9b7(%rip), %rdx     # 0x49ca4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1093d
movb $0x1, %bpl
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x193, %esi            # imm = 0x193
callq 0x1ed9e
xorl %ebp, %ebp
leaq 0x45c4e(%rip), %rsi     # 0x70f68
leaq -0x98cb(%rip), %rdx     # 0x21a56
movq %rbx, %rdi
callq 0x9760
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x9898
jmp 0x2b33e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x9898
testb %bpl, %bpl
jne 0x2b352
jmp 0x2b35a
movq %rax, %r14
movq %rbx, %rdi
callq 0x9320
callq 0x9730
jmp 0x2b39a
movq %rax, %rdi
callq 0xc99e
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x9898
jmp 0x2b37e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x9898
testb %bpl, %bpl
jne 0x2b392
jmp 0x2b39a
movq %rax, %r14
movq %rbx, %rdi
callq 0x9320
movq %r14, %rdi
callq 0x97a0
// File: /workspace/github_cpp_makefile_star2_O2/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>>>::at(unsigned long) const
const_reference at(size_type idx) const
    {
        // at only works for arrays
        if (JSON_HEDLEY_LIKELY(is_array()))
        {
            JSON_TRY
            {
                return m_value.array->at(idx);
            }
            JSON_CATCH (std::out_of_range&)
            {
                // create better exception explanation
                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0x2b3cb
movq %rsi, %r15
movq 0x8(%r14), %rdi
callq 0x2cc6a
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x9200
movq %rax, %rbx
movq %r14, %rdi
callq 0x20438
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %rax, %rsi
callq 0xc0a4
leaq 0x1eb5f(%rip), %rsi     # 0x49f56
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x17df0
movb $0x1, %bpl
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x130, %esi            # imm = 0x130
callq 0x20382
xorl %ebp, %ebp
leaq 0x45bc4(%rip), %rsi     # 0x70fe8
leaq -0x99d5(%rip), %rdx     # 0x21a56
movq %rbx, %rdi
callq 0x9760
jmp 0x2b4bd
movq %rax, %r14
cmpl $0x1, %edx
jne 0x2b540
movq %r14, %rdi
callq 0x9170
pushq $0x20
popq %rdi
callq 0x9200
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x19a10
leaq 0x1e730(%rip), %rsi     # 0x49b9b
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x17df0
leaq 0x1e79f(%rip), %rdx     # 0x49c20
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1093d
movb $0x1, %bpl
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x191, %esi            # imm = 0x191
callq 0x1ed9e
xorl %ebp, %ebp
leaq 0x45aba(%rip), %rsi     # 0x70f68
leaq -0x9a5f(%rip), %rdx     # 0x21a56
movq %rbx, %rdi
callq 0x9760
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x9898
jmp 0x2b4d2
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x9898
jmp 0x2b4e4
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rdi
callq 0x9898
testb %bpl, %bpl
jne 0x2b4f8
jmp 0x2b500
movq %rax, %r14
movq %rbx, %rdi
callq 0x9320
callq 0x9730
jmp 0x2b540
movq %rax, %rdi
callq 0xc99e
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x9898
jmp 0x2b524
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x9898
testb %bpl, %bpl
jne 0x2b538
jmp 0x2b540
movq %rax, %r14
movq %rbx, %rdi
callq 0x9320
movq %r14, %rdi
callq 0x97a0