LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/AgathokakologicalBit[P]wit/src/parsing/../node.hpp
// Function: akbit::system::etype_to_str[abi:cxx11](akbit::system::Node::etype_t)
inline std::string etype_to_str(Node::etype_t t)
  {
    switch (t)
    {
      case Node::etype_t::unknown: return "unknown";
      case Node::etype_t::string: return "string";
      case Node::etype_t::character: return "character";
      case Node::etype_t::integer: return "integer";
      case Node::etype_t::decimal: return "decimal";

      case Node::etype_t::function: return "function";
      case Node::etype_t::tuple: return "tuple";

      case Node::etype_t::any: return "any";
    } 
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movl %esi, %eax
leaq 0xe544(%rip), %rcx      # 0x15004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xe791(%rip), %rsi      # 0x15261
leaq 0xe791(%rip), %rdx      # 0x15268
jmp 0x6b47
leaq 0xe962(%rip), %rsi      # 0x15442
leaq 0xe962(%rip), %rdx      # 0x15449
jmp 0x6b47
leaq 0xe68b(%rip), %rsi      # 0x1517b
leaq 0xe68d(%rip), %rdx      # 0x15184
jmp 0x6b47
leaq 0xe933(%rip), %rsi      # 0x15433
leaq 0xe933(%rip), %rdx      # 0x1543a
jmp 0x6b47
leaq 0xe759(%rip), %rsi      # 0x15269
leaq 0xe755(%rip), %rdx      # 0x1526c
jmp 0x6b47
leaq 0xe654(%rip), %rsi      # 0x15174
leaq 0xe653(%rip), %rdx      # 0x1517a
jmp 0x6b47
leaq 0xe655(%rip), %rsi      # 0x15185
leaq 0xe656(%rip), %rdx      # 0x1518d
jmp 0x6b47
leaq 0xe64e(%rip), %rsi      # 0x1518e
leaq 0xe64c(%rip), %rdx      # 0x15193
movq %rbx, %rdi
callq 0x6bd0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/AgathokakologicalBit[P]wit/src/error_handling.cpp
// Function: akbit::system::log_error(akbit::system::parsing::LexerState&)
void log_error(parsing::LexerState &state)
  {
    log_error_common(state);

    std::cout << "Line: " << state.line << "\n";
    std::cout << "Column: " << state.column << "\n\n";

    // throw std::runtime_error("halt");
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
leaq 0x20(%rsp), %rdi
movq %rax, -0x10(%rdi)
movups (%rbx), %xmm0
movaps %xmm0, -0x20(%rdi)
movl 0x18(%rbx), %eax
movl %eax, -0x8(%rdi)
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
callq 0x6de8
movq 0x15d14(%rip), %rdi     # 0x1cfc0
leaq 0xe06f(%rip), %rsi      # 0x15322
movl $0x9, %edx
callq 0x3240
movl 0x18(%rsp), %esi
movq 0x15cf8(%rip), %rdi     # 0x1cfc0
callq 0x3340
leaq 0xe058(%rip), %rsi      # 0x1532c
movl $0x2, %edx
movq %rax, %rdi
callq 0x3240
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x15cce(%rip), %rdi     # 0x1cfc0
callq 0x3240
leaq 0xe021(%rip), %rsi      # 0x1531f
movl $0x2, %edx
movq %rax, %rdi
callq 0x3240
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x7322
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31f0
movq 0x15c97(%rip), %r14     # 0x1cfc0
leaq 0xdfdf(%rip), %rsi      # 0x1530f
movl $0x6, %edx
movq %r14, %rdi
callq 0x3240
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0x3150
leaq 0xdfd1(%rip), %rsi      # 0x15320
movl $0x1, %edx
movq %rax, %rdi
callq 0x3240
leaq 0xdfb3(%rip), %rsi      # 0x15316
movl $0x8, %edx
movq %r14, %rdi
callq 0x3240
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x3150
leaq 0xdf9d(%rip), %rsi      # 0x1531f
movl $0x2, %edx
movq %rax, %rdi
callq 0x3240
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x73b1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31f0
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O3/AgathokakologicalBit[P]wit/src/parsing/operators.cpp
// Function: akbit::system::find_operator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
operator_t const * find_operator(std::string representation)
  {
    for (auto& op : operators_list)
      if (op.representation == representation)
        return &op;
    return nullptr;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
xorl %r12d, %r12d
leaq 0x15ae6(%rip), %r13     # 0x1d1f8
cmpq %r14, 0x18(%r12,%r13)
jne 0x7735
leaq (%r12,%r13), %r15
testq %r14, %r14
je 0x7745
movq (%rbx), %rsi
movq 0x10(%r15), %rdi
movq %r14, %rdx
callq 0x3210
testl %eax, %eax
je 0x7745
addq $0x30, %r12
cmpq $0x420, %r12            # imm = 0x420
jne 0x7712
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/AgathokakologicalBit[P]wit/src/parsing/lexing.cpp
// Function: akbit::system::parsing::tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::vector<Token> tokenize(std::string &source)
  {
    std::vector<Token> tokens{};
    parsing::LexerState state(source);

    while (state.index < source.size() && not state.is_error_occurred())
      tokens.push_back(get_next_token(state));

    if (state.is_error_occurred())
    {
      log_error(state);
    }

    return tokens;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movabsq $0x100000000, %rcx      # imm = 0x100000000
leaq 0x30(%rsp), %r13
movq %rcx, -0x30(%r13)
movl $0x1, -0x28(%r13)
movq %rsi, -0x20(%r13)
movl $0x0, -0x18(%r13)
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb $0x0, (%r13)
cmpq %rax, 0x8(%rsi)
je 0x8371
movq %rsi, %r14
leaq 0x60(%rsp), %rbp
leaq 0x40(%rsp), %r15
movq %rsp, %r12
cmpl $0x0, 0x18(%rsp)
jne 0x8369
movq %r15, %rdi
movq %r12, %rsi
callq 0x7d33
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8444
movq 0x50(%rsp), %rdi
cmpq %rbp, %rdi
je 0x8359
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x31f0
movl (%rsp), %eax
cmpq %rax, 0x8(%r14)
ja 0x8325
cmpl $0x0, 0x18(%rsp)
je 0x8371
movq %rsp, %rdi
callq 0x7268
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x8388
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31f0
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x83b8
movq %rax, %r14
movq 0x50(%rsp), %rdi
cmpq %rbp, %rdi
je 0x83bb
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x31f0
jmp 0x83bb
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x83d2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31f0
movq %rbx, %rdi
callq 0x6b54
movq %r14, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O3/AgathokakologicalBit[P]wit/src/parsing/parsing.cpp
// Function: akbit::system::parsing::parse(std::vector<akbit::system::parsing::Token, std::allocator<akbit::system::parsing::Token>>&)
std::shared_ptr<Node> parse(std::vector<Token> &tokens)
  {
    ParserState state(tokens);
    auto module = parse_module(state);

    if (state.is_failed())
    {
      std::get<Node::module_t>(module->value).has_errors = state.is_failed();
      log_error(state);
      return module;
    }

    return module;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %rbp
movq %rsi, -0x28(%rbp)
xorl %eax, %eax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb $0x0, (%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbp)
movq %rax, 0x20(%rbp)
leaq 0x60(%rsp), %rcx
movups %xmm0, 0x19(%rcx)
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc38e
movq %r14, 0x8(%rsp)
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x9748
callq 0x6d78
leaq 0x60(%rsp), %rdi
callq 0x6d2a
movl 0x20(%rsp), %eax
testl %eax, %eax
sete %cl
movq 0x10(%rsp), %rdx
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
sarq $0x3, %rsi
movabsq $0x6db6db6db6db6db7, %r14 # imm = 0x6DB6DB6DB6DB6DB7
imulq %r14, %rsi
decq %rsi
cmpq %rsi, 0x18(%rsp)
setb %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x97f0
leaq 0x60(%rsp), %r15
leaq 0x10(%rsp), %r12
movq (%rbx), %rdi
addq $0x10, %rdi
callq 0x6e7d
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x9984
movq %r13, %rdi
movq %r15, %rsi
callq 0xc820
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x97c9
callq 0x6d78
cmpl $0x0, 0x20(%rsp)
jne 0x97f4
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
imulq %r14, %rcx
decq %rcx
cmpq %rcx, 0x18(%rsp)
jb 0x9795
jmp 0x980e
testl %eax, %eax
je 0x980e
movq (%rbx), %rdi
addq $0x10, %rdi
callq 0x6e7d
movb $0x1, 0x28(%rax)
leaq 0x10(%rsp), %rdi
callq 0x73b9
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x9825
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x31f0
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x983c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31f0
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xc372
jmp 0x988d
jmp 0x9878
jmp 0x9878
movq %rax, %rbx
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x987b
callq 0x6d78
jmp 0x987b
movq %rax, %rbx
movq 0x8(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x988d
callq 0x6d78
leaq 0x10(%rsp), %rdi
callq 0x7628
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O3/AgathokakologicalBit[P]wit/src/parsing/parsing.cpp
// Function: akbit::system::parsing::convert_to_tuple(std::shared_ptr<akbit::system::Node>)
std::shared_ptr<Node> convert_to_tuple(std::shared_ptr<Node> node)
  {
    if (nullptr == node) return nullptr;
    try
    {
      std::get<Node::value_tuple_t>(node->value);
      return node;
    }
    catch (...) { }
    
    auto container = std::make_shared<Node>(Node::value_tuple_t{
      .entries = {
        {node}
      }
    });

    return container;
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x98cf
movq %rsi, %r14
addq $0x10, %rdi
callq 0xc30e
movups (%r14), %xmm0
xorl %eax, %eax
movq %rax, 0x8(%r14)
movups %xmm0, (%rbx)
movq %rax, (%r14)
jmp 0x98d5
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3100
callq 0x3310
movq (%r14), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r14), %rdi
movq %rdi, 0x18(%rsp)
testq %rdi, %rdi
jne 0x9954
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xe(%rsp), %rcx
movl $0x1, %edx
callq 0xc2c6
movq $0x0, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0xf(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rbx, %rsi
callq 0xda44
leaq 0x20(%rsp), %rdi
callq 0x6d2a
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x98d5
callq 0x6d78
jmp 0x98d5
callq 0x35f3
jmp 0x9903
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6d2a
jmp 0x996d
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x997c
callq 0x6d78
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O3/AgathokakologicalBit[P]wit/src/parsing/parsing.cpp
// Function: akbit::system::parsing::(anonymous namespace)::parse_composite_unit(akbit::system::parsing::ParserState&)
std::shared_ptr<Node> parse_composite_unit(ParserState &state)
    {
      auto unit = parse_unit(state);
      if (state.is_failed()) return unit;

      // Function calls
      while (state.peek().sub_type == TokenSubType::t_brace_round_left)
      {
        auto container = std::make_shared<Node>(Node::function_call_t{
          .expression = unit,
          .arguments = parse_unit(state)
        });
        unit = container;
      }

      return unit;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0xb710
cmpl $0x0, 0x10(%r14)
je 0xb56c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30(%rsp), %r12
leaq 0x8(%r15), %rbx
movq (%r14), %rax
movq (%rax), %rbp
imulq $0x38, 0x8(%r14), %r13
movl 0x8(%rbp,%r13), %eax
movl %eax, 0x18(%rsp)
movq (%rbp,%r13), %rax
movq %rax, 0x10(%rsp)
movq %r12, 0x20(%rsp)
movq 0x10(%rbp,%r13), %rsi
movq 0x18(%rbp,%r13), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x6de8
addq %r13, %rbp
movq 0x30(%rbp), %r13
movq %r13, 0x40(%rsp)
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xb5d2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31f0
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq %rax, %r13
movabsq $0x900000000, %rax      # imm = 0x900000000
cmpq %rax, %r13
jne 0xb55d
movq (%r15), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0xb61d
movq 0x119a9(%rip), %rcx     # 0x1cfb8
cmpb $0x0, (%rcx)
je 0xb619
incl 0x8(%rax)
jmp 0xb61d
lock
incl 0x8(%rax)
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0xb710
movq $0x0, (%rsp)
movl $0x68, %edi
callq 0x31e0
movq %rax, %rbp
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%rbp)
leaq 0x1135c(%rip), %rax     # 0x1c9b0
movq %rax, (%rbp)
leaq 0x10(%rbp), %r13
movq %rbp, %rdi
addq $0x20, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbp)
leaq 0x10(%rsp), %rsi
callq 0xd576
movb $0x7, 0x58(%rbp)
movl $0x0, 0x60(%rbp)
movq %rbp, 0x8(%rsp)
movq %r13, (%rsp)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xb697
callq 0x6d78
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xb6a6
callq 0x6d78
movq (%rsp), %rax
movq %rax, (%r15)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0xd808
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb575
callq 0x6d78
jmp 0xb575
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xc6b0
jmp 0xb6f3
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xb6f3
callq 0x6d78
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb700
callq 0x6d78
movq %r14, %rdi
callq 0x3350
movq %rax, %rdi
callq 0x6c65
// File: /workspace/github_cpp_makefile_star2_O3/AgathokakologicalBit[P]wit/src/parsing/../node.hpp
// Function: akbit::system::make_node_bop(std::shared_ptr<akbit::system::Node>, std::shared_ptr<akbit::system::Node>, akbit::system::operator_t const*)
inline std::shared_ptr<Node> make_node_bop(std::shared_ptr<Node> left, std::shared_ptr<Node> right, operator_t const * operation)
  {
    return std::make_shared<Node>(Node::binary_operation_t{
      .operation = operation,
      .operands = {
        left,
        right,
      }
    });
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq %rcx, 0x28(%rsp)
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xcf86
movq 0x10040(%rip), %rcx     # 0x1cfb8
cmpb $0x0, (%rcx)
je 0xcf82
incl 0x8(%rax)
jmp 0xcf86
lock
incl 0x8(%rax)
leaq 0x30(%rsp), %r14
movq (%rdx), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0xcfb6
movq 0x10010(%rip), %rcx     # 0x1cfb8
cmpb $0x0, (%rcx)
je 0xcfb2
incl 0x8(%rax)
jmp 0xcfb6
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
leaq 0x6(%rsp), %rcx
movl $0x2, %edx
movq %r14, %rdi
callq 0xc2c6
movq $0x0, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x7(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rsi
callq 0xd6ec
movq %r14, %rdi
callq 0x6d2a
movl $0x20, %r14d
movq (%rsp,%r14), %rdi
testq %rdi, %rdi
je 0xd006
callq 0x6d78
addq $-0x10, %r14
jne 0xcff8
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x6d2a
jmp 0xd027
movq %rax, %rbx
movl $0x20, %r14d
movq (%rsp,%r14), %rdi
testq %rdi, %rdi
je 0xd03b
callq 0x6d78
addq $-0x10, %r14
jne 0xd02d
movq %rbx, %rdi
callq 0x3350
nop
// File: /workspace/github_cpp_makefile_star2_O3/AgathokakologicalBit[P]wit/src/annotation/tree_preprocessing.cpp
// Function: akbit::system::annotation::(anonymous namespace)::tp_visit(std::shared_ptr<akbit::system::Node>)
void tp_visit(std::shared_ptr<Node> node)
    {
      if (nullptr == node) return;
      std::visit(overloaded {
        [](auto                     & ) {                                  },
        [](Node::module_t           &_) { tp_visit_module(_);              },
        [](Node::declaration_t      &_) { tp_visit_declaration(_);         },
        [](Node::condition_t        &_) { tp_visit_condition(_);           },
        [](Node::block_t            &_) { tp_visit_block(_);               },
        [](Node::unary_operation_t  &_) { tp_visit_unary_operation(_);     },
        [&](Node::binary_operation_t& ) { tp_visit_binary_operation(node); },
        [](Node::function_call_t    &_) { tp_visit_function_call(_);       },
        [](Node::value_function_t   &_) { tp_visit_value_function(_);      },
        [](Node::value_tuple_t      &_) { tp_visit_value_tuple(_);         },
        [](Node::value_variable_t   &_) { tp_visit_value_variable(_);      },
        [](Node::value_string_t     &_) { tp_visit_value_string(_);        },
        [](Node::value_character_t  &_) { tp_visit_value_character(_);     },
        [](Node::value_integer_t    &_) { tp_visit_value_integer(_);       },
        [](Node::value_decimal_t    &_) { tp_visit_value_decimal(_);       },
      }, node->value);
    }

// Assembly:
pushq %rax
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xdb83
movq %rdi, (%rsp)
movsbq 0x48(%rsi), %rax
cmpq $-0x1, %rax
je 0xdb85
addq $0x10, %rsi
leaq 0xef93(%rip), %rcx      # 0x1cb10
movq %rsp, %rdi
callq *(%rcx,%rax,8)
popq %rax
retq
movl $0x10, %edi
callq 0x3120
leaq 0xecf2(%rip), %rcx      # 0x1c888
movq %rcx, (%rax)
leaq 0x7545(%rip), %rcx      # 0x150e5
movq %rcx, 0x8(%rax)
leaq 0xecb5(%rip), %rsi      # 0x1c860
movq 0xf426(%rip), %rdx      # 0x1cfd8
movq %rax, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O3/AgathokakologicalBit[P]wit/src/annotation/../context.hpp
// Function: akbit::system::Context::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
std::vector<std::shared_ptr<DeclarationRecord>> find(std::string& name) const
    {
      std::vector<std::shared_ptr<DeclarationRecord>> results{};
      std::copy_if(this->declarations.begin(), this->declarations.end(),
                   std::back_inserter(results),
                   [&](auto& record) { return record->name == name; });
      if (!this->parent.lock()) return results;

      auto rest = this->parent.lock()->find(name);
      results.reserve(results.size() + rest.size());
      results.insert(results.end(), rest.begin(), rest.end());
      return results;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x18(%rsi), %rdi
movq 0x20(%rsi), %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x11f77
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x11ea6
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x11ea6
leal 0x1(%rax), %ecx
lock
cmpxchgl %ecx, 0x8(%rdi)
jne 0x11e03
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x11ea1
movq 0x8(%r15), %r12
callq 0x6d78
testq %r12, %r12
je 0x11ea6
movq 0x10(%r15), %r12
movl 0x8(%r12), %eax
leal 0x1(%rax), %ecx
lock
cmpxchgl %ecx, 0x8(%r12)
jne 0x11e37
movl 0x8(%r12), %eax
movq 0x8(%r15), %rsi
movq %rsp, %rdi
movq %r14, %rdx
callq 0x11dbe
movq %r12, %rdi
callq 0x6d78
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x4, %rax
movq 0x8(%rsp), %rsi
subq (%rsp), %rsi
sarq $0x4, %rsi
addq %rax, %rsi
movq %rbx, %rdi
callq 0x11fd6
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x121f4
movq %rsp, %rdi
callq 0x11f2a
jmp 0x11ea6
callq 0x6d78
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x11eb7
movq %rax, %r14
movq %rsp, %rdi
callq 0x11f2a
jmp 0x11ed4
movq %rax, %r14
movq %r12, %rdi
callq 0x6d78
jmp 0x11ed4
movq %rax, %r14
movq %rbx, %rdi
callq 0x11f2a
movq %r14, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/main.cpp
// Function: get_per_char_as_nuc_2_num_coding_array()
int* get_per_char_as_nuc_2_num_coding_array()
{
  // code all non-nucleotide values as 4, others as a:0, c:1, g:2, t:3.
  int* per_nuc_val = new int[256];
  for(int i = 0; i < 256; i++)
  {
    per_nuc_val[i] = 4;
  } // i loop.
  per_nuc_val[(int)'A'] = 0;
  per_nuc_val[(int)'C'] = 1;
  per_nuc_val[(int)'G'] = 2;
  per_nuc_val[(int)'T'] = 3;
  per_nuc_val[(int)'U'] = 3;
  per_nuc_val[(int)'a'] = 0;
  per_nuc_val[(int)'c'] = 1;
  per_nuc_val[(int)'g'] = 2;
  per_nuc_val[(int)'t'] = 3;
  per_nuc_val[(int)'u'] = 3;

  return(per_nuc_val);
}

// Assembly:
pushq %rax
movl $0x400, %edi            # imm = 0x400
callq 0x2040
xorl %ecx, %ecx
movaps 0x6f9f(%rip), %xmm0     # 0xa010
movups %xmm0, (%rax,%rcx,4)
addq $0x4, %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x3071
xorl %ecx, %ecx
movl %ecx, 0x104(%rax)
movl $0x1, %edx
movl %edx, 0x10c(%rax)
movl $0x2, %esi
movl %esi, 0x11c(%rax)
movabsq $0x300000003, %rdi      # imm = 0x300000003
movq %rdi, 0x150(%rax)
movl %ecx, 0x184(%rax)
movl %edx, 0x18c(%rax)
movl %esi, 0x19c(%rax)
movq %rdi, 0x1d0(%rax)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/main.cpp
// Function: normalize_chr_id(char*)
void normalize_chr_id(char* raw_chr_id)
{
  if(t_string::starts_with(raw_chr_id, "chr") || 
    t_string::starts_with(raw_chr_id, "Chr") ||
    t_string::starts_with(raw_chr_id, "CHR"))
  {
    // Get rid of the first 3 characters.
    char temp[1000];
    strcpy(temp, &raw_chr_id[3]);
    strcpy(raw_chr_id, temp);
  }
  else
  {
    // No need to change.
    return;
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x3e8, %rsp            # imm = 0x3E8
movq %rdi, %rbx
leaq 0x6f50(%rip), %rsi      # 0xa030
callq 0x84ee
testb %al, %al
jne 0x310f
leaq 0x6f44(%rip), %rsi      # 0xa034
movq %rbx, %rdi
callq 0x84ee
testb %al, %al
jne 0x310f
leaq 0x6f35(%rip), %rsi      # 0xa038
movq %rbx, %rdi
callq 0x84ee
testb %al, %al
je 0x3129
leaq 0x3(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x2130
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2130
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/main.cpp
// Function: load_chromosome_lengths_per_tabbed_file(char*, std::vector<char*, std::allocator<char*>>*, std::vector<int, std::allocator<int>>*)
void load_chromosome_lengths_per_tabbed_file(char* chr_lengths_fp, vector<char*>* chr_ids, vector<int>* chr_lengths)
{
  FILE* f_l_chrs = open_f(chr_lengths_fp, "r");

  while(1)
  {
    char* cur_line = getline(f_l_chrs);
    if(cur_line == NULL)
    {
      break;
    }

    char cur_chr_id[1000];
    int cur_l_chr = 0;
    if(sscanf(cur_line, "%s %d", cur_chr_id, &cur_l_chr) != 2)
    {
      fprintf(stderr, "Could not read chromosome lengths from: %s\n", cur_line);
      exit(0);
    } // check if reading is succesful.

    // Normalize the chromosome id before adding it to the list.
    normalize_chr_id(cur_chr_id);
    chr_ids->push_back(t_string::copy_me_str(cur_chr_id));
    chr_lengths->push_back(cur_l_chr);
  } // file reading loop.

  fclose(f_l_chrs);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x6ee4(%rip), %rsi      # 0xa036
callq 0x4b65
movq %rax, %r15
movq %rax, %rdi
callq 0x498e
testq %rax, %rax
je 0x31f3
movq %rax, %r12
leaq 0x10(%rsp), %r13
leaq 0x4(%rsp), %rbp
movl $0x0, 0x4(%rsp)
movq %r12, %rdi
leaq 0x6eb2(%rip), %rsi      # 0xa03c
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x2140
cmpl $0x2, %eax
jne 0x320d
movq %r13, %rdi
callq 0x30cc
movq %r13, %rdi
callq 0x5ace
movq %rax, 0x8(%rsp)
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
callq 0x4016
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x31d8
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x31e3
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x418a
movq %r15, %rdi
callq 0x498e
movq %rax, %r12
testq %rax, %rax
jne 0x3178
movq %r15, %rdi
callq 0x2150
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x2bb3
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/utils.cpp
// Function: get_absolute_fp(char*, char*)
void get_absolute_fp(char* fp, char* abs_fp)
{
	char cwd[1000];
	get_current_working_directory(cwd);

	if(fp[0] == '/')
	{
		strcpy(abs_fp, fp);
	}
	else
	{
		sprintf(abs_fp, "%s/%s", cwd, fp);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x7e0, %rsp            # imm = 0x7E0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3f0(%rsp), %r15
movl $0x3e8, %esi            # imm = 0x3E8
movq %r15, %rdi
callq 0x20c0
movq %rsp, %rdi
movq %r15, %rsi
callq 0x2130
cmpb $0x2f, (%rbx)
jne 0x437b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2130
jmp 0x4392
leaq 0x6630(%rip), %rsi      # 0xa9b2
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2060
addq $0x7e0, %rsp            # imm = 0x7E0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/utils.cpp
// Function: get_file_size(char*)
long int get_file_size(char* fp)
{
	FILE* f = NULL;

	// If the file is "stdin", load the standard input.
	if(strcmp(fp, "stdin") == 0)
	{
		fprintf(stderr, "Cannot buffer stdin.\n");
		return(-1);
	}
	else
	{
		// Open the file if it is not the stdin.
		f = fopen(fp, "rb");
		if (f == NULL) 
		{ 
			fprintf(stderr, "Could not open %s\n", fp);
			return(-1);
		} 
	}

	fseek(f, 0, SEEK_END);
	long int file_size = ftell(f);
	fprintf(stderr, "Loading %s of %ld bytes.\n", fp, file_size);

	return(file_size);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5ce3(%rip), %rsi      # 0xa315
callq 0x2210
testl %eax, %eax
jne 0x4642
callq 0x2dd7
jmp 0x4671
leaq 0x5a25(%rip), %rsi      # 0xa06e
movq %rbx, %rdi
callq 0x2190
testq %rax, %rax
jne 0x467a
movq 0xa983(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x5a16(%rip), %rsi      # 0xa07d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2230
movq $-0x1, %r14
jmp 0x46b5
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2180
movq %r14, %rdi
callq 0x2030
movq %rax, %r14
movq 0xa942(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x63ae(%rip), %rsi      # 0xaa56
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2230
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/utils.cpp
// Function: load_file(char*)
t_file_buffer* load_file(char* fp)
{
	FILE* f = NULL;

	// If the file is "stdin", load the standard input.
	if(strcmp(fp, "stdin") == 0)
	{
		fprintf(stderr, "Cannot buffer stdin.\n");
		return(NULL);
	}
	else
	{
		// Open the file if it is not the stdin.
		f = fopen(fp, "rb");
		if (f == NULL) 
		{ 
			fprintf(stderr, "Could not open %s\n", fp);
			return(NULL);
		} 
	}

	fseek(f, 0, SEEK_END);
	long int file_size = ftell(f);
if(__DUMP_UTIL_MESSAGES__)
{
	fprintf(stderr, "Loading %s of %ld bytes.\n", fp, file_size);
}

	fseek(f, 0, SEEK_SET);
	char* file_buff = new char[file_size + 1];

if(__DUMP_UTIL_MESSAGES__)
{
	fprintf(stderr, "Allocated buffer memory.\n");
}

	if (file_size != (long int)fread(file_buff, sizeof(char), file_size, f)) 
	{ 
		delete [] file_buff;
		return NULL;
	}

if(__DUMP_UTIL_MESSAGES__)
{
	fprintf(stderr, "Read successfully.\n");
}

	fclose(f);
	file_buff[file_size] = 0;

	t_file_buffer* file_buffer = new t_file_buffer();
	file_buffer->file_buffer = file_buff;
	file_buffer->f_ptr = 0;
	file_buffer->l_file = file_size;

	return file_buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
leaq 0x5c46(%rip), %rsi      # 0xa315
callq 0x2210
testl %eax, %eax
je 0x47a6
leaq 0x598b(%rip), %rsi      # 0xa06e
movq %r15, %rdi
callq 0x2190
testq %rax, %rax
je 0x47ad
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2180
movq %rbx, %rdi
callq 0x2030
movq %rax, %r14
cmpb $0x1, 0xaa7a(%rip)      # 0xf192
je 0x47cc
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2180
leaq 0x1(%r14), %rdi
callq 0x2040
movq %rax, %r15
cmpb $0x1, 0xaa55(%rip)      # 0xf192
je 0x47ef
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2240
cmpq %rax, %r14
jne 0x4793
cmpb $0x1, 0xaa30(%rip)      # 0xf192
je 0x47f9
movq %rbx, %rdi
callq 0x2150
movb $0x0, (%r15,%r14)
movl $0x18, %edi
callq 0x2160
movq %rax, %rbx
movq %r15, (%rax)
movq $0x0, 0x8(%rax)
movq %r14, 0x10(%rax)
jmp 0x479d
movq %r15, %rdi
callq 0x21f0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2e2b
jmp 0x479b
movq 0xa82c(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x58bf(%rip), %rsi      # 0xa07d
xorl %ebx, %ebx
movq %r15, %rdx
xorl %eax, %eax
callq 0x2230
jmp 0x479d
movq 0xa80d(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x6279(%rip), %rsi      # 0xaa56
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2230
jmp 0x471e
callq 0x2df3
jmp 0x4743
callq 0x2e0f
jmp 0x4768
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/utils.cpp
// Function: get_next_string(_IO_FILE*, char*, int)
int get_next_string(FILE* file, char* buff, int buff_size)
{
	memset(buff, 0, buff_size);

	int i_s = 0;
	int ret = 0;
	ret = getc(file);
	while(ret != ' ' && ret != EOF && ret != '\n' && ret != '\t')
	{		
		buff[i_s] = ret;
		i_s++;
		ret = getc(file);
	} // file reading loop.

	return(ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %rdx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x20e0
movabsq $0x200000c01, %r15      # imm = 0x200000C01
movq %r14, %rdi
callq 0x2070
movl %eax, %ecx
incl %ecx
cmpl $0x21, %ecx
ja 0x485b
btq %rcx, %r15
jb 0x4862
movb %al, (%rbx)
incq %rbx
jmp 0x4844
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/utils.cpp
// Function: line_empty(char*)
bool line_empty(char* line)
{
	int l = strlen(line);
	for(int i = 0; i < l; i++)
	{
		if(line[i] != ' ' &&
			line[i] != '\t' &&
			line[i] != '\n')
		{
			return(false);
		}
	}

	return(true);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x20a0
testl %eax, %eax
jle 0x4c84
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, %rdx
negq %rdx
movl $0x1, %esi
xorl %ecx, %ecx
movabsq $0x100000600, %rdi      # imm = 0x100000600
movzbl -0x1(%rbx,%rsi), %r8d
cmpq $0x20, %r8
ja 0x4c86
btq %r8, %rdi
jae 0x4c86
cmpq %rax, %rsi
setae %cl
leaq (%rdx,%rsi), %r8
incq %r8
incq %rsi
cmpq $0x1, %r8
jne 0x4c5a
jmp 0x4c86
movb $0x1, %cl
andb $0x1, %cl
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::t_string(char*)
t_string::t_string(char* string)
{
	// Allocate the memory.
	//this->obj_string = (char*)malloc(string_length(string) + 3);
	//this->obj_str_mem_size = string_length(string) + 1;

	this->string_buffer = new t_string_buffer();
	this->string_buffer->i_buff = 0;
	this->string_buffer->l_buffer_mem = IBS;
	this->string_buffer->string_buff = new char[IBS+3];

	this->copy(string);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x2160
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, (%r14)
movl $0x1f4, 0x8(%rax)       # imm = 0x1F4
movl $0x1f7, %edi            # imm = 0x1F7
callq 0x2040
movq %rax, (%r15)
movb (%rbx), %al
testb %al, %al
je 0x50d6
incq %rbx
movsbl %al, %esi
movq %r14, %rdi
callq 0x5f5c
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x50c2
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::t_string(t_string*)
t_string::t_string(t_string* string)
{
	// Allocate the memory.
	//this->obj_string = (char*)malloc(string_length(string) + 3);
	//this->obj_str_mem_size = string_length(string) + 1;
	this->string_buffer = new t_string_buffer();
	this->string_buffer->i_buff = 0;
	this->string_buffer->l_buffer_mem = IBS;
	this->string_buffer->string_buff = new char[IBS+3];

	this->copy(string);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x10, %edi
callq 0x2160
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, (%rbx)
movl $0x1f4, 0x8(%rax)       # imm = 0x1F4
movl $0x1f7, %edi            # imm = 0x1F7
callq 0x2040
movq %rax, (%r15)
movq (%r14), %rax
movq (%rax), %r14
movb (%r14), %al
testb %al, %al
je 0x517a
incq %r14
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5f5c
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x5165
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::sort_strings_per_prefix(char*, char*)
bool t_string::sort_strings_per_prefix(char* str1, char* str2)
{
	int l1 = t_string::string_length(str1);
	int l2 = t_string::string_length(str2);
	int max_l12 = (l1 > l2)?(l1):(l2);
	for(int i = 0; i < max_l12; i++)
	{
		// First string is shorter and the prefixes match exactly, put str1 frist.
		if(str1[i] == 0)
		{
			return(true);
		}

		// The second string is shorter, it should come before first.
		if(str2[i] == 0)
		{
			return(false);
		}

		if(str1[i] < str2[i])
		{
			return(true);
		}
		else if(str1[i] > str2[i])
		{
			return(false);
		}
	} // i loop.

	// Strings are exactly the same, return false to obey strict weak ordering.
	return(false);
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incl %eax
cmpb $0x0, (%rdi,%rax)
jne 0x520f
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
incl %ecx
cmpb $0x0, (%rsi,%rcx)
jne 0x521c
cmpl %ecx, %eax
movl %ecx, %edx
cmovgl %eax, %edx
testl %edx, %edx
jle 0x5273
movb (%rdi), %r9b
testb %r9b, %r9b
je 0x5277
movl %edx, %edx
cmpl %ecx, %eax
cmovgl %eax, %ecx
movb $0x1, %al
movl $0x1, %r10d
movb -0x1(%rsi,%r10), %r11b
testb %r11b, %r11b
je 0x527b
movb $0x1, %r8b
cmpb %r11b, %r9b
jl 0x5280
jg 0x527b
cmpq %rdx, %r10
setb %al
cmpq %r10, %rcx
je 0x5280
movb (%rdi,%r10), %r9b
incq %r10
testb %r9b, %r9b
jne 0x5246
jmp 0x5280
xorl %eax, %eax
jmp 0x5283
movb $0x1, %al
jmp 0x5283
xorl %r8d, %r8d
jmp 0x5280
andb %r8b, %al
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::get_matching_prefix_length(char*, char*)
int t_string::get_matching_prefix_length(char* str1, char* str2)
{
	int l1 = string_length(str1);
	int l2 = string_length(str2);
	int l_str_2_match = (l1 < l2)?(l1):(l2);
	for(int i = 0; i < l_str_2_match; i++)
	{
		if(str1[i] != str2[i])
		{
			return(i);
		}
	} // i loop.

	return(l_str_2_match);
}

// Assembly:
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
incl %edx
cmpb $0x0, (%rdi,%rdx)
jne 0x530d
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
incl %ecx
cmpb $0x0, (%rsi,%rcx)
jne 0x531a
cmpl %ecx, %edx
movl %ecx, %eax
cmovll %edx, %eax
testl %eax, %eax
jle 0x534a
cmpl %ecx, %edx
cmovll %edx, %ecx
xorl %edx, %edx
movb (%rdi,%rdx), %r8b
cmpb (%rsi,%rdx), %r8b
jne 0x534c
incq %rdx
cmpq %rdx, %rcx
jne 0x5334
movl %eax, %edx
jmp 0x534c
xorl %edx, %edx
cmpl %eax, %edx
cmovll %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::compare_strings_per_total_prefix(char*, char*)
bool t_string::compare_strings_per_total_prefix(char* str1, char* str2)
{
	int l1 = t_string::string_length(str1);
	int l2 = t_string::string_length(str2);
	int l_match_prefix = t_string::get_matching_prefix_length(str1, str2);

	if(l1 == l_match_prefix ||
		l2 == l_match_prefix)
	{
		return(true);
	}

	return(false);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movl %ebx, %eax
incl %ebx
cmpb $0x0, (%rdi,%rax)
jne 0x5357
xorl %ebp, %ebp
movl %ebp, %eax
incl %ebp
cmpb $0x0, (%rsi,%rax)
jne 0x5363
callq 0x5308
incl %eax
cmpl %ebx, %eax
sete %cl
cmpl %ebp, %eax
sete %al
orb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::compare_strings(char const*, char const*)
bool t_string::compare_strings(const char* str1, const char* str2)
{
	if(str1 == NULL || str2 == NULL)
	{
		return(false);
	}

	int str_len1 = string_length(str1);
	int str_len2 = string_length(str2);
	if(str_len1 != str_len2)
	{
		return(false);
	}

	for(int i = 0; i < str_len1; i++)
	{
		if(str1[i] != str2[i])
		{
			return(false);
		}
	}

	return(true);
}

// Assembly:
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x58e8
movl %eax, %ecx
incl %eax
cmpb $0x0, (%rdi,%rcx)
jne 0x58ae
leal -0x1(%rax), %ecx
xorl %edx, %edx
movl %edx, %r8d
incl %edx
cmpb $0x0, (%rsi,%r8)
jne 0x58bd
cmpl %edx, %eax
jne 0x58e9
testl %ecx, %ecx
jle 0x58ec
movl %ecx, %eax
xorl %ecx, %ecx
movb (%rdi,%rcx), %dl
cmpb (%rsi,%rcx), %dl
jne 0x58e9
incq %rcx
cmpq %rcx, %rax
jne 0x58d5
setbe %al
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::fast_count_non_empty_tokens(char*, char*)
int t_string::fast_count_non_empty_tokens(char* str, char* delims)
{
	int n_delims = t_string::string_length(delims);
	int n_toks = 0;
	int l_cur_tok = 0;
	int i = 0;
	while(str[i] != 0)
	{
		//bool found_delim = false;
		for(int i_d = 0; i_d < n_delims; i_d++)
		{
			if(str[i] == delims[i_d])
			{
				if(l_cur_tok > 0)
				{
					n_toks++;
					l_cur_tok = 0;
				}
				else
				{
					// This is an empty token, do not count it.
				}
			}
			else
			{
				// This is a non-delim char, update the current token length.
				l_cur_tok++;
				break;
			}
		} // i_d loop.

		i++;
	} // string loop.

	if(l_cur_tok > 0)
	{
		n_toks++;
	}

	return(n_toks);
}

// Assembly:
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
incl %ecx
cmpb $0x0, (%rsi,%rcx)
jne 0x5a69
movb (%rdi), %r11b
testb %r11b, %r11b
je 0x5aca
pushq %rbp
pushq %rbx
movl %ecx, %edx
xorl %r8d, %r8d
xorl %r10d, %r10d
xorl %r9d, %r9d
xorl %eax, %eax
testl %ecx, %ecx
jle 0x5ab0
xorl %ebx, %ebx
cmpb (%rsi,%rbx), %r11b
jne 0x5aad
xorl %ebp, %ebp
testl %r9d, %r9d
cmovnsl %r8d, %r9d
setg %bpl
addl %ebp, %eax
incq %rbx
cmpq %rbx, %rdx
jne 0x5a8e
jmp 0x5ab0
incl %r9d
movb 0x1(%rdi,%r10), %r11b
incq %r10
testb %r11b, %r11b
jne 0x5a88
xorl %ecx, %ecx
testl %r9d, %r9d
setg %cl
addl %ecx, %eax
popq %rbx
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::get_integers_in_string(char*)
vector<int>* t_string::get_integers_in_string(char* str)
{
	vector<int>* int_vector = new vector<int>();
	int l_str = t_string::string_length(str);

	// The number string.
	t_string* cur_int_str = new t_string();

	for(int char_i = 0; char_i < l_str; char_i++)
	{
		if(str[char_i] >= '0' && str[char_i] <= '9')
		{
			// Add this character.
			cur_int_str->concat_char(str[char_i]);
		}
		else
		{
			if(cur_int_str->length() > 0)
			{
				int new_num = str2num(cur_int_str, 10);

				// Add the new number
				int_vector->push_back(new_num); 

				cur_int_str->empty();
			}
		}
	} // char index.

	// Process the last string if it is a number.
	if(cur_int_str->length() > 0)
	{
		int new_num = str2num(cur_int_str, 10);

		// Add the new number
		int_vector->push_back(new_num); 

		cur_int_str->empty();
	}

	// Free integer storing string.
	delete(cur_int_str);

	return(int_vector);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl $0x18, %edi
callq 0x2160
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
incl %r13d
cmpb $0x0, (%r15,%r13)
jne 0x5e05
movl $0x8, %edi
callq 0x2160
movq %rax, %r14
movl $0x10, %edi
callq 0x2160
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, (%r14)
movl $0x1f4, 0x8(%rax)       # imm = 0x1F4
movl $0x1f7, %edi            # imm = 0x1F7
callq 0x2040
movq %rax, (%r12)
movl $0x0, 0xc(%r12)
movb $0x0, (%rax)
testl %r13d, %r13d
jle 0x5f1c
movl %r13d, %r13d
xorl %ebp, %ebp
leaq 0x4(%rsp), %r12
movb (%r15,%rbp), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x5e7f
movsbl %al, %esi
movq %r14, %rdi
callq 0x5f5c
jmp 0x5eca
movq (%r14), %rax
cmpl $0x0, 0xc(%rax)
jle 0x5eca
movq (%rax), %rdi
movl $0xa, %esi
callq 0x8544
movl %eax, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5eaf
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5eba
movq %rbx, %rdi
movq %r12, %rdx
callq 0x418a
movq (%r14), %rax
movl $0x0, 0xc(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
incq %rbp
cmpq %rbp, %r13
jne 0x5e66
movq (%r14), %rax
cmpl $0x0, 0xc(%rax)
jle 0x5f1c
movq (%rax), %rdi
movl $0xa, %esi
callq 0x8544
movl %eax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5f01
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5f0c
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x418a
movq (%r14), %rax
movl $0x0, 0xc(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x5db0
movl $0x8, %esi
movq %r14, %rdi
callq 0x2170
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x8, %esi
movq %r14, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::get_integers_in_string()
vector<int>* t_string::get_integers_in_string()
{
	vector<int>* int_vector = new vector<int>();

	// The number string.
	t_string* cur_int_str = new t_string();

	int l_str = this->length();
	for(int char_i = 0; char_i < l_str; char_i++)
	{
		if(this->x(char_i) >= '0' && this->x(char_i) <= '9')
		{
			// Add this character.
			cur_int_str->concat_char(this->x(char_i));
		}
		else
		{
			if(cur_int_str->length() > 0)
			{
				int new_num = str2num(cur_int_str, 10);

				// Add the new number
				int_vector->push_back(new_num); 

				cur_int_str->empty();
			}
		}
	} // char index.

	// Process the last string if it is a number.
	if(cur_int_str->length() > 0)
	{
		int new_num = str2num(cur_int_str, 10);

		// Add the new number
		int_vector->push_back(new_num); 

		cur_int_str->empty();
	}

	// Free integer storing string.
	delete(cur_int_str);

	return(int_vector);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl $0x18, %edi
callq 0x2160
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movl $0x8, %edi
callq 0x2160
movq %rax, %r14
movl $0x10, %edi
callq 0x2160
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, (%r14)
movl $0x1f4, 0x8(%rax)       # imm = 0x1F4
movl $0x1f7, %edi            # imm = 0x1F7
callq 0x2040
movq %rax, (%r12)
movl $0x0, 0xc(%r12)
movb $0x0, (%rax)
movq (%r15), %rax
movslq 0xc(%rax), %r13
testq %r13, %r13
jle 0x6155
xorl %ebp, %ebp
leaq 0x4(%rsp), %r12
movq (%r15), %rax
movq (%rax), %rax
movb (%rax,%rbp), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x60b8
movsbl %al, %esi
movq %r14, %rdi
callq 0x5f5c
jmp 0x6103
movq (%r14), %rax
cmpl $0x0, 0xc(%rax)
jle 0x6103
movq (%rax), %rdi
movl $0xa, %esi
callq 0x8544
movl %eax, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x60e8
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x60f3
movq %rbx, %rdi
movq %r12, %rdx
callq 0x418a
movq (%r14), %rax
movl $0x0, 0xc(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
incq %rbp
cmpq %rbp, %r13
jne 0x609a
movq (%r14), %rax
cmpl $0x0, 0xc(%rax)
jle 0x6155
movq (%rax), %rdi
movl $0xa, %esi
callq 0x8544
movl %eax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x613a
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6145
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x418a
movq (%r14), %rax
movl $0x0, 0xc(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x5db0
movl $0x8, %esi
movq %r14, %rdi
callq 0x2170
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x8, %esi
movq %r14, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::get_alphanumeric(char*)
char* t_string::get_alphanumeric(char* string)
{
	int l_str = t_string::string_length(string);
	char* alphanum_string = new char[l_str + 2];
	//memset(alphanum_string, 0, l_str);
	t_string::set_byte_buffer(alphanum_string, l_str, 0);
	int i_an = 0;
	for(int i = 0; i < l_str; i++)
	{
		// Update if this is an alphanumeric character.
		if((string[i] >= 'a' && string[i] <= 'z') ||
			(string[i] >= 'A' && string[i] <= 'Z') ||
			(string[i] >= '0' && string[i] <= '9'))
		{
			alphanum_string[i_an] = string[i];
			i_an++;
		}
	} // i loop.

	return(alphanum_string);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
incl %r15d
cmpb $0x0, (%rbx,%r15)
jne 0x61af
leal 0x2(%r15), %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, %r14
testl %r15d, %r15d
jle 0x6210
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20e0
movl %r15d, %eax
xorl %ecx, %ecx
movb (%rbx,%r12), %dl
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
jb 0x61ff
movl %edx, %esi
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x19, %sil
ja 0x6208
movslq %ecx, %rcx
movb %dl, (%r14,%rcx)
incl %ecx
incq %r12
cmpq %r12, %rax
jne 0x61e2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::substring(char const*, int, int)
char* t_string::substring(const char* str, int i, int j)
{
	//t_string* sub_str = new t_string();
	char* sub_str = NULL;

	int l_str = t_string::string_length(str);

	// Validity checks on the arguments.
	if(i > j ||
		i > l_str)
	{
		return(NULL);
	}
	else if(j >= l_str)
	{
		j = l_str-1;
	}

	sub_str = new char[j-i+1+2];
	sub_str[0] = 0; // Make this an empty string.

	// Copy the substring.
	int ip = i;
	int i_sub_str = 0;
	while(ip <= j)
	{
		sub_str[i_sub_str] = str[ip];

		i_sub_str++;
		ip++;
	}

	// End the string.
	sub_str[i_sub_str] = 0;

	return(sub_str);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incl %eax
cmpb $0x0, (%rbx,%rax)
jne 0x624f
cmpl %edx, %ebp
setg %cl
cmpl %ebp, %eax
setl %sil
orb %cl, %sil
je 0x626c
xorl %r14d, %r14d
jmp 0x62b7
leal -0x1(%rax), %r15d
cmpl %edx, %eax
cmovgl %edx, %r15d
movl %r15d, %eax
subl %ebp, %eax
addl $0x3, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, %r14
movb $0x0, (%rax)
subl %ebp, %r15d
jge 0x6295
xorl %eax, %eax
jmp 0x62b2
movslq %ebp, %rax
addq %rax, %rbx
movl %r15d, %r15d
incq %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2100
movl %r15d, %eax
movb $0x0, (%r14,%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::substring(int, int)
char* t_string::substring(int i, int j)
{
	//t_string* sub_str = new t_string();
	char* sub_str;

	// Validity checks on the arguments.
	if(i > j ||
		i > this->length() || 
		j > this->length())
	{
		return(NULL);
	}
	else
	{
		sub_str = (char*)malloc(sizeof(char) * (j-i+1+2));
		sub_str[0] = 0; // Make this an empty string.
	}

	// Copy the substring.
	int ip = i;
	int i_sub_str = 0;
	while(ip <= j)
	{
		sub_str[i_sub_str] = this->x(ip);

		i_sub_str++;
		ip++;
	}

	// End the string.
	sub_str[i_sub_str] = 0;

	return(sub_str);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
subl %esi, %ebx
jl 0x62dd
movq (%rdi), %r15
cmpl %edx, 0xc(%r15)
jge 0x62e2
xorl %r14d, %r14d
jmp 0x6312
movl %esi, %ebp
leal 0x3(%rbx), %eax
movslq %eax, %rdi
callq 0x2200
movq %rax, %r14
xorl %r12d, %r12d
movb %r12b, (%rax)
movslq %ebp, %rsi
addq (%r15), %rsi
incq %rbx
movq %rax, %rdi
movq %rbx, %rdx
callq 0x2100
movl %ebx, %eax
movb %r12b, (%r14,%rax)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq