LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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&)
reference operator[](const typename object_t::key_type& key)
    {
        // implicitly convert null value to an empty object
        if (is_null())
        {
            m_type = value_t::object;
            m_value.object = create<object_t>();
            assert_invariant();
        }

        // operator[] only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            return m_value.object->operator[](key);
        }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, (%rdi)
jne 0xeea3
movb $0x1, (%r14)
movl $0x30, %edi
callq 0x93b0
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x2450a
cmpb $0x1, (%r14)
jne 0xeebf
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x28720
movl $0x20, %edi
callq 0x91f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x2858a
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, %rdi
callq 0x91b0
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x12646
leaq 0x4a904(%rip), %rsi     # 0x59804
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1dc69
movb $0x1, %bpl
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
callq 0x28424
xorl %ebp, %ebp
leaq 0x690c3(%rip), %rsi     # 0x77ff0
leaq 0x1b726(%rip), %rdx     # 0x2a65a
movq %rbx, %rdi
callq 0x9750
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xef62
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x93c0
jmp 0xef62
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xef81
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x93c0
jmp 0xef81
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xef8e
movq %rbx, %rdi
callq 0x92e0
movq %r14, %rdi
callq 0x9790
// File: /workspace/github_cpp_makefile_star2_O1/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>>>>::key() const
const typename object_t::key_type& key() const
    {
        JSON_ASSERT(m_object != nullptr);

        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
        {
            return m_it.object_iterator->first;
        }

        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xf0bf
cmpb $0x1, (%rax)
jne 0xf064
movq 0x8(%rdi), %rax
addq $0x20, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x91f0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4c120(%rip), %rsi     # 0x5b1a1
leaq 0x4c142(%rip), %rdx     # 0x5b1ca
leaq 0x8(%rsp), %rdi
callq 0x12646
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xcf, %esi
callq 0x27eb0
xorl %ebp, %ebp
leaq 0x68ed8(%rip), %rsi     # 0x77f88
leaq 0x1b5a3(%rip), %rdx     # 0x2a65a
movq %rbx, %rdi
callq 0x9750
leaq 0x49401(%rip), %rdi     # 0x584c7
leaq 0x47c1c(%rip), %rsi     # 0x56ce9
leaq 0x4c040(%rip), %rcx     # 0x5b114
movl $0x2c74, %edx           # imm = 0x2C74
callq 0x92a0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xf100
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x93c0
jmp 0xf100
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xf10d
movq %rbx, %rdi
callq 0x92e0
movq %r14, %rdi
callq 0x9790
nop
// File: /workspace/github_cpp_makefile_star2_O1/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++()
iter_impl& operator++()
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_type)
        {
            case value_t::object:
            {
                std::advance(m_it.object_iterator, 1);
                break;
            }

            case value_t::array:
            {
                std::advance(m_it.array_iterator, 1);
                break;
            }

            default:
            {
                ++m_it.primitive_iterator;
                break;
            }
        }

        return *this;
    }

// Assembly:
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xf14e
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0xf13e
cmpl $0x1, %eax
jne 0xf145
movq 0x8(%rbx), %rdi
callq 0x92c0
movq %rax, 0x8(%rbx)
jmp 0xf149
addq $0x10, 0x10(%rbx)
jmp 0xf149
incq 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0x49372(%rip), %rdi     # 0x584c7
leaq 0x47b8d(%rip), %rsi     # 0x56ce9
leaq 0x4bf2c(%rip), %rcx     # 0x5b08f
movl $0x2b54, %edx           # imm = 0x2B54
callq 0x92a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Environment::set_expression(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&)
void set_expression(const std::string &open, const std::string &close) {
    lexer_config.expression_open = open;
    lexer_config.expression_open_force_lstrip = open + "-";
    lexer_config.expression_close = close;
    lexer_config.expression_close_force_rstrip = "-" + close;
    lexer_config.update_open_chars();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x100, %rdi            # imm = 0x100
callq 0x9220
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3c29c
leaq 0x47645(%rip), %rsi     # 0x569d1
movq %r15, %rdi
callq 0x9820
leaq 0x120(%rbx), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x94f0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xf3bd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x93c0
leaq 0x140(%rbx), %rdi
movq %r14, %rsi
callq 0x9220
leaq 0x475fe(%rip), %rsi     # 0x569d1
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x124ba
leaq 0x160(%rbx), %rdi
movq %r15, %rsi
callq 0x94f0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xf407
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x93c0
addq $0x40, %rbx
movq %rbx, %rdi
callq 0x1a8ea
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xf439
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x93c0
movq %rbx, %rdi
callq 0x9790
nop
// File: /workspace/github_cpp_makefile_star2_O1/Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Environment::set_statement(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&)
void set_statement(const std::string &open, const std::string &close) {
    lexer_config.statement_open = open;
    lexer_config.statement_open_no_lstrip = open + "+";
    lexer_config.statement_open_force_lstrip = open + "-";
    lexer_config.statement_close = close;
    lexer_config.statement_close_force_rstrip = "-" + close;
    lexer_config.update_open_chars();
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x40(%rdi), %rbx
movq %rbx, %rdi
callq 0x9220
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x3c29c
leaq 0x4753f(%rip), %rsi     # 0x569cd
movq %r13, %rdi
callq 0x9820
leaq 0x60(%r14), %rdi
leaq 0x8(%rsp), %r13
movq %r13, %rsi
callq 0x94f0
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0xf4bd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x93c0
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x3c29c
leaq 0x474eb(%rip), %rsi     # 0x569d1
movq %r12, %rdi
callq 0x9820
leaq 0x80(%r14), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x94f0
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0xf518
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x93c0
leaq 0xa0(%r14), %rdi
movq %r15, %rsi
callq 0x9220
leaq 0x474a3(%rip), %rsi     # 0x569d1
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x124ba
addq $0xc0, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x94f0
movq (%r12), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xf56b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x93c0
movq %rbx, %rdi
callq 0x1a8ea
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf584
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xf59d
movq (%rbp), %rsi
incq %rsi
callq 0x93c0
movq %rbx, %rdi
callq 0x9790
nop
// File: /workspace/github_cpp_makefile_star2_O1/Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::LexerConfig::update_open_chars()
void update_open_chars() {
    open_chars = "";
    if (open_chars.find(line_statement[0]) == std::string::npos) {
      open_chars += line_statement[0];
    }
    if (open_chars.find(statement_open[0]) == std::string::npos) {
      open_chars += statement_open[0];
    }
    if (open_chars.find(statement_open_no_lstrip[0]) == std::string::npos) {
      open_chars += statement_open_no_lstrip[0];
    }
    if (open_chars.find(statement_open_force_lstrip[0]) == std::string::npos) {
      open_chars += statement_open_force_lstrip[0];
    }
    if (open_chars.find(expression_open[0]) == std::string::npos) {
      open_chars += expression_open[0];
    }
    if (open_chars.find(expression_open_force_lstrip[0]) == std::string::npos) {
      open_chars += expression_open_force_lstrip[0];
    }
    if (open_chars.find(comment_open[0]) == std::string::npos) {
      open_chars += comment_open[0];
    }
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x180(%rdi), %rbx
movq 0x188(%rdi), %rdx
leaq 0x3c075(%rip), %rcx     # 0x5697b
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x96a0
movq 0xa0(%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9550
cmpq $-0x1, %rax
jne 0x1a93f
movq 0xa0(%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x9340
movq (%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9550
cmpq $-0x1, %rax
jne 0x1a963
movq (%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x9340
movq 0x20(%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9550
cmpq $-0x1, %rax
jne 0x1a989
movq 0x20(%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x9340
movq 0x40(%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9550
cmpq $-0x1, %rax
jne 0x1a9af
movq 0x40(%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x9340
movq 0xc0(%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9550
cmpq $-0x1, %rax
jne 0x1a9db
movq 0xc0(%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x9340
movq 0xe0(%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9550
cmpq $-0x1, %rax
jne 0x1aa07
movq 0xe0(%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x9340
movq 0x140(%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9550
cmpq $-0x1, %rax
je 0x1aa29
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x140(%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9340
// File: /workspace/github_cpp_makefile_star2_O1/Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Lexer::start(std::basic_string_view<char, std::char_traits<char>>)
void start(nonstd::string_view input) {
    m_in = input;
    tok_start = 0;
    pos = 0;
    state = State::Text;
    minus_state = MinusState::Number;

    // Consume byte order mark (BOM) for UTF-8
    if (inja::string_view::starts_with(m_in, "\xEF\xBB\xBF")) {
      m_in = m_in.substr(3);
    }
  }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x3, %rsi
jb 0x1c3fc
movq %rdi, %rbx
leaq 0x3a788(%rip), %r8      # 0x56b55
movq %rsp, %rdi
movl $0x3, %edx
movl $0x3, %ecx
xorl %esi, %esi
callq 0x1ec56
testl %eax, %eax
jne 0x1c3fc
movq 0x10(%rbx), %rcx
cmpq $0x2, %rcx
jbe 0x1c402
addq $-0x3, %rcx
movq %rcx, 0x10(%rbx)
addq $0x3, 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x3a76a(%rip), %rdi     # 0x56b73
leaq 0x3a749(%rip), %rsi     # 0x56b59
movl $0x3, %edx
xorl %eax, %eax
callq 0x9670
// File: /workspace/github_cpp_makefile_star2_O1/Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Token::describe[abi:cxx11]() const
std::string describe() const {
    switch (kind) {
    case Kind::Text:
      return "<text>";
    case Kind::LineStatementClose:
      return "<eol>";
    case Kind::Eof:
      return "<eof>";
    default:
      return static_cast<std::string>(text);
    }
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x22, %eax
je 0x1dd1c
cmpl $0x4, %eax
je 0x1dd05
testl %eax, %eax
jne 0x1dd36
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3b878(%rip), %rsi     # 0x59574
leaq 0x3b877(%rip), %rdx     # 0x5957a
jmp 0x1dd31
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3b868(%rip), %rsi     # 0x5957b
leaq 0x3b866(%rip), %rdx     # 0x59580
jmp 0x1dd31
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3b857(%rip), %rsi     # 0x59581
leaq 0x3b855(%rip), %rdx     # 0x59586
movq %rbx, %rdi
jmp 0x1dd4e
movq 0x10(%rsi), %rax
leaq 0x10(%rbx), %rcx
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12646
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Lexer::clear_final_line_if_whitespace(std::basic_string_view<char, std::char_traits<char>>)
static nonstd::string_view clear_final_line_if_whitespace(nonstd::string_view text) {
    nonstd::string_view result = text;
    while (!result.empty()) {
      char ch = result.back();
      if (ch == ' ' || ch == '\t') {
        result.remove_suffix(1);
      } else if (ch == '\n' || ch == '\r') {
        break;
      } else {
        return text;
      }
    }
    return result;
  }

// Assembly:
movq %rsi, %rdx
movq %rdi, %rax
movq %rdi, %rcx
testq %rcx, %rcx
je 0x1f370
movzbl -0x1(%rdx,%rcx), %edi
movl $0x3, %esi
cmpl $0xc, %edi
jg 0x1f351
cmpl $0x9, %edi
je 0x1f35b
cmpl $0xa, %edi
je 0x1f367
jmp 0x1f362
cmpl $0xd, %edi
je 0x1f367
cmpl $0x20, %edi
jne 0x1f362
decq %rcx
xorl %esi, %esi
jmp 0x1f367
movl $0x1, %esi
testl %esi, %esi
je 0x1f331
cmpl $0x3, %esi
jne 0x1f373
movq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, (%rsp)
movq 0x10(%rsi), %rbx
movq 0x28(%rsi), %r12
cmpq %rbx, %r12
jae 0x1fd24
movq 0x18(%r14), %r13
movq %rbx, %r15
negq %r15
incq %r12
movsbl -0x1(%r13,%r12), %ebp
movl %ebp, %edi
callq 0x93f0
testl %eax, %eax
jne 0x1fd10
movzbl %bpl, %eax
leal -0x2d(%rax), %ecx
cmpl $0x3, %ecx
jb 0x1fd10
cmpl $0x5f, %eax
jne 0x1fd24
movq %r12, 0x28(%r14)
leaq (%r15,%r12), %rax
incq %rax
incq %r12
cmpq $0x1, %rax
jne 0x1fcee
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
cmpq %rdx, %rbx
cmovbq %rbx, %rdx
cmpq %rcx, %rdx
cmovaq %rdx, %rcx
cmpq %rbx, %rcx
cmovaeq %rbx, %rcx
subq %rdx, %rcx
subq %rdx, %rbx
cmpq %rcx, %rbx
cmovaeq %rcx, %rbx
addq 0x18(%r14), %rdx
movq (%rsp), %rax
movl $0x9, (%rax)
movq %rbx, 0x8(%rax)
movq %rdx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdi, %rax
movq 0x10(%rsi), %rcx
movq 0x28(%rsi), %rdx
cmpq %rcx, %rdx
jae 0x1fdd6
movq 0x18(%rsi), %rdi
movq %rcx, %r8
negq %r8
incq %rdx
movabsq $0x40000000400000d, %r9 # imm = 0x40000000400000D
movb -0x1(%rdi,%rdx), %r10b
movsbl %r10b, %r11d
addl $-0x3a, %r11d
cmpl $-0xb, %r11d
ja 0x1fdc2
movzbl %r10b, %r10d
addl $-0x2b, %r10d
cmpl $0x3a, %r10d
ja 0x1fdd6
btq %r10, %r9
jae 0x1fdd6
movq %rdx, 0x28(%rsi)
leaq (%r8,%rdx), %r10
incq %r10
incq %rdx
cmpq $0x1, %r10
jne 0x1fd9b
movq 0x20(%rsi), %rdx
movq 0x28(%rsi), %rdi
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
cmpq %rdi, %rdx
cmovaq %rdx, %rdi
cmpq %rcx, %rdi
cmovaeq %rcx, %rdi
subq %rdx, %rdi
subq %rdx, %rcx
cmpq %rdi, %rcx
cmovaeq %rdi, %rcx
addq 0x18(%rsi), %rdx
movl $0xa, (%rax)
movq %rcx, 0x8(%rax)
movq %rdx, 0x10(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rax
movq 0x10(%rsi), %rcx
movq 0x18(%rsi), %rdx
movq 0x28(%rsi), %r9
movq 0x20(%rsi), %rdi
xorl %r8d, %r8d
xorl %r10d, %r10d
cmpq %rcx, %r9
jae 0x1fe6d
movq %r9, %r11
incq %r9
movq %r9, 0x28(%rsi)
movb (%rdx,%r11), %bl
movb $0x1, %r11b
cmpb $0x5c, %bl
jne 0x1fe4e
movb $0x1, %r10b
jmp 0x1fe68
testb $0x1, %r10b
je 0x1fe59
xorl %r10d, %r10d
jmp 0x1fe68
cmpb (%rdx,%rdi), %bl
setne %r11b
movzbl %r10b, %r10d
cmovnel %r8d, %r10d
testb %r11b, %r11b
jne 0x1fe2e
movq 0x20(%rsi), %rdx
movq 0x28(%rsi), %rdi
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
cmpq %rdi, %rdx
cmovaq %rdx, %rdi
cmpq %rcx, %rdi
cmovaeq %rcx, %rdi
subq %rdx, %rdi
subq %rdx, %rcx
cmpq %rdi, %rcx
cmovaeq %rdi, %rcx
addq 0x18(%rsi), %rdx
movl $0xb, (%rax)
movq %rcx, 0x8(%rax)
movq %rdx, 0x10(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9480
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
addq %r14, %r15
movq %rsp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x12646
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x2be1d
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x20dab
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x93c0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
movq 0x108(%rsp,%rax), %rsi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x2c26e
leaq 0x20(%rsp), %rdi
callq 0x90c0
movq %rbx, %rax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x20e11
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x20e14
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x93c0
jmp 0x20e14
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x90c0
movq %rbx, %rdi
callq 0x9790
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38726(%rip), %rsi     # 0x59571
movl $0x2, %ecx
movq %r15, %rdi
movq $-0x1, %rdx
callq 0x2c94c
leaq 0x1(%rax), %r12
movq (%r15), %rax
movq 0x8(%r15), %r15
cmpq %r12, %rax
cmovbq %rax, %r12
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x38(%r14), %rcx
movq 0x40(%r14), %r8
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1aa42
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x1b4ae
leaq 0x1b8(%rsp), %rdi
callq 0x2f4ac
leaq 0x168(%rsp), %rdi
callq 0x1b1ac
leaq 0x118(%rsp), %rdi
callq 0x1b1fc
leaq 0xc8(%rsp), %rdi
callq 0x1b34e
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1ab98
movq %rbx, %rdi
callq 0x9790
// File: /workspace/github_cpp_makefile_star2_O1/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 0x24563
testq %rcx, %rcx
sete %dl
cmpb $0x2, %al
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x24582
testq %rcx, %rcx
sete %dl
cmpb $0x3, %al
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x245a1
testq %rcx, %rcx
sete %cl
cmpb $0x8, %al
sete %al
andb %cl, %al
cmpb $0x1, %al
je 0x245c0
popq %rax
retq
leaq 0x3467b(%rip), %rdi     # 0x58be5
leaq 0x32778(%rip), %rsi     # 0x56ce9
leaq 0x346a4(%rip), %rcx     # 0x58c1c
movl $0x4530, %edx           # imm = 0x4530
callq 0x92a0
leaq 0x34800(%rip), %rdi     # 0x58d89
leaq 0x32759(%rip), %rsi     # 0x56ce9
leaq 0x34685(%rip), %rcx     # 0x58c1c
movl $0x4531, %edx           # imm = 0x4531
callq 0x92a0
leaq 0x34816(%rip), %rdi     # 0x58dbe
leaq 0x3273a(%rip), %rsi     # 0x56ce9
leaq 0x34666(%rip), %rcx     # 0x58c1c
movl $0x4532, %edx           # imm = 0x4532
callq 0x92a0
leaq 0x3482e(%rip), %rdi     # 0x58df5
leaq 0x3271b(%rip), %rsi     # 0x56ce9
leaq 0x34647(%rip), %rcx     # 0x58c1c
movl $0x4533, %edx           # imm = 0x4533
callq 0x92a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x38(%rsi), %r13
movq 0x40(%rsi), %rbp
cmpq %rbp, %r13
je 0x246ad
leaq 0x347ce(%rip), %r14     # 0x58e2c
leaq 0x8(%rsp), %r15
movzbl (%r13), %ecx
cmpl $0x1f, %ecx
ja 0x2469a
movb $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x9, %esi
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x96d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9820
jmp 0x246a5
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x9340
incq %r13
cmpq %rbp, %r13
jne 0x24663
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x246c1
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x246d8
movq (%r12), %rsi
incq %rsi
callq 0x93c0
movq %r14, %rdi
callq 0x9790
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq -0x8(%rax), %rcx
testq %rcx, %rcx
je 0x26ae1
subq 0x8(%rbx), %rax
shrq $0x3, %rax
decl %eax
movl %eax, 0xc(%rsp)
movb $0x3, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x26bbc
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
callq *0x98(%rbx)
movl %eax, %ebp
testb %al, %al
jne 0x26ae4
leaq 0xa8(%rbx), %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x2748e
movq 0x10(%rbx), %rax
movq -0x8(%rax), %r15
movq %r14, %rdi
callq 0x2450a
movb (%r15), %al
movb (%r14), %cl
movb %cl, (%r15)
movb %al, (%r14)
leaq 0x18(%rsp), %r12
movq 0x8(%r15), %rax
movq (%r12), %rcx
movq %rcx, 0x8(%r15)
movq %rax, (%r12)
movq %r15, %rdi
callq 0x2450a
movq %r14, %rdi
callq 0x2450a
movzbl -0x8(%r12), %esi
movq %r12, %rdi
callq 0x3c32c
jmp 0x26ae4
movb $0x1, %bpl
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rax
cmpq %rax, %rcx
je 0x26b7e
movq 0x30(%rbx), %rdx
movl 0x38(%rbx), %esi
cmpq %rdx, 0x20(%rbx)
sete %dil
testl %esi, %esi
sete %r8b
andb %dil, %r8b
cmpb $0x1, %r8b
je 0x26b9d
leaq -0x8(%rax), %rdi
movq %rdi, 0x10(%rbx)
subl $0x1, %esi
movl %esi, 0x38(%rbx)
jae 0x26b36
movl $0x3f, 0x38(%rbx)
addq $-0x8, %rdx
movq %rdx, 0x30(%rbx)
cmpq %rdi, %rcx
sete %cl
orb %cl, %bpl
jne 0x26b6f
movq -0x10(%rax), %rax
cmpb $0x2, (%rax)
jne 0x26b6f
movq 0x8(%rax), %rax
movq 0x8(%rax), %rbx
leaq -0x10(%rbx), %rdi
movq %rdi, 0x8(%rax)
callq 0x2450a
movzbl -0x10(%rbx), %esi
addq $-0x8, %rbx
movq %rbx, %rdi
callq 0x3c32c
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x318ac(%rip), %rdi     # 0x58431
leaq 0x3015d(%rip), %rsi     # 0x56ce9
leaq 0x31aff(%rip), %rcx     # 0x58692
movl $0x1621, %edx           # imm = 0x1621
callq 0x92a0
leaq 0x3173c(%rip), %rdi     # 0x582e0
leaq 0x3013e(%rip), %rsi     # 0x56ce9
leaq 0x31ae0(%rip), %rcx     # 0x58692
movl $0x1622, %edx           # imm = 0x1622
callq 0x92a0
callq 0x9150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x275fa
movzbl (%rax), %ecx
cmpl $0x2, %ecx
je 0x27560
cmpl $0x1, %ecx
jne 0x2758d
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq 0x8(%rdi), %rax
cmpq %rcx, %rax
je 0x27619
addq $0x40, %rax
jmp 0x27594
movq 0x8(%rax), %rcx
movq 0x10(%rdi), %rax
cmpq 0x8(%rcx), %rax
jne 0x27594
leaq 0x31017(%rip), %rdi     # 0x5858c
leaq 0x2f76d(%rip), %rsi     # 0x56ce9
leaq 0x30f58(%rip), %rcx     # 0x584db
movl $0x2b33, %edx           # imm = 0x2B33
callq 0x92a0
cmpq $0x0, 0x18(%rdi)
jne 0x2759f
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x91f0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x31006(%rip), %rsi     # 0x585c2
leaq 0x3100f(%rip), %rdx     # 0x585d2
leaq 0x8(%rsp), %rdi
callq 0x12646
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xd6, %esi
callq 0x27eb0
xorl %ebp, %ebp
leaq 0x5099d(%rip), %rsi     # 0x77f88
leaq 0x3068(%rip), %rdx      # 0x2a65a
movq %rbx, %rdi
callq 0x9750
leaq 0x30ec6(%rip), %rdi     # 0x584c7
leaq 0x2f6e1(%rip), %rsi     # 0x56ce9
leaq 0x30ecc(%rip), %rcx     # 0x584db
movl $0x2b27, %edx           # imm = 0x2B27
callq 0x92a0
leaq 0x30f34(%rip), %rdi     # 0x58554
leaq 0x2f6c2(%rip), %rsi     # 0x56ce9
leaq 0x30ead(%rip), %rcx     # 0x584db
movl $0x2b2d, %edx           # imm = 0x2B2D
callq 0x92a0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2765a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x93c0
jmp 0x2765a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x27667
movq %rbx, %rdi
callq 0x92e0
movq %r14, %rdi
callq 0x9790
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
cmpb $0x3, (%rdi)
jne 0x2bcbc
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2bcbc
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x91f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x2858a
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, %rdi
callq 0x91b0
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x12646
leaq 0x2d816(%rip), %rsi     # 0x59513
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1dc69
movb $0x1, %bpl
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x12f, %esi            # imm = 0x12F
callq 0x28424
xorl %ebp, %ebp
leaq 0x4c2c6(%rip), %rsi     # 0x77ff0
leaq -0x16d7(%rip), %rdx     # 0x2a65a
movq %rbx, %rdi
callq 0x9750
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2bd5f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x93c0
jmp 0x2bd5f
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2bd7e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x93c0
jmp 0x2bd7e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2bd8b
movq %rbx, %rdi
callq 0x92e0
movq %r14, %rdi
callq 0x9790
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
leaq (%rsi,%rax), %rdi
movl $0x5, 0x1c(%rsi,%rax)
movl 0x20(%rsi,%rax), %esi
callq 0x9730
movq %rbx, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x9350
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x2bf6e
movq %r14, %rdi
callq 0x9170
movl $0x60, %edi
callq 0x91f0
movq %rax, %rbx
leaq 0x2d6bf(%rip), %rsi     # 0x5954b
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x124ba
leaq 0x2cfee(%rip), %rsi     # 0x58e8e
leaq 0x28(%rsp), %rdi
callq 0x9820
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2becb
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x2bed8
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x2bf7e
xorl %ebp, %ebp
leaq 0x4c190(%rip), %rsi     # 0x78098
leaq 0xc7c9(%rip), %rdx      # 0x386d8
movq %rbx, %rdi
callq 0x9750
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2bf39
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x93c0
jmp 0x2bf39
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2bf5c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x93c0
jmp 0x2bf5c
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2bf69
movq %rbx, %rdi
callq 0x92e0
callq 0x9710
movq %r14, %rdi
callq 0x9790
movq %rax, %rdi
callq 0xe8bb
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testq %r14, %r14
je 0x2e513
movq %r15, %rdi
movl $0x2e, %esi
movq %r14, %rdx
callq 0x9450
movq %rax, %rcx
subq %r15, %rcx
cmpq $0x1, %rax
movl $0x0, %ebp
sbbq %rbp, %rbp
orq %rcx, %rbp
jmp 0x2e51a
movq $-0x1, %rbp
cmpq $-0x1, %rbp
je 0x2e53c
cmpq %r14, %rbp
movq %r14, %r12
cmovbq %rbp, %r12
incq %rbp
cmpq %rbp, %r14
cmovbq %r14, %rbp
subq %rbp, %r14
addq %r15, %rbp
jmp 0x2e544
movq %r14, %r12
xorl %ebp, %ebp
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x9340
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movq %r15, %rcx
movq %r12, %r8
callq 0x9460
movq %rbp, %r15
testq %r14, %r14
jne 0x2e4e7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x2e59a
movq (%r13), %rsi
incq %rsi
callq 0x93c0
movq %r14, %rdi
callq 0x9790
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, 0x30(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x28(%rdi)
testq %r8, %r8
je 0x2f697
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r8, %rsi
callq 0x2748e
leaq 0x38(%rbx), %r15
movq %r14, %rdi
callq 0x2450a
movb 0x38(%rbx), %al
movb (%r14), %cl
movb %cl, 0x38(%rbx)
movb %al, (%r14)
leaq 0x10(%rsp), %r12
movq 0x40(%rbx), %rax
movq (%r12), %rcx
movq %rcx, 0x40(%rbx)
movq %rax, (%r12)
movq %r15, %rdi
callq 0x2450a
movq %r14, %rdi
callq 0x2450a
movzbl -0x8(%r12), %esi
movq %r12, %rdi
callq 0x3c32c
leaq 0x2a174(%rip), %rsi     # 0x597ff
movq %r15, %rdi
callq 0x2f702
movq %rax, 0x48(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq *(%rax)
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x3c1ae
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3baee
movq (%r15), %rsi
movq %r14, %rdi
callq 0x35eb8
movl $0x38, %ecx
testb %al, %al
jne 0x33487
movl $0x60, %ecx
cmpb $0x1, 0x91(%rbx)
jne 0x33495
addq %rcx, %rbx
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x334a4
callq 0xf9ae
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x334c0
callq 0xf9ae
movq %rbx, %rdi
callq 0x9790
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f4fc
movq 0x18(%rbx), %rdi
leaq 0x10(%r14), %r12
movq %r12, %rsi
callq 0x3c124
movq 0x18(%rbx), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x33537
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 0x2f60a
jmp 0x335e9
cmpb $0x1, (%r15)
jne 0x335e9
leaq 0x26ed9(%rip), %rsi     # 0x5a421
leaq 0x20(%rsp), %rdi
movq %r12, %rdx
callq 0x124ba
leaq 0x26603(%rip), %rsi     # 0x59b5f
leaq 0x20(%rsp), %rdi
callq 0x9820
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3358c
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x33593
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rdx
callq 0x36a62
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x335ce
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x93c0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x335e9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x93c0
leaq 0x44e30(%rip), %rax     # 0x78420
leaq 0xf8(%rsp), %rdi
movq %rax, -0xb8(%rdi)
callq 0x3c1f0
leaq 0xa8(%rsp), %rdi
callq 0x33c56
leaq 0x90(%rsp), %rdi
callq 0x2f8ac
leaq 0x78(%rsp), %rdi
callq 0x2450a
leaq 0x80(%rsp), %rdi
movzbl -0x8(%rdi), %esi
callq 0x3c32c
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x33666
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x93c0
jmp 0x33666
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x33688
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x93c0
jmp 0x33688
jmp 0x33685
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2f6bc
movq %rbx, %rdi
callq 0x9790
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0x34118
movq %rsi, %rbx
movq 0x8(%r14), %rdi
callq 0x347ec
movq 0x8(%r14), %rdi
leaq 0x8(%rdi), %rcx
cmpq %rcx, %rax
je 0x34195
movq %rbx, %rsi
callq 0x347ec
addq $0x40, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x91f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x2858a
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, %rdi
callq 0x91b0
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x12646
leaq 0x256ab(%rip), %rsi     # 0x59804
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1dc69
movb $0x1, %bpl
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
callq 0x28424
xorl %ebp, %ebp
leaq 0x43e6a(%rip), %rsi     # 0x77ff0
leaq -0x9b33(%rip), %rdx     # 0x2a65a
movq %rbx, %rdi
callq 0x9750
leaq 0x2569b(%rip), %rdi     # 0x59837
leaq 0x22b46(%rip), %rsi     # 0x56ce9
leaq 0x256c0(%rip), %rcx     # 0x5986a
movl $0x4e9e, %edx           # imm = 0x4E9E
callq 0x92a0
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x341da
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x93c0
jmp 0x341da
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x341f9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x93c0
jmp 0x341f9
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x34206
movq %rbx, %rdi
callq 0x92e0
movq %r14, %rdi
callq 0x9790
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x37d1e
cmpb $0x1, (%r15)
jne 0x37441
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x347ec
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq