LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
callq 0x9707
cmpl $0x0, 0x10(%r14)
je 0x966a
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %r15
leaq 0x10(%rsp), %rbp
movq %rsp, %r12
movq %rbp, %rdi
movq %r14, %rsi
callq 0x7236
movl 0x44(%rsp), %r13d
movq %r15, %rdi
callq 0x4120
cmpl $0x9, %r13d
jne 0x9658
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x6d30
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x9707
movq %r12, %rdi
movq %rbp, %rsi
callq 0xaa45
movq %rbp, %rdi
callq 0x6b64
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb294
leaq 0x8(%rsp), %rdi
callq 0x69e2
jmp 0x9677
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x6b64
jmp 0x96f3
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x69e2
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x69e2
movq %r14, %rdi
callq 0x43c0
// File: /workspace/github_cpp_makefile_star2_O2/AgathokakologicalBit[P]wit/src/parsing/parsing.hpp
// Function: akbit::system::parsing::ParserState::restore()
inline void restore()
    {
      index = saves[saves.size() - 1];
      error.code = error_t::e_no_errors;
      error.message = "";
      saves.pop_back();
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq -0x8(%rax), %rax
movq %rax, 0x8(%rdi)
andl $0x0, 0x10(%rdi)
addq $0x18, %rdi
leaq 0x6b0a(%rip), %rsi      # 0x11335
callq 0x4410
addq $-0x8, 0x40(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %rcx, -0x8(%r14)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x6d30
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x6d30
pushq $0x2
popq %rdx
leaq 0x7(%rsp), %rcx
movq %r14, %rdi
movq %r12, %rsi
callq 0x9d14
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xb156
movq %r14, %rdi
callq 0x69c0
pushq $0x18
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x8, %rdi
callq 0x69e2
addq $-0x10, %r14
cmpq $-0x8, %r14
jne 0xa8c4
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x69c0
jmp 0xa8fa
movq %rax, %rbx
pushq $0x18
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x8, %rdi
callq 0x69e2
addq $-0x10, %r14
cmpq $-0x8, %r14
jne 0xa8fe
movq %rbx, %rdi
callq 0x43c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x18(%rsi), %rdi
movq 0x20(%rsi), %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xe9d3
addq $0x8, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6cf6
movq (%r12), %r12
leaq 0x8(%rsp), %rdi
callq 0x69e2
testq %r12, %r12
je 0xe92e
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6cf6
movq (%r12), %rsi
movq %rsp, %rdi
movq %r14, %rdx
callq 0xe86e
leaq 0x20(%rsp), %rdi
callq 0x69e2
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 0xea20
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0xeab4
movq %rsp, %rdi
callq 0xe9b2
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xe93f
movq %rax, %r14
movq %rsp, %rdi
callq 0xe9b2
jmp 0xe95e
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x69e2
jmp 0xe95e
movq %rax, %r14
movq %rbx, %rdi
callq 0xe9b2
movq %r14, %rdi
callq 0x43c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x48, %rsp
leaq 0x1d3f(%rip), %rsi      # 0x417d
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2d5c
callq 0x23c5
movq %rax, %rbx
movq 0x3b66(%rip), %rdi      # 0x5fc0
leaq 0x1c49(%rip), %rsi      # 0x40aa
callq 0x2110
movq 0x3b73(%rip), %rdi      # 0x5fe0
leaq -0x30(%rbp), %rsi
callq 0x20d0
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2100
leaq -0x50(%rbp), %rdi
movq %rbx, %rsi
callq 0x24d4
leaq -0x50(%rbp), %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x21b0
leaq -0x30(%rbp), %rdi
callq 0x21a0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x21a0
jmp 0x24c3
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/allasandeep[P]LocationBoundaryFinder/prog2.cc
// Function: formatOutputString[abi:cxx11](int)
string formatOutputString(int boundary)
{
	double dd;
	int d = 0, m = 0;
	float value = 0, seconds = 0;
	string sTemp = "",s = "", outString = "";	
	dd = (double)boundary/ (double)1000000;
	//Formula to convert to DMS
	d = dd;
	m = (dd-d) * 60;
	value = (dd-(double)d - ((double)m/(double)60))*3600;
	seconds = roundf(value * 100)/100;
	sTemp = to_string(seconds);
	s = sTemp.substr(0,sTemp.length()-4);
	//Appendning the DMS values to the string as to be displayed
	outString += to_string(d);
	outString += " degrees, "; 
	outString += to_string(m); 
	outString += " minutes, "; 
	outString += s;
	outString += " seconds ";

	return outString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x15ff(%rip), %r15      # 0x417d
leaq -0xa0(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movq %r15, %rsi
callq 0x2d5c
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
movq %r15, %rsi
callq 0x2d5c
leaq 0x15d5(%rip), %rsi      # 0x417d
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x2d5c
cvtsi2sd %r14d, %xmm1
divsd 0x1447(%rip), %xmm1     # 0x4008
cvttpd2dq %xmm1, %xmm0
cvtdq2pd %xmm0, %xmm0
movapd %xmm1, -0x80(%rbp)
subsd %xmm0, %xmm1
movsd 0x1436(%rip), %xmm0     # 0x4010
movapd %xmm1, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm2, -0x70(%rbp)
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
divsd %xmm0, %xmm2
subsd %xmm2, %xmm1
mulsd 0x1419(%rip), %xmm1     # 0x4018
cvtsd2ss %xmm1, %xmm0
mulss 0x1415(%rip), %xmm0     # 0x4020
callq 0x20a0
divss 0x1408(%rip), %xmm0     # 0x4020
leaq -0x38(%rbp), %rdi
callq 0x2db8
leaq -0xa0(%rbp), %r14
leaq -0x38(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x20f0
movq %r15, %rdi
callq 0x21a0
movq 0x8(%r14), %rcx
addq $-0x4, %rcx
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x21f0
cvttsd2si -0x80(%rbp), %r14d
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x20f0
movq %r15, %rdi
callq 0x21a0
leaq -0x38(%rbp), %rdi
movl %r14d, %esi
callq 0x2de7
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x21d0
leaq -0x38(%rbp), %rdi
callq 0x21a0
leaq 0x152a(%rip), %rsi      # 0x41c1
movq %rbx, %rdi
callq 0x2160
cvttsd2si -0x70(%rbp), %esi
leaq -0x38(%rbp), %rdi
callq 0x2de7
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x21d0
leaq -0x38(%rbp), %rdi
callq 0x21a0
leaq 0x1503(%rip), %rsi      # 0x41cc
movq %rbx, %rdi
callq 0x2160
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x21d0
leaq 0x14f3(%rip), %rsi      # 0x41d7
movq %rbx, %rdi
callq 0x2160
leaq -0x58(%rbp), %rdi
callq 0x21a0
leaq -0xa0(%rbp), %rdi
callq 0x21a0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d16
jmp 0x2d34
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x21a0
jmp 0x2d37
jmp 0x2d34
jmp 0x2d34
jmp 0x2d34
movq %rax, %r14
jmp 0x2d3f
movq %rax, %r14
jmp 0x2d48
movq %rax, %r14
movq %rbx, %rdi
callq 0x21a0
leaq -0x58(%rbp), %rdi
callq 0x21a0
leaq -0xa0(%rbp), %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebp
pushq $0x28
popq %rdi
callq 0x2040
movq %rax, %rbx
movslq %ebp, %rax
leaq 0x4(,%rax,2), %r14
cmpl $-0x2, %eax
pushq $-0x1
popq %r15
cmovgeq %r14, %r15
xorl %r12d, %r12d
cmpq $0x5, %r12
je 0x244e
movq %r15, %rdi
callq 0x2040
movq %rax, (%rbx,%r12,8)
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2100
incq %r12
jmp 0x242a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x100, %rcx            # imm = 0x100
je 0x247c
movl $0x4, (%rax,%rcx,4)
incq %rcx
jmp 0x2467
andl $0x0, 0x104(%rax)
pushq $0x1
popq %rcx
movl %ecx, 0x10c(%rax)
pushq $0x2
popq %rdx
movl %edx, 0x11c(%rax)
movabsq $0x300000003, %rsi      # imm = 0x300000003
movq %rsi, 0x150(%rax)
andl $0x0, 0x184(%rax)
movl %ecx, 0x18c(%rax)
movl %edx, 0x19c(%rax)
movq %rsi, 0x1d0(%rax)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6b4a(%rip), %rsi      # 0x9020
callq 0x7370
testb %al, %al
jne 0x2505
leaq 0x6b3e(%rip), %rsi      # 0x9024
movq %rbx, %rdi
callq 0x7370
testb %al, %al
jne 0x2505
leaq 0x6b2f(%rip), %rsi      # 0x9028
movq %rbx, %rdi
callq 0x7370
testb %al, %al
je 0x251f
leaq 0x3(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x2140
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2140
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6ade(%rip), %rsi      # 0x9026
callq 0x471a
movq %rax, %r15
leaq 0x10(%rsp), %r13
leaq 0x4(%rsp), %rbp
movq %r15, %rdi
callq 0x459e
testq %rax, %rax
je 0x25ba
movq %rax, %r12
andl $0x0, 0x4(%rsp)
movq %rax, %rdi
leaq 0x6ab3(%rip), %rsi      # 0x902c
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x2150
cmpl $0x2, %eax
jne 0x25d4
movq %r13, %rdi
callq 0x24c2
movq %r13, %rdi
callq 0x5442
movq %rax, 0x8(%rsp)
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
callq 0x3c04
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3ba2
jmp 0x255a
movq %r15, %rdi
callq 0x2160
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xca05(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x6a4d(%rip), %rsi      # 0x9032
movq %r12, %rdx
xorl %eax, %eax
callq 0x2240
xorl %edi, %edi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
leaq 0x5c8d(%rip), %rsi      # 0x905e
callq 0x471a
movq %rax, %rbx
leaq 0x4(%rsp), %r15
andl $0x0, (%r15)
pushq $0x4
popq %rsi
pushq $0x1
popq %r12
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
callq 0x2250
movslq (%r15), %r15
movl %r15d, (%r14)
leaq 0x2(%r15), %rdi
callq 0x2040
movq %rax, %r14
incq %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2250
movq %rbx, %rdi
callq 0x2160
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq $0x5, %r14
je 0x3457
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x3452
callq 0x2200
incq %r14
jmp 0x343e
testq %rbx, %rbx
je 0x346b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2200
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x3e8, %rsp            # imm = 0x3E8
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x3feb
cmpb $0x2f, (%rbx)
jne 0x3fc9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2140
jmp 0x3fe0
leaq 0x59d2(%rip), %rsi      # 0x99a2
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2060
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x50df(%rip), %rsi      # 0x9305
callq 0x2220
testl %eax, %eax
jne 0x424d
movq 0xadaa(%rip), %rax      # 0xefe0
movq (%rax), %rcx
leaq 0x57f0(%rip), %rdi      # 0x9a30
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x22f0
jmp 0x427c
leaq 0x4e0a(%rip), %rsi      # 0x905e
movq %rbx, %rdi
callq 0x21a0
testq %rax, %rax
jne 0x4282
movq 0xad78(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x4dfb(%rip), %rsi      # 0x906d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2240
pushq $-0x1
popq %r14
jmp 0x42bb
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x2190
movq %r14, %rdi
callq 0x2030
movq %rax, %r14
movq 0xad3c(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x5798(%rip), %rsi      # 0x9a46
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2240
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5030(%rip), %rsi      # 0x9305
callq 0x2220
testl %eax, %eax
je 0x43a3
leaq 0x4d75(%rip), %rsi      # 0x905e
movq %r15, %rdi
callq 0x21a0
testq %rax, %rax
je 0x43c1
movq %rax, %rbx
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x2190
movq %rbx, %rdi
callq 0x2030
movq %rax, %r14
cmpb $0x1, 0xae7e(%rip)      # 0xf19a
je 0x43e0
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2190
leaq 0x1(%r14), %rdi
callq 0x2040
movq %rax, %r15
cmpb $0x1, 0xae59(%rip)      # 0xf19a
je 0x4403
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2250
cmpq %rax, %r14
jne 0x4390
cmpb $0x1, 0xae36(%rip)      # 0xf19a
je 0x4424
movq %rbx, %rdi
callq 0x2160
movb $0x0, (%r15,%r14)
pushq $0x18
popq %rdi
callq 0x2170
movq %rax, %rbx
movq %r15, (%rax)
andq $0x0, 0x8(%rax)
movq %r14, 0x10(%rax)
jmp 0x439a
movq %r15, %rdi
callq 0x2200
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xac36(%rip), %rax      # 0xefe0
movq (%rax), %rcx
leaq 0x567c(%rip), %rdi      # 0x9a30
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x22f0
jmp 0x4398
movq 0xac18(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x4c9b(%rip), %rsi      # 0x906d
xorl %ebx, %ebx
movq %r15, %rdx
xorl %eax, %eax
callq 0x2240
jmp 0x439a
movq 0xabf9(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x5655(%rip), %rsi      # 0x9a46
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2240
jmp 0x4322
movq 0xabd6(%rip), %rax      # 0xefe0
movq (%rax), %rcx
leaq 0x564c(%rip), %rdi      # 0x9a60
pushq $0x19
popq %rsi
pushq $0x1
popq %rdx
callq 0x22f0
jmp 0x4347
movq 0xabb5(%rip), %rax      # 0xefe0
movq (%rax), %rcx
leaq 0x5645(%rip), %rdi      # 0x9a7a
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
callq 0x22f0
jmp 0x436a
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2100
movabsq $0x200000c01, %r15      # imm = 0x200000C01
movq %r14, %rdi
callq 0x2080
movl %eax, %ecx
incl %ecx
cmpl $0x21, %ecx
ja 0x449b
btq %rcx, %r15
jb 0x44a2
movb %al, (%rbx)
incq %rbx
jmp 0x4484
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20c0
xorl %ecx, %ecx
testl %eax, %eax
movl %eax, %edx
cmovlel %ecx, %edx
movabsq $0x100000600, %rsi      # imm = 0x100000600
cmpq %rcx, %rdx
je 0x480c
movzbl (%rbx,%rcx), %edi
cmpq $0x20, %rdi
ja 0x480c
btq %rdi, %rsi
jae 0x480c
incq %rcx
jmp 0x47f2
cltq
cmpq %rax, %rcx
setge %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
pushq $0x1
popq %rbp
xorl %eax, %eax
movl %eax, %r15d
movq %r14, %rdi
callq 0x2080
cmpb $-0x1, %al
je 0x496f
movzbl %al, %ecx
movl %ebp, %eax
cmpl $0xa, %ecx
jne 0x4951
addl %r15d, %ebx
jmp 0x494f
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4eb4
movl %eax, %ebp
movq %rbx, %rdi
callq 0x4eb4
cmpl %eax, %ebp
cmovgl %ebp, %eax
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %esi
cmovgl %eax, %esi
movq %rdx, %rcx
cmpq %rcx, %rsi
je 0x4ea4
movb (%r14,%rcx), %dil
movb $0x1, %dl
testb %dil, %dil
je 0x4ea4
movb (%rbx,%rcx), %r8b
testb %r8b, %r8b
je 0x4ea2
cmpb %r8b, %dil
jl 0x4ea4
leaq 0x1(%rcx), %rdx
cmpb %r8b, %dil
jle 0x4e78
xorl %edx, %edx
cltq
cmpq %rax, %rcx
setl %al
andb %dl, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4eb4
movl %eax, %ebp
movq %rbx, %rdi
callq 0x4eb4
cmpl %eax, %ebp
cmovll %ebp, %eax
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
cmpq %rdx, %rcx
je 0x4f6a
movb (%r14,%rdx), %sil
cmpb (%rbx,%rdx), %sil
jne 0x4f68
incq %rdx
jmp 0x4f54
movl %edx, %ecx
cmpl %eax, %ecx
cmovll %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4eb4
movl %eax, %ebp
movq %rbx, %rdi
callq 0x4eb4
movl %eax, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4f2a
cmpl %eax, %ebp
sete %cl
cmpl %eax, %r15d
sete %al
orb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::fast_search_string_per_prefix(char*, std::vector<char*, std::allocator<char*>>*, int, int)
int t_string::fast_search_string_per_prefix(char* query, vector<char*>* string_list, int i, int j)
{
	// Sort the string list.
	int i_mid = (i + j) / 2;

	if(i_mid == i ||
		i_mid == j)
	{
		return(i);
	}
	
	if(t_string::compare_strings(string_list->at(i_mid), query))
	{
		while(i_mid < (int)string_list->size() &&
			t_string::sort_strings_per_prefix(string_list->at(i_mid), query))
		{
			i_mid++;
		}

		// If the above loop hit the end, move back once.
		if(i_mid == (int)string_list->size())
		{
			i_mid--;
		}

		// If the above loop moved beyond the query move back once, which is the exact element just before query.
		if(i_mid > 0 &&
			!t_string::sort_strings_per_prefix(string_list->at(i_mid), query))
		{
			i_mid--;
		}

		return(i_mid);
	}
	else if(t_string::sort_strings_per_prefix(query, string_list->at(i_mid)))
	{
		return(t_string::fast_search_string_per_prefix(query, string_list, i, i_mid));
	}
	else if(!t_string::sort_strings_per_prefix(query, string_list->at(i_mid)))
	{
		return(t_string::fast_search_string_per_prefix(query, string_list, i_mid, j));
	}
	else
	{
		fprintf(stderr, "Fast searching failed @ %s(%d)\n", __FILE__, __LINE__);
		exit(0);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r13d
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movl %r13d, %r15d
movl %r15d, %r13d
leal (%r12,%r13), %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
cmpl %r12d, %eax
je 0x5219
movl %eax, %ebp
cmpl %r13d, %eax
je 0x5219
movslq %ebp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3be2
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x522c
testb %al, %al
jne 0x519a
movq %r14, %rdi
movq %r15, %rsi
callq 0x3be2
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4e4e
testb %al, %al
jne 0x50fa
movq %r14, %rdi
movq %r15, %rsi
callq 0x3be2
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4e4e
movl %r15d, %r12d
testb %al, %al
je 0x50f7
movq 0x9e6a(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x4a5c(%rip), %rsi      # 0x9bdc
leaq 0x4a75(%rip), %rdx      # 0x9bfc
movl $0x106, %ecx            # imm = 0x106
xorl %eax, %eax
callq 0x2240
xorl %edi, %edi
callq 0x21c0
negl %ebp
movq 0x8(%r14), %rax
subq (%r14), %rax
movq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r15
jge 0x51da
movq %r14, %rdi
movq %r15, %rsi
callq 0x3be2
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x4e4e
testb %al, %al
je 0x51d3
incq %r15
decl %ebp
jmp 0x519c
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
xorl %r15d, %r15d
addl %ebp, %eax
sete %r15b
negl %r15d
movl %r15d, %r12d
subl %ebp, %r12d
testl %r12d, %r12d
jle 0x5219
movl %r12d, %esi
movq %r14, %rdi
callq 0x3be2
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x4e4e
xorb $0x1, %al
movzbl %al, %eax
subl %eax, %r15d
subl %ebp, %r15d
movl %r15d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x523f
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4eb4
movl %eax, %r15d
movq %rbx, %rdi
callq 0x4eb4
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %r15d
jne 0x528c
movslq %r15d, %rcx
testl %r15d, %r15d
cmovlel %eax, %r15d
cmpq %rax, %r15
je 0x5286
movb (%r14,%rax), %dl
leaq 0x1(%rax), %rsi
cmpb (%rbx,%rax), %dl
movq %rsi, %rax
je 0x526d
xorl %eax, %eax
jmp 0x528c
cmpq %rcx, %rax
setge %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x4eb4
movl %eax, %ecx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %ecx
xorl %edi, %edi
xorl %eax, %eax
xorl %esi, %esi
movb (%r14,%rdi), %r8b
testb %r8b, %r8b
je 0x5431
xorl %r9d, %r9d
cmpq %r9, %rcx
je 0x542c
cmpb (%rbx,%r9), %r8b
jne 0x542a
xorl %r10d, %r10d
testl %esi, %esi
setg %r10b
cmovnsl %edx, %esi
addl %r10d, %eax
incq %r9
jmp 0x540b
incl %esi
incq %rdi
jmp 0x53ff
xorl %ecx, %ecx
testl %esi, %esi
setg %cl
addl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x2170
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %r15, %rdi
callq 0x4eb4
movl %eax, %r12d
pushq $0x8
popq %rdi
callq 0x2170
movq %rax, %r14
movq %rax, %rdi
callq 0x4e00
xorl %ebp, %ebp
testl %r12d, %r12d
cmovlel %ebp, %r12d
movq %rsp, %r13
cmpq %rbp, %r12
je 0x5756
movb (%r15,%rbp), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x5722
movsbl %al, %esi
movq %r14, %rdi
callq 0x57c2
jmp 0x5751
movq (%r14), %rax
cmpl $0x0, 0xc(%rax)
jle 0x5751
movq %r14, %rdi
pushq $0xa
popq %rsi
callq 0x5866
movl %eax, (%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3ba2
movq (%r14), %rax
andl $0x0, 0xc(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
incq %rbp
jmp 0x5704
movq (%r14), %rax
cmpl $0x0, 0xc(%rax)
jle 0x5786
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x5866
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x3ba2
movq (%r14), %rax
andl $0x0, 0xc(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x5692
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x2180
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x2170
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
pushq $0x8
popq %rdi
callq 0x2170
movq %rax, %r14
movq %rax, %rdi
callq 0x4e00
movq (%r15), %rax
movl 0xc(%rax), %r13d
xorl %ebp, %ebp
testl %r13d, %r13d
cmovlel %ebp, %r13d
movq %rsp, %r12
cmpq %rbp, %r13
je 0x5913
movq (%r15), %rax
movq (%rax), %rax
movb (%rax,%rbp), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x58df
movsbl %al, %esi
movq %r14, %rdi
callq 0x57c2
jmp 0x590e
movq (%r14), %rax
cmpl $0x0, 0xc(%rax)
jle 0x590e
movq %r14, %rdi
pushq $0xa
popq %rsi
callq 0x5866
movl %eax, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3ba2
movq (%r14), %rax
andl $0x0, 0xc(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
incq %rbp
jmp 0x58bc
movq (%r14), %rax
cmpl $0x0, 0xc(%rax)
jle 0x5943
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x5866
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x3ba2
movq (%r14), %rax
andl $0x0, 0xc(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x5692
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x2180
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x4eb4
movl %eax, %r15d
leal 0x2(%r15), %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, %r14
movslq %r15d, %r15
xorl %r12d, %r12d
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x4d98
testl %r15d, %r15d
cmovlel %r12d, %r15d
xorl %eax, %eax
cmpq %r12, %r15
je 0x59f1
movb (%rbx,%r12), %cl
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x59e4
movl %ecx, %edx
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x19, %dl
ja 0x59ec
cltq
movb %cl, (%r14,%rax)
incl %eax
incq %r12
jmp 0x59c6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movl %edi, %ebx
pushq $0x2
popq %rdi
callq 0x2040
movb %bl, (%rax)
movb $0x0, 0x1(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x4eb4
cmpl %r14d, %ebp
setg %cl
cmpl %ebp, %eax
setl %dl
orb %cl, %dl
je 0x5a43
xorl %eax, %eax
jmp 0x5a88
leal -0x1(%rax), %r15d
cmpl %r14d, %eax
cmovgl %r14d, %r15d
movl %r15d, %eax
subl %ebp, %eax
addl $0x3, %eax
movslq %eax, %rdi
callq 0x2040
movb $0x0, (%rax)
movslq %ebp, %rcx
movslq %r15d, %rdx
addq %rcx, %rbx
xorl %esi, %esi
leaq (%rcx,%rsi), %rdi
cmpq %rdx, %rdi
jg 0x5a82
movb (%rbx,%rsi), %dil
movb %dil, (%rax,%rsi)
incq %rsi
jmp 0x5a6c
movl %esi, %ecx
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %edx, %eax
subl %esi, %eax
jge 0x5a9d
xorl %eax, %eax
retq
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq (%rdi), %r14
cmpl %edx, 0xc(%r14)
jge 0x5ab0
xorl %eax, %eax
jmp 0x5aea
movl %esi, %ebp
addl $0x3, %eax
movslq %eax, %rdi
callq 0x2210
movb $0x0, (%rax)
movslq %ebp, %rdx
movslq %ebx, %rsi
xorl %ecx, %ecx
leaq (%rdx,%rcx), %rdi
cmpq %rsi, %rdi
jg 0x5ae4
movq (%r14), %rdi
addq %rdx, %rdi
movb (%rcx,%rdi), %dil
movb %dil, (%rax,%rcx)
incq %rcx
jmp 0x5ac8
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::split_string_list(std::vector<char*, std::allocator<char*>>*, int)
vector<vector<char*>*>* t_string::split_string_list(vector<char*>* string_list, int n_batches)
{
	vector<vector<char*>*>* batches = new vector<vector<char*>*>();

	int n_string_per_batch = (int)string_list->size() / n_batches;
	vector<char*>* current_batch = new vector<char*>();
	batches->push_back(current_batch);
	for(int i_str = 0; i_str < (int)string_list->size(); i_str++)
	{
		if((int)current_batch->size() == n_string_per_batch)
		{
			current_batch = new vector<char*>();
			batches->push_back(current_batch);
		}

		current_batch->push_back(string_list->at(i_str));
	} // i_str loop.

	return(batches);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x18
popq %r14
movq %r14, %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltd
idivl %ebp
movl %eax, %ebp
movq %r14, %rdi
callq 0x2170
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rsp, %r12
movq %rax, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x756c
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltq
cmpq %rax, %r13
jge 0x600c
movq (%rsp), %r14
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
cmpl %eax, %ebp
jne 0x5ff1
pushq $0x18
popq %rdi
callq 0x2170
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x756c
movq (%rsp), %r14
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3be2
movq %r14, %rdi
movq %rax, %rsi
callq 0x4a7e
incq %r13
jmp 0x5fa6
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::copy_tokens_2_strs(std::vector<t_string*, std::allocator<t_string*>>*)
vector<char*>* t_string::copy_tokens_2_strs(t_string_tokens* toks)
{
	vector<char*>* strs = new vector<char*>();
	for (int i_t = 0; i_t < toks->size(); i_t++)
	{
		strs->push_back(toks->at(i_t)->str());
	} // i_t loop.

	return(strs);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x2170
movq %rax, %r14
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r15d, %r15d
movq %rsp, %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x66c1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4a5c
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x3c04
incq %r15
jmp 0x6689
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::remove_beginning_spaces_tabs(char*)
char* t_string::remove_beginning_spaces_tabs(char* string)
{
	int i_last_space = 0;

	int l_str = t_string::string_length(string);

	for(int i = 0; i < l_str; i++)
	{
		if(string[i] != ' ' &&
			string[i] != '\t')
		{
			i_last_space = i;
			break;
		}
	}

	char* reloc_copy = new char[l_str + 2];

	// Relocate.
	copy(reloc_copy, &string[i_last_space]);
	
	return(reloc_copy);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4eb4
xorl %r15d, %r15d
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
cmpq %r15, %rcx
je 0x69ed
movzbl (%rbx,%r15), %edx
cmpl $0x20, %edx
je 0x69e8
cmpl $0x9, %edx
jne 0x69f0
incq %r15
jmp 0x69d4
xorl %r15d, %r15d
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, %r14
addq %r15, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x547c
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::ends_with(char const*)
bool t_string::ends_with(const char* string)
{
	if(this->length() < string_length(string))
	{
		return(false);
	}

	// Go over all the characters of the sub-string and check if they match to the end of the string.
	int i_str = this->length() - 1;
	unsigned int i_sub = string_length(string) - 1;
	while(1)
	{
		if(string[i_sub] != this->x(i_str))
		{
			return(false);
		}

		if(i_sub == 0)
		{
			return(true);
		}
		else
		{
			i_sub--;
		}

		i_str--;		
	} // i loop.

	return(true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r14
movslq 0xc(%r14), %r15
movq %rsi, %rdi
callq 0x4eb4
cmpl %eax, %r15d
jge 0x721a
xorl %ecx, %ecx
jmp 0x7242
movq (%r14), %rcx
leaq (%r15,%rcx), %rdx
decq %rdx
decl %eax
movl %eax, %ecx
movb (%rbx,%rcx), %sil
movb (%rdx), %dil
cmpb %dil, %sil
sete %cl
addl $-0x1, %eax
jae 0x7242
decq %rdx
cmpb %dil, %sil
je 0x7226
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::ends_with(char const*, char const*)
bool t_string::ends_with(const char* full_string, const char* sub_str)
{
	if(string_length(full_string) < string_length(sub_str))
	{
		return(false);
	}

	// Go over all the characters of the sub-string and check if they match to the end of the string.
	int i_str = string_length(full_string) - 1;
	unsigned int i_sub = string_length(sub_str) - 1;
	while(1)
	{
		if(sub_str[i_sub] != full_string[i_str])
		{
			return(false);
		}

		if(i_sub == 0)
		{
			return(true);
		}
		else
		{
			i_sub--;
		}

		i_str--;		
	} // i loop.

	return(true);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4eb4
movl %eax, %ebp
movq %rbx, %rdi
callq 0x4eb4
cmpl %eax, %ebp
jge 0x7341
xorl %ecx, %ecx
jmp 0x7369
movslq %ebp, %rcx
leaq (%rcx,%r14), %rdx
decq %rdx
decl %eax
movl %eax, %ecx
movb (%rbx,%rcx), %sil
movb (%rdx), %dil
cmpb %dil, %sil
sete %cl
addl $-0x1, %eax
jae 0x7369
decq %rdx
cmpb %dil, %sil
je 0x734d
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq