LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, %rsi
movq %rsi, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x96d0
testb $0x1, %al
jne 0x20b92
jmp 0x20b94
jmp 0x20bb9
movq -0x30(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x9b90
movq %rax, %rsi
addq $0x10, %rsi
leaq -0x10(%rbp), %rdi
callq 0x20bc0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: AgathokakologicalBit[P]wit/src/annotation/context_generation.cpp
// Function: akbit::system::annotation::(anonymous namespace)::cg_visit_condition(std::shared_ptr<akbit::system::Node>, akbit::system::Node::condition_t&, std::shared_ptr<akbit::system::Context>, bool)
void cg_visit_condition(std::shared_ptr<Node> node, Node::condition_t &val, std::shared_ptr<Context> ctx, bool reg_vars)
    {
      cg_visit(val.expression, ctx, reg_vars);
      cg_visit(val.clause_true, ctx, reg_vars);
      cg_visit(val.clause_false, ctx, reg_vars);

      node->result_type = Node::etype_t::any;
      if (val.clause_false && val.clause_false->result_type != val.clause_true->result_type)
        node->result_type = val.clause_false->result_type;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdx, -0xa8(%rbp)
movq %rdi, -0xb0(%rbp)
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x9b20
movq -0xa8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xa380
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movzbl -0x19(%rbp), %edx
andl $0x1, %edx
callq 0x2a060
jmp 0x2b383
leaq -0x40(%rbp), %rdi
callq 0xabf0
leaq -0x30(%rbp), %rdi
callq 0x9b50
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x9b20
movq -0xa8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xa380
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movzbl -0x19(%rbp), %edx
andl $0x1, %edx
callq 0x2a060
jmp 0x2b3e0
leaq -0x70(%rbp), %rdi
callq 0xabf0
leaq -0x60(%rbp), %rdi
callq 0x9b50
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x9b20
movq -0xa8(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xa380
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
movzbl -0x19(%rbp), %edx
andl $0x1, %edx
callq 0x2a060
jmp 0x2b440
leaq -0x90(%rbp), %rdi
callq 0xabf0
leaq -0x80(%rbp), %rdi
callq 0x9b50
movq -0xb0(%rbp), %rdi
callq 0x9b90
movl $0x7, 0x50(%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x9b00
testb $0x1, %al
jne 0x2b47e
jmp 0x2b543
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x9b90
movl 0x50(%rax), %eax
movl %eax, -0xd4(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x9b90
movq %rax, %rcx
movl -0xd4(%rbp), %eax
cmpl 0x50(%rcx), %eax
je 0x2b543
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x9b90
movq -0xb0(%rbp), %rdi
movl 0x50(%rax), %eax
movl %eax, -0xd8(%rbp)
callq 0x9b90
movl -0xd8(%rbp), %ecx
movl %ecx, 0x50(%rax)
jmp 0x2b543
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xabf0
leaq -0x30(%rbp), %rdi
callq 0x9b50
jmp 0x2b54c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xabf0
leaq -0x60(%rbp), %rdi
callq 0x9b50
jmp 0x2b54c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xabf0
leaq -0x80(%rbp), %rdi
callq 0x9b50
jmp 0x2b54c
addq $0xe0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4560
nopw %cs:(%rax,%rax)
// File: AgathokakologicalBit[P]wit/src/annotation/context_generation.cpp
// Function: akbit::system::annotation::(anonymous namespace)::cg_visit_block(std::shared_ptr<akbit::system::Node>, akbit::system::Node::block_t&, std::shared_ptr<akbit::system::Context>, bool)
void cg_visit_block(std::shared_ptr<Node>, Node::block_t &val, std::shared_ptr<Context> ctx, bool reg_vars)
    {
      auto rt = Node::etype_t::unknown;
      for (auto stmt : val.code)
      {
        cg_visit(stmt, ctx, reg_vars);
        rt = stmt->result_type;
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x80(%rbp)
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x18160
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x17fa0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x22a70
testb $0x1, %al
jne 0x2b6f1
jmp 0x2b7b5
leaq -0x30(%rbp), %rdi
callq 0x184a0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x9b20
movq -0x98(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x9b20
movq -0x80(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xa380
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movzbl -0x19(%rbp), %edx
andl $0x1, %edx
callq 0x2a060
jmp 0x2b754
leaq -0x68(%rbp), %rdi
callq 0xabf0
leaq -0x58(%rbp), %rdi
callq 0x9b50
leaq -0x48(%rbp), %rdi
callq 0x9b90
movl 0x50(%rax), %eax
movl %eax, -0x20(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9b50
leaq -0x30(%rbp), %rdi
callq 0x22ab0
jmp 0x2b6db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xabf0
leaq -0x58(%rbp), %rdi
callq 0x9b50
leaq -0x48(%rbp), %rdi
callq 0x9b50
jmp 0x2b7be
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x4560
nopw (%rax,%rax)
// File: AgathokakologicalBit[P]wit/src/annotation/context_generation.cpp
// Function: akbit::system::annotation::(anonymous namespace)::cg_visit_value_function(std::shared_ptr<akbit::system::Node>, akbit::system::Node::value_function_t&, std::shared_ptr<akbit::system::Context>, bool)
void cg_visit_value_function(std::shared_ptr<Node> node, Node::value_function_t &val, std::shared_ptr<Context> ctx, bool reg_vars)
    {
      // TODO: Determine body return type
      node->result_type = Node::etype_t::function;
      auto sub_context = std::make_shared<Context>(ctx);
      val.owned_context = sub_context;
      for (auto param : val.parameters)
        cg_visit(param, sub_context, true);
      cg_visit(val.body, sub_context, reg_vars);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdx, -0xb0(%rbp)
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
callq 0x9b90
movq -0xb0(%rbp), %rsi
movl $0x5, 0x50(%rax)
leaq -0x30(%rbp), %rdi
callq 0x302a0
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
leaq -0x30(%rbp), %rsi
callq 0x241c0
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x18160
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x17fa0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x22a70
testb $0x1, %al
jne 0x2cbca
jmp 0x2cc83
leaq -0x40(%rbp), %rdi
callq 0x184a0
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x9b20
movq -0xc8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x9b20
leaq -0x78(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
leaq -0x30(%rbp), %rsi
callq 0xa380
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movl $0x1, %edx
callq 0x2a060
jmp 0x2cc2b
leaq -0x78(%rbp), %rdi
callq 0xabf0
leaq -0x68(%rbp), %rdi
callq 0x9b50
leaq -0x58(%rbp), %rdi
callq 0x9b50
leaq -0x40(%rbp), %rdi
callq 0x22ab0
jmp 0x2cbb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xabf0
leaq -0x68(%rbp), %rdi
callq 0x9b50
leaq -0x58(%rbp), %rdi
callq 0x9b50
jmp 0x2cd22
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
leaq -0x98(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x9b20
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq -0x30(%rbp), %rsi
callq 0xa380
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
movzbl -0x19(%rbp), %edx
andl $0x1, %edx
callq 0x2a060
jmp 0x2ccd1
leaq -0xa8(%rbp), %rdi
callq 0xabf0
leaq -0x98(%rbp), %rdi
callq 0x9b50
leaq -0x30(%rbp), %rdi
callq 0xabf0
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xabf0
leaq -0x98(%rbp), %rdi
callq 0x9b50
leaq -0x30(%rbp), %rdi
callq 0xabf0
movq -0x80(%rbp), %rdi
callq 0x4560
nopw %cs:(%rax,%rax)
// File: AgathokakologicalBit[P]wit/src/annotation/../context.hpp
// Function: akbit::system::Context::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
std::vector<std::shared_ptr<DeclarationRecord>> get(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; });
      return results;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x19(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x2e610
movq -0x78(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x70(%rbp)
callq 0x2e6c0
movq -0x70(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x2e6f0
movq -0x68(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x2e720
movq %rax, -0x60(%rbp)
jmp 0x2e532
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x30140
movq %rax, -0x88(%rbp)
jmp 0x2e560
movq -0x88(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2e597
jmp 0x2e58e
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x2e5b0
jmp 0x2e5a4
movq -0x68(%rbp), %rdi
callq 0x2e5b0
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4560
nopl (%rax)
// File: AgathokakologicalBit[P]wit/src/code_generation/generators/javascript/generator.cpp
// Function: akbit::system::code_generation::js::(anonymous namespace)::cg_visit_function_call[abi:cxx11](std::shared_ptr<akbit::system::Node>, akbit::system::Node::function_call_t&, akbit::system::code_generation::js::Settings)
std::string cg_visit_function_call(std::shared_ptr<Node>, Node::function_call_t &val, Settings s)
    {
      std::string res = "(" + cg_visit(val.expression, s) + ")";
      s.vectorise_tuple = false;
      res += cg_visit(val.arguments, s);
      return res;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x128(%rbp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, -0x120(%rbp)
movq %rdi, -0x8(%rbp)
movq %rcx, -0x28(%rbp)
movb %al, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x9b20
movq -0x118(%rbp), %rsi
movl -0x10(%rbp), %eax
movl %eax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl -0x98(%rbp), %eax
movl %eax, -0xa8(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rdx
movl -0xa8(%rbp), %ecx
leaq -0x80(%rbp), %rdi
callq 0x31180
jmp 0x339a8
leaq 0x32a1(%rip), %rsi      # 0x36c50
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x34e50
jmp 0x339be
movq -0x128(%rbp), %rdi
leaq 0x32a9(%rip), %rdx      # 0x36c75
leaq -0x60(%rbp), %rsi
callq 0x11a50
jmp 0x339d7
leaq -0x60(%rbp), %rdi
callq 0x4210
leaq -0x80(%rbp), %rdi
callq 0x4210
leaq -0x90(%rbp), %rdi
callq 0x9b50
movb $0x0, -0x10(%rbp)
movq -0x38(%rbp), %rsi
addq $0x10, %rsi
leaq -0xf0(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x9b20
movq -0x130(%rbp), %rsi
movl -0x10(%rbp), %eax
movl %eax, -0xf8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0xf8(%rbp), %eax
movl %eax, -0x108(%rbp)
movq -0x100(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x110(%rbp), %rdx
movl -0x108(%rbp), %ecx
leaq -0xe0(%rbp), %rdi
callq 0x31180
jmp 0x33a64
movq -0x128(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x4410
jmp 0x33a79
leaq -0xe0(%rbp), %rdi
callq 0x4210
leaq -0xf0(%rbp), %rdi
callq 0x9b50
movb $0x1, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x33b56
jmp 0x33b4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x33af0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x33ae7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4210
leaq -0x80(%rbp), %rdi
callq 0x4210
leaq -0x90(%rbp), %rdi
callq 0x9b50
jmp 0x33b66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x33b30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x4210
leaq -0xf0(%rbp), %rdi
callq 0x9b50
movq -0x128(%rbp), %rdi
callq 0x4210
jmp 0x33b66
movq -0x128(%rbp), %rdi
callq 0x4210
movq -0x120(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x4560
nopw %cs:(%rax,%rax)
// File: allasandeep[P]LocationBoundaryFinder/prog2.cc
// Function: main
int main()
{
	string regionName = "";
	PGconn *db;
	db = conn();
	cout<<"Enter the Region Name: ";
	//Reading the user input
	std::getline(cin,regionName);
	//Calling the getRegionData by passing regionName and db connection
	getRegionData(regionName,db);

	PQfinish(db);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x22c0
movq -0x70(%rbp), %rdx
leaq 0x2b83(%rip), %rsi      # 0x517d
leaq -0x28(%rbp), %rdi
callq 0x3840
jmp 0x2605
leaq -0x29(%rbp), %rdi
callq 0x2380
callq 0x2540
movq %rax, -0x78(%rbp)
jmp 0x2619
movq -0x78(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x4988(%rip), %rdi      # 0x6fb0
leaq 0x2a7b(%rip), %rsi      # 0x50aa
callq 0x21b0
jmp 0x2636
movq 0x499b(%rip), %rdi      # 0x6fd8
leaq -0x28(%rbp), %rsi
callq 0x2160
jmp 0x2648
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x20a0
jmp 0x2657
movq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x26f0
jmp 0x2666
leaq -0x68(%rbp), %rdi
callq 0x2240
movq -0x48(%rbp), %rdi
callq 0x2260
jmp 0x267a
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2240
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x2380
jmp 0x26d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x26d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2240
leaq -0x28(%rbp), %rdi
callq 0x2240
movq -0x38(%rbp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
// File: akdess[P]BAFExtract/src/main.cpp
// Function: allocate_pileup(int)
unsigned short** allocate_pileup(int l_sig)
{
  unsigned short** loaded_pileup = new unsigned short*[5];
  for (int i_allele = 0; i_allele < 5; i_allele++)
  {
    loaded_pileup[i_allele] = new unsigned short[l_sig + 2];
    memset(loaded_pileup[i_allele], 0, sizeof(unsigned short) * (l_sig + 2));
  } // i_allele loop.

  return loaded_pileup;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x28, %edi
callq 0x2040
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x5, 0x4(%rsp)
jge 0x24b0
movl 0x14(%rsp), %eax
addl $0x2, %eax
cltq
movl $0x2, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2040
movq %rax, %rdx
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movl 0x14(%rsp), %eax
addl $0x2, %eax
movslq %eax, %rdx
shlq %rdx
xorl %esi, %esi
callq 0x2110
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x243f
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movl $0x400, %edi            # imm = 0x400
callq 0x2040
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x100, 0xc(%rsp)       # imm = 0x100
jge 0x2503
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movl $0x4, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x24db
movq 0x10(%rsp), %rax
movl $0x0, 0x104(%rax)
movq 0x10(%rsp), %rax
movl $0x1, 0x10c(%rax)
movq 0x10(%rsp), %rax
movl $0x2, 0x11c(%rax)
movq 0x10(%rsp), %rax
movl $0x3, 0x150(%rax)
movq 0x10(%rsp), %rax
movl $0x3, 0x154(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x184(%rax)
movq 0x10(%rsp), %rax
movl $0x1, 0x18c(%rax)
movq 0x10(%rsp), %rax
movl $0x2, 0x19c(%rax)
movq 0x10(%rsp), %rax
movl $0x3, 0x1d0(%rax)
movq 0x10(%rsp), %rax
movl $0x3, 0x1d4(%rax)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x3f8, %rsp            # imm = 0x3F8
movq %rdi, 0x3f0(%rsp)
movq 0x3f0(%rsp), %rdi
leaq 0x11a36(%rip), %rsi     # 0x14004
callq 0xcef0
testb $0x1, %al
jne 0x2609
movq 0x3f0(%rsp), %rdi
leaq 0x11a22(%rip), %rsi     # 0x14008
callq 0xcef0
testb $0x1, %al
jne 0x2609
movq 0x3f0(%rsp), %rdi
leaq 0x11a0e(%rip), %rsi     # 0x1400c
callq 0xcef0
testb $0x1, %al
jne 0x2609
jmp 0x262f
movq %rsp, %rdi
movq 0x3f0(%rsp), %rsi
addq $0x3, %rsi
callq 0x2150
movq 0x3f0(%rsp), %rdi
movq %rsp, %rsi
callq 0x2150
jmp 0x2631
jmp 0x2631
addq $0x3f8, %rsp            # imm = 0x3F8
retq
nopl (%rax)
// File: 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:
subq $0x438, %rsp            # imm = 0x438
movq %rdi, 0x430(%rsp)
movq %rsi, 0x428(%rsp)
movq %rdx, 0x420(%rsp)
movq 0x430(%rsp), %rdi
leaq 0x1199c(%rip), %rsi     # 0x1400a
callq 0x6f40
movq %rax, 0x418(%rsp)
movq 0x418(%rsp), %rdi
callq 0x6cd0
movq %rax, 0x410(%rsp)
cmpq $0x0, 0x410(%rsp)
jne 0x26a0
jmp 0x2740
movl $0x0, 0x1c(%rsp)
movq 0x410(%rsp), %rdi
leaq 0x20(%rsp), %rdx
leaq 0x11954(%rip), %rsi     # 0x14010
leaq 0x1c(%rsp), %rcx
movb $0x0, %al
callq 0x2160
cmpl $0x2, %eax
je 0x26f4
movq 0x1890c(%rip), %rax     # 0x1afe0
movq (%rax), %rdi
movq 0x410(%rsp), %rdx
leaq 0x11930(%rip), %rsi     # 0x14016
movb $0x0, %al
callq 0x2240
xorl %edi, %edi
callq 0x21d0
leaq 0x20(%rsp), %rdi
callq 0x25b0
movq 0x428(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x91e0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x4e70
movq 0x420(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x4ea0
jmp 0x267b
movq 0x418(%rsp), %rdi
callq 0x2170
addq $0x438, %rsp            # imm = 0x438
retq
nopw %cs:(%rax,%rax)
// File: akdess[P]BAFExtract/src/main.cpp
// Function: load_binary_sequence_file(char*, int&)
char* load_binary_sequence_file(char* bin_seq_fp, int& l_seq)
{
	FILE* f_bin_seq = open_f(bin_seq_fp, "rb");
	int l_bin_seq = 0;

	// Read the length.
	fread(&l_bin_seq, sizeof(int), 1, f_bin_seq);

	l_seq = l_bin_seq;

	// Read the sequence.
	char* bin_seq = new char[l_bin_seq + 2];
	fread(bin_seq, sizeof(char), l_bin_seq + 1, f_bin_seq);
	fclose(f_bin_seq);

	return(bin_seq);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0xffb8(%rip), %rsi      # 0x14042
callq 0x6f40
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x2260
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl 0xc(%rsp), %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, (%rsp)
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %esi
callq 0x2260
movq 0x10(%rsp), %rdi
callq 0x2170
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: akdess[P]BAFExtract/src/main.cpp
// Function: delete_pileup(unsigned short**)
void delete_pileup(unsigned short** loaded_pileup)
{
	//unsigned short** loaded_pileup = new unsigned short*[5];
	for (int i_allele = 0; i_allele < 5; i_allele++)
	{
		delete[] loaded_pileup[i_allele];
	} // i_allele loop.

	delete[] loaded_pileup;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x5, 0x1c(%rsp)
jge 0x415a
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x414b
movq 0x10(%rsp), %rdi
callq 0x2200
jmp 0x414d
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4121
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x4174
movq 0x8(%rsp), %rdi
callq 0x2200
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x3f8, %rsp            # imm = 0x3F8
movq %rdi, 0x3f0(%rsp)
movq %rsi, 0x3e8(%rsp)
movq %rsp, %rdi
callq 0x6440
movq 0x3f0(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x6416
movq 0x3e8(%rsp), %rdi
movq 0x3f0(%rsp), %rsi
callq 0x2150
jmp 0x6437
movq 0x3e8(%rsp), %rdi
movq %rsp, %rdx
movq 0x3f0(%rsp), %rcx
leaq 0xe5a0(%rip), %rsi      # 0x149d0
movb $0x0, %al
callq 0x2070
addq $0x3f8, %rsp            # imm = 0x3F8
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xdba5(%rip), %rsi      # 0x14333
callq 0x2220
cmpl $0x0, %eax
jne 0x67be
movq 0x14841(%rip), %rax     # 0x1afe0
movq (%rax), %rdi
leaq 0xe2b5(%rip), %rsi      # 0x14a5e
movb $0x0, %al
callq 0x2240
movq $-0x1, 0x20(%rsp)
jmp 0x6854
movq 0x18(%rsp), %rdi
leaq 0xd878(%rip), %rsi      # 0x14042
callq 0x21b0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x6804
movq 0x147fd(%rip), %rax     # 0x1afe0
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0xd85f(%rip), %rsi      # 0x14051
movb $0x0, %al
callq 0x2240
movq $-0x1, 0x20(%rsp)
jmp 0x6854
jmp 0x6806
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x21a0
movq 0x10(%rsp), %rdi
callq 0x2030
movq %rax, 0x8(%rsp)
movq 0x147b1(%rip), %rax     # 0x1afe0
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0xe231(%rip), %rsi      # 0x14a74
movb $0x0, %al
callq 0x2240
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rdx
xorl %esi, %esi
callq 0x2110
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2090
movl %eax, 0xc(%rsp)
xorl %eax, %eax
cmpl $0x20, 0xc(%rsp)
movb %al, 0xb(%rsp)
je 0x6b44
xorl %eax, %eax
cmpl $-0x1, 0xc(%rsp)
movb %al, 0xb(%rsp)
je 0x6b44
xorl %eax, %eax
cmpl $0xa, 0xc(%rsp)
movb %al, 0xb(%rsp)
je 0x6b44
cmpl $0x9, 0xc(%rsp)
setne %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x6b4e
jmp 0x6b7c
movl 0xc(%rsp), %eax
movb %al, %dl
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2090
movl %eax, 0xc(%rsp)
jmp 0x6b11
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x20d0
movl %eax, 0x4(%rsp)
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0x7111
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x7104
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
je 0x7104
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x7104
movb $0x0, 0x17(%rsp)
jmp 0x7116
jmp 0x7106
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x70be
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: akdess[P]BAFExtract/src/utils.cpp
// Function: get_n_lines(_IO_FILE*)
int get_n_lines(FILE* file)
{
	int n_lines = 0;

	char ret = 0;
	int n_chars_in_cur_line = 0;
	while(1)
	{
		ret = getc(file);

		if(ret == EOF)
		{
			break;
		}
		else if(ret == '\n')
		{
			if(n_chars_in_cur_line)
				n_lines++;

			n_chars_in_cur_line = 0;
		}
		else
		{
			n_chars_in_cur_line = 1;
		}
	} // file reading loop.

	return(n_lines);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movb $0x0, 0xb(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2090
movb %al, 0xb(%rsp)
movsbl 0xb(%rsp), %eax
cmpl $-0x1, %eax
jne 0x7358
jmp 0x738a
movsbl 0xb(%rsp), %eax
cmpl $0xa, %eax
jne 0x737e
cmpl $0x0, 0x4(%rsp)
je 0x7374
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl $0x0, 0x4(%rsp)
jmp 0x7386
movl $0x1, 0x4(%rsp)
jmp 0x7388
jmp 0x733e
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: akdess[P]BAFExtract/src/utils.cpp
// Function: x_fgets(char*, int, _IO_FILE*)
char* x_fgets(char* buff, int size, FILE* file)
{
	if(fgets(buff, size, file) == NULL)
	{
		return(NULL);
	}

	if(buff[strlen(buff) - 1] == '\n')
	{
		int i_new_line_char = (int)strlen(buff) - 1;
		buff[i_new_line_char] = 0;
	}

	return(buff);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0x2290
cmpq $0x0, %rax
jne 0x7536
movq $0x0, 0x30(%rsp)
jmp 0x7588
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x20d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x757e
movq 0x28(%rsp), %rdi
callq 0x20d0
subl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x87e0
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x87e0
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jle 0x870e
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x8716
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x87cd
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x8751
movb $0x1, 0x37(%rsp)
jmp 0x87d2
movq 0x20(%rsp), %rax
movslq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x876b
movb $0x0, 0x37(%rsp)
jmp 0x87d2
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0x20(%rsp), %rcx
movslq 0x10(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x8792
movb $0x1, 0x37(%rsp)
jmp 0x87d2
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0x20(%rsp), %rcx
movslq 0x10(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jle 0x87b9
movb $0x0, 0x37(%rsp)
jmp 0x87d2
jmp 0x87bb
jmp 0x87bd
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x8726
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x87e0
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x87e0
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x892e
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x8936
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x8989
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0x20(%rsp), %rcx
movslq 0x10(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x897a
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x8991
jmp 0x897c
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x8946
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x87e0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x87e0
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x88f0
movl %eax, 0x4(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x4(%rsp), %eax
je 0x89f1
movl 0x8(%rsp), %eax
cmpl 0x4(%rsp), %eax
jne 0x89f8
movb $0x1, 0x27(%rsp)
jmp 0x89fd
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x8e6e
cmpq $0x0, 0x10(%rsp)
jne 0x8e75
movb $0x0, 0x27(%rsp)
jmp 0x8eef
movq 0x18(%rsp), %rdi
callq 0x87e0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x87e0
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
je 0x8ea2
movb $0x0, 0x27(%rsp)
jmp 0x8eef
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x8eea
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0x10(%rsp), %rcx
movslq 0x4(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x8edb
movb $0x0, 0x27(%rsp)
jmp 0x8eef
jmp 0x8edd
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x8eaa
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x87e0
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x91c5
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x91b5
movq 0x20(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0x18(%rsp), %rcx
movslq 0x4(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x9199
cmpl $0x0, 0xc(%rsp)
jle 0x9195
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
jmp 0x9197
jmp 0x9197
jmp 0x91a6
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x91b5
jmp 0x91a8
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x914f
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x9134
cmpl $0x0, 0xc(%rsp)
jle 0x91d7
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
// File: akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::~t_string()
t_string::~t_string()
{
	//printf("Freeing a string object.\n");
	//free(this->obj_string);
	delete [] this->string_buffer->string_buff;
	delete this->string_buffer;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x961e
movq 0x18(%rsp), %rdi
callq 0x2200
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x9640
movq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x2190
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl $0x18, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x4fe0
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x87e0
movl %eax, 0x44(%rsp)
movl $0x8, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x8630
jmp 0x96b2
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x9783
movq 0x50(%rsp), %rax
movslq 0x28(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x9734
movq 0x50(%rsp), %rax
movslq 0x28(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0x9734
movq 0x38(%rsp), %rdi
movq 0x50(%rsp), %rax
movslq 0x28(%rsp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x9800
jmp 0x9771
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x8, %esi
callq 0x2190
jmp 0x97f1
movq 0x38(%rsp), %rdi
callq 0x9920
cmpl $0x0, %eax
jle 0x976f
movq 0x38(%rsp), %rdi
movl $0xa, %esi
callq 0x9930
movl %eax, 0x24(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0x4ea0
movq 0x38(%rsp), %rdi
callq 0x86b0
jmp 0x9771
jmp 0x9773
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x96c4
movq 0x38(%rsp), %rdi
callq 0x9920
cmpl $0x0, %eax
jle 0x97be
movq 0x38(%rsp), %rdi
movl $0xa, %esi
callq 0x9930
movl %eax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x4ea0
movq 0x38(%rsp), %rdi
callq 0x86b0
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x97e7
movq 0x8(%rsp), %rdi
callq 0x95f0
movq 0x8(%rsp), %rdi
movl $0x8, %esi
callq 0x2190
movq 0x48(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x22d0
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x18, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x4fe0
movq 0x20(%rsp), %rax
movq %rax, 0x58(%rsp)
movl $0x8, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x28(%rsp)
callq 0x8630
jmp 0x99be
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
callq 0x9920
movl %eax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x40(%rsp), %eax
jge 0x9ab0
movq 0x18(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x9b30
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x9a61
movq 0x18(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x9b30
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x9a61
movq 0x18(%rsp), %rdi
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x3c(%rsp), %esi
callq 0x9b30
movq 0x10(%rsp), %rdi
movsbl (%rax), %esi
callq 0x9800
jmp 0x9a9e
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl $0x8, %esi
callq 0x2190
jmp 0x9b1e
movq 0x50(%rsp), %rdi
callq 0x9920
cmpl $0x0, %eax
jle 0x9a9c
movq 0x50(%rsp), %rdi
movl $0xa, %esi
callq 0x9930
movl %eax, 0x38(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x4ea0
movq 0x50(%rsp), %rdi
callq 0x86b0
jmp 0x9a9e
jmp 0x9aa0
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x99de
movq 0x50(%rsp), %rdi
callq 0x9920
cmpl $0x0, %eax
jle 0x9aeb
movq 0x50(%rsp), %rdi
movl $0xa, %esi
callq 0x9930
movl %eax, 0x34(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x34(%rsp), %rsi
callq 0x4ea0
movq 0x50(%rsp), %rdi
callq 0x86b0
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x9b14
movq 0x8(%rsp), %rdi
callq 0x95f0
movq 0x8(%rsp), %rdi
movl $0x8, %esi
callq 0x2190
movq 0x58(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x22d0
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x87e0
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
xorl %edx, %edx
callq 0x8520
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x9c53
movq 0x20(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jl 0x9bd0
movq 0x20(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7a, %eax
jle 0x9c1c
movq 0x20(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0x9bf6
movq 0x20(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5a, %eax
jle 0x9c1c
movq 0x20(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x9c41
movq 0x20(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0x9c41
movq 0x20(%rsp), %rax
movslq 0x8(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x9c43
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x9b9c
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::char_2_str(char)
char* t_string::char_2_str(const char char_val)
{
	char* char_str = new char[2];
	char_str[0] = char_val;
	char_str[1] = 0;

	return char_str;
}

// Assembly:
subq $0x18, %rsp
movb %dil, %al
movb %al, 0x17(%rsp)
movl $0x2, %edi
callq 0x2040
movq %rax, 0x8(%rsp)
movb 0x17(%rsp), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x1(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x87e0
movl %eax, 0x14(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jg 0x9cfc
movl 0x24(%rsp), %eax
cmpl 0x14(%rsp), %eax
jle 0x9d0a
movq $0x0, 0x30(%rsp)
jmp 0x9da8
movl 0x20(%rsp), %eax
cmpl 0x14(%rsp), %eax
jl 0x9d1f
movl 0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x9d21
movl 0x20(%rsp), %eax
subl 0x24(%rsp), %eax
addl $0x1, %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
movl 0x24(%rsp), %eax
movl %eax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x20(%rsp), %eax
jg 0x9d90
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x9d54
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)