LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/chart.cc
// Function: Chart::canEnter(int, int)
bool Chart::canEnter(int x, int y){
  vector<vector <container> >::iterator row = world.end()-y;
  vector<container> ::iterator col = row->begin()+x-1;
  //cout<<col->getPosX()<<','<<col->getPosY()<<endl;
  if(col->getOccupance() == false){
    //cout<<"allowed to enter"<<endl;
    return false;
  }
  else return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movslq %edx, %rcx
negq %rcx
imulq $0x18, %rcx, %rcx
movq (%rax,%rcx), %rax
movslq %esi, %rcx
imulq $0x30, %rcx, %rcx
movb -0x28(%rax,%rcx), %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/chart.cc
// Function: Chart::setSpawn(char, int&, int&)
void Chart::setSpawn(char spawnPt, int& x, int&y){
  vector<vector <container> >::iterator row;
  vector<container> ::iterator col;
  for(row = world.begin(); row < world.end(); row++){
    for(col = row->begin(); col< row->end(); col++){
      if(spawnPt == col->getGeoType()){
	x = col->getPosX();
	y = col->getPosY();
	return;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rdi), %rdi
cmpq %rdi, %rax
jae 0x69d5
movq (%rax), %r8
movq 0x8(%rax), %r9
cmpq %r9, %r8
jae 0x69c4
cmpb %sil, 0x9(%r8)
je 0x69ca
addq $0x30, %r8
jmp 0x69b3
addq $0x18, %rax
jmp 0x69a7
movl (%r8), %eax
movl %eax, (%rdx)
movl 0x4(%r8), %eax
movl %eax, (%rcx)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/chart.cc
// Function: Chart::isPortal(int, int, bool&)
void Chart::isPortal(int x,int y,bool& gotLink){
  //cout<<"starting portal search"<<endl;
  vector<vector <container> >::iterator row = world.end()-y;
  vector<container> ::iterator col = row->begin()+x-1;
  //cout<<col->getPosX()<<col->getPosY()<<col->getLink();
  if(col->getLink() != ""){
    gotLink = true;
    this->loadWorld(col->getLink().c_str());
    //	cout<<"going to"<< col->getLink()<<endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movslq %edx, %rcx
negq %rcx
imulq $0x18, %rcx, %rcx
movq (%rax,%rcx), %rax
movslq %esi, %rcx
imulq $0x30, %rcx, %rcx
leaq (%rax,%rcx), %r15
addq $-0x20, %r15
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2250
leaq 0x2aca(%rip), %rsi      # 0x94f4
movq %r12, %rdi
callq 0x2e47
movl %eax, %r12d
leaq -0x48(%rbp), %rdi
callq 0x2100
testb %r12b, %r12b
je 0x6a84
movb $0x1, (%r14)
leaq -0x48(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2250
movq (%r14), %rsi
leaq -0x68(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x2dd8
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x613a
leaq -0x68(%rbp), %rdi
callq 0x2100
leaq -0x48(%rbp), %rdi
callq 0x2100
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x2100
jmp 0x6aa4
jmp 0x6aa1
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/inventory.cc
// Function: Inventory::displayInv()
void Inventory::displayInv(){
  vector<Item>::iterator it;
  cout<<"===============Inventory==============="<<endl;
  for(it= invContainer.begin(); it< invContainer.end(); it++){
    cout<<"- ";
    it->viewItem();
  }
  cout<<"=======================================";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x6ad3(%rip), %r14      # 0xdfd0
leaq 0x2268(%rip), %rsi      # 0x976c
movq %r14, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x2110
movq (%rbx), %r15
leaq 0x2203(%rip), %r12      # 0x9721
cmpq 0x8(%rbx), %r15
jae 0x753d
movq %r14, %rdi
movq %r12, %rsi
callq 0x21c0
movq %r15, %rdi
callq 0x4a02
addq $0x58, %r15
jmp 0x751e
movq 0x6a8c(%rip), %rdi      # 0xdfd0
leaq 0x2249(%rip), %rsi      # 0x9794
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/inventory.cc
// Function: Inventory::saveInventory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Inventory::saveInventory(string unitName){
  Item temp;
  vector<Item>::iterator it;
  ofstream fout;
  //open file at destination
	remove(("./saves/" + unitName +"Inv").c_str());
  fout.open(("./saves/" + unitName +"Inv").c_str());
  for(it=invContainer.begin(); it< invContainer.end(); it++){
    if(it+1 != invContainer.end())
      fout<<*it<<endl;
    else
      fout<<*it;
  }
  fout.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2f8, %rsp            # imm = 0x2F8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1c7b(%rip), %rsi      # 0x9208
leaq -0x98(%rbp), %rdi
leaq -0x2f0(%rbp), %rdx
callq 0x2dd8
leaq 0x1d11(%rip), %rsi      # 0x92b8
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x2dd8
andl $0x0, 0x10(%rsp)
andl $0x0, (%rsp)
movl $0x14, 0x8(%rsp)
leaq -0xf0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0x78(%rbp), %rdx
pushq $0x1
popq %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x48f4
leaq -0x78(%rbp), %rdi
callq 0x2100
leaq -0x98(%rbp), %rdi
callq 0x2100
leaq -0x2f0(%rbp), %rdi
callq 0x22e0
leaq 0x1d15(%rip), %rsi      # 0x9322
leaq -0x38(%rbp), %rdi
movq %r14, %rdx
callq 0x47d2
leaq 0x219c(%rip), %rdx      # 0x97bc
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6afc
leaq -0x58(%rbp), %r15
movq (%r15), %rdi
callq 0x2320
movq %r15, %rdi
callq 0x2100
leaq -0x38(%rbp), %rdi
callq 0x2100
leaq 0x1cd1(%rip), %rsi      # 0x9322
leaq -0x38(%rbp), %rdi
movq %r14, %rdx
callq 0x47d2
leaq 0x2158(%rip), %rdx      # 0x97bc
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6afc
movq -0x58(%rbp), %rsi
leaq -0x2f0(%rbp), %rdi
pushq $0x10
popq %rdx
callq 0x2050
leaq -0x58(%rbp), %rdi
callq 0x2100
leaq -0x38(%rbp), %rdi
callq 0x2100
movq (%rbx), %rsi
leaq -0x2f0(%rbp), %r14
movq 0x8(%rbx), %rax
cmpq %rax, %rsi
jae 0x76d4
leaq 0x58(%rsi), %r15
cmpq %rax, %r15
je 0x76c7
movq %r14, %rdi
callq 0x4cc5
movq %rax, %rdi
callq 0x2110
movq %r15, %rsi
jmp 0x76a0
movq %r14, %rdi
callq 0x4cc5
movq %r15, %rsi
jmp 0x76a0
leaq -0x2f0(%rbp), %rdi
callq 0x2260
leaq -0x2f0(%rbp), %rdi
callq 0x2280
leaq -0xf0(%rbp), %rdi
callq 0x2f08
addq $0x2f8, %rsp            # imm = 0x2F8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7753
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2100
jmp 0x771d
jmp 0x771a
jmp 0x7753
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2100
jmp 0x7756
jmp 0x7753
movq %rax, %rbx
jmp 0x7762
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x2100
jmp 0x7740
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x2100
jmp 0x776e
movq %rax, %rbx
jmp 0x776e
movq %rax, %rbx
leaq -0x2f0(%rbp), %rdi
callq 0x2280
leaq -0xf0(%rbp), %rdi
callq 0x2f08
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/inventory.cc
// Function: Inventory::loadInventory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Inventory::loadInventory(string unitName){
  Item temp;
  ifstream fin;
  fin.open(("./saves/" + unitName +"Inv").c_str());
  //for each item in file get stats and overwrite temp
  while(!fin.eof()){
    fin>>temp;
    //push into Inventory
    pickUp(temp);
  }
  fin.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x350, %rsp            # imm = 0x350
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1a73(%rip), %rsi      # 0x9208
leaq -0xa0(%rbp), %rdi
leaq -0x358(%rbp), %rdx
callq 0x2dd8
leaq 0x1b09(%rip), %rsi      # 0x92b8
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x2dd8
andl $0x0, 0x10(%rsp)
andl $0x0, (%rsp)
movl $0x14, 0x8(%rsp)
leaq -0xf8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0x80(%rbp), %rdx
pushq $0x1
popq %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x48f4
leaq -0x80(%rbp), %rdi
callq 0x2100
leaq -0xa0(%rbp), %rdi
callq 0x2100
leaq -0x358(%rbp), %rdi
callq 0x21f0
leaq 0x1b0d(%rip), %rsi      # 0x9322
leaq -0x60(%rbp), %rdi
movq %r14, %rdx
callq 0x47d2
leaq 0x1f94(%rip), %rdx      # 0x97bc
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x6afc
movq -0x40(%rbp), %rsi
leaq -0x358(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x2150
leaq -0x40(%rbp), %rdi
callq 0x2100
leaq -0x60(%rbp), %rdi
callq 0x2100
leaq -0x358(%rbp), %r14
leaq -0xf8(%rbp), %r15
leaq -0x150(%rbp), %r12
movq -0x358(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x338(%rbp,%rax)
jne 0x78af
movq %r14, %rdi
movq %r15, %rsi
callq 0x4d8e
movq %r12, %rdi
movq %r15, %rsi
callq 0x4780
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7c10
movq %r12, %rdi
callq 0x2f08
jmp 0x786f
leaq -0x358(%rbp), %rdi
callq 0x2070
leaq -0x358(%rbp), %rdi
callq 0x2080
leaq -0xf8(%rbp), %rdi
callq 0x2f08
addq $0x350, %rsp            # imm = 0x350
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x793d
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2100
jmp 0x78f6
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2100
jmp 0x7940
jmp 0x793d
movq %rax, %rbx
jmp 0x794c
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x2100
jmp 0x7919
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x2100
jmp 0x7958
movq %rax, %rbx
jmp 0x7958
movq %rax, %rbx
leaq -0x150(%rbp), %rdi
callq 0x2f08
jmp 0x7940
movq %rax, %rbx
leaq -0x358(%rbp), %rdi
callq 0x2080
leaq -0xf8(%rbp), %rdi
callq 0x2f08
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/inventory.cc
// Function: Inventory::searchWeaponEquipped()
bool Inventory::searchWeaponEquipped(){
  vector<Item>::iterator it;

  for(it=invContainer.begin(); it< invContainer.end(); it++){
    if(it->itemGetType() == "Right-Hand" && it->itemGetEquipped() == true){
      return true;
    }
    else if(it->itemGetType() == "Left-Hand" && it->itemGetEquipped() == true){
       return true;
    }
    else if(it->itemGetType() == "Two-Hands" && it->itemGetEquipped() == true){
        return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq (%rdi), %rbx
leaq -0x48(%rbp), %r15
movq 0x8(%r14), %r12
cmpq %r12, %rbx
jae 0x7a54
movq %r15, %rdi
movq %rbx, %rsi
callq 0x49aa
movq %r15, %rdi
leaq 0x1906(%rip), %rsi      # 0x92a3
callq 0x2e13
testb %al, %al
je 0x79c3
movq %rbx, %rdi
callq 0x49f8
movl %eax, %r13d
movq %r15, %rdi
callq 0x2100
testb %r13b, %r13b
je 0x79cb
jmp 0x7a54
movq %r15, %rdi
callq 0x2100
movq %r15, %rdi
movq %rbx, %rsi
callq 0x49aa
movq %r15, %rdi
leaq 0x18ce(%rip), %rsi      # 0x92ae
callq 0x2e13
testb %al, %al
je 0x7a03
movq %rbx, %rdi
callq 0x49f8
movl %eax, %r13d
movq %r15, %rdi
callq 0x2100
testb %r13b, %r13b
je 0x7a0b
jmp 0x7a54
movq %r15, %rdi
callq 0x2100
movq %r15, %rdi
movq %rbx, %rsi
callq 0x49aa
movq %r15, %rdi
leaq 0x1898(%rip), %rsi      # 0x92b8
callq 0x2e13
testb %al, %al
je 0x7a43
movq %rbx, %rdi
callq 0x49f8
movl %eax, %r13d
movq %r15, %rdi
callq 0x2100
testb %r13b, %r13b
je 0x7a4b
jmp 0x7a54
movq %r15, %rdi
callq 0x2100
addq $0x58, %rbx
jmp 0x797b
cmpq %r12, %rbx
setb %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7a6d
jmp 0x7a6d
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/inventory.cc
// Function: Inventory::getSearch(Item)
Item Inventory::getSearch(Item iSearch){
  vector<Item>::iterator it;
  for(it=invContainer.begin(); it< invContainer.end(); it++){
    if (*it == iSearch)
      return *it;
  }
  return *it;
  cout<<"test";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %r15
cmpq 0x8(%r12), %r15
jae 0x7ab5
movq %r15, %rdi
movq %r14, %rsi
callq 0x4c56
testb %al, %al
jne 0x7ab5
addq $0x58, %r15
jmp 0x7a99
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4780
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/inventory.cc
// Function: Inventory::getItemEquipped()
Item& Inventory::getItemEquipped(){

    vector<Item>::iterator it= invContainer.begin();
        Item& temp=*it;
    for(it=invContainer.begin(); it< invContainer.end(); it++){

      if(it->itemGetType() == "Right-Hand" && it->itemGetEquipped() == true)
        temp = *it;
      else if(it->itemGetType() == "Left-Hand" && it->itemGetEquipped() == true)
        temp =*it;
      else if(it->itemGetType() == "Two-Hands" && it->itemGetEquipped() == true)
        temp= *it;
  }
  return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq (%rdi), %r13
leaq -0x48(%rbp), %r15
movq %r13, %rbx
cmpq 0x8(%r14), %rbx
jae 0x7bc8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x49aa
movq %r15, %rdi
leaq 0x179a(%rip), %rsi      # 0x92a3
callq 0x2e13
testb %al, %al
je 0x7b2c
movq %rbx, %rdi
callq 0x49f8
movl %eax, %r12d
movq %r15, %rdi
callq 0x2100
testb %r12b, %r12b
je 0x7b34
jmp 0x7baa
movq %r15, %rdi
callq 0x2100
movq %r15, %rdi
movq %rbx, %rsi
callq 0x49aa
movq %r15, %rdi
leaq 0x1765(%rip), %rsi      # 0x92ae
callq 0x2e13
testb %al, %al
je 0x7b6c
movq %rbx, %rdi
callq 0x49f8
movl %eax, %r12d
movq %r15, %rdi
callq 0x2100
testb %r12b, %r12b
je 0x7b74
jmp 0x7baa
movq %r15, %rdi
callq 0x2100
movq %r15, %rdi
movq %rbx, %rsi
callq 0x49aa
movq %r15, %rdi
leaq 0x172f(%rip), %rsi      # 0x92b8
callq 0x2e13
testb %al, %al
je 0x7bb7
movq %rbx, %rdi
callq 0x49f8
movl %eax, %r12d
movq %r15, %rdi
callq 0x2100
testb %r12b, %r12b
je 0x7bbf
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4c74
jmp 0x7bbf
movq %r15, %rdi
callq 0x2100
addq $0x58, %rbx
jmp 0x7aea
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7bde
jmp 0x7bde
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: open_file(char*)
FILE * open_file(char * fn)
{
    FILE* random_file;
    random_file = fopen(fn, "r");

    if (!random_file)
    {
        fprintf(stderr, "-! ERROR - docfile does not exist !-\n");
        exit(1);
    }

    return random_file;
}

// Assembly:
pushq %rax
leaq 0x18f0(%rip), %rsi      # 0x4210
callq 0x20f0
testq %rax, %rax
je 0x292c
popq %rcx
retq
movq 0x46a5(%rip), %rax      # 0x6fd8
movq (%rax), %rcx
leaq 0x18d5(%rip), %rdi      # 0x4212
pushq $0x25
popq %rsi
pushq $0x1
popq %rdx
callq 0x2240
pushq $0x1
popq %rdi
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: get_number_of_lines(_IO_FILE*)
unsigned int get_number_of_lines(FILE * fp)
{
    unsigned int lines = 0;
    int ch ;

    while(!feof(fp))
    {
      ch = fgetc(fp);
      if(ch == '\n')
      {
        lines++;
      }
    }

    rewind(fp);
    return lines ;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
jne 0x2979
movq %r14, %rdi
callq 0x21c0
xorl %ecx, %ecx
cmpl $0xa, %eax
sete %cl
addl %ecx, %ebx
jmp 0x2959
movq %r14, %rdi
callq 0x2030
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: is_number(char const*)
bool is_number(const char *str)
{
    for(unsigned int i=0; i < strlen(str); i++)
    { //iterating the whole string character by character
        if(!isdigit(str[i]))
        {// and checking if every character is a number
            return 0;
        }
    }

    return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2040
xorl %edx, %edx
movl %edx, %ecx
cmpq %rcx, %rax
jbe 0x29ac
movsbl (%rbx,%rcx), %esi
addl $-0x30, %esi
leal 0x1(%rcx), %edx
cmpl $0xa, %esi
jb 0x2996
cmpq %rcx, %rax
setbe %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: parse_docs(char**, _IO_FILE*)
bool parse_docs(char **docs, FILE * fp)
{// storing docfile's lines into docs array - checking docfile for errors
    char * line = NULL;
    size_t len = 0;
    ssize_t nchars;
    int line_index = 0;

    while ((nchars = getline(&line, &len, fp)) != -1)
    {
        if ( line[nchars - 1] == '\n')
        { // removing newline character from string
            line[nchars - 1] = '\0';
            nchars--;
        }

        char *content;
        char *line_id_str = strtok_r(line, " \t", &content);

        if(line_id_str == NULL)
        { // checking if there is a line id
            cout<<"-! ERROR line is empty (without id) !-"<<endl;
            free(line);
            return 1;
        }

        int line_id = strtol(line_id_str, NULL, 10);

        if(is_number(line_id_str) == 1)
        { //checking if line id is a number
            if(line_id != line_index)
            { //checking if indexing is correct
                cout<<"-! ERROR at line indexing !-"<<endl;
                free(line);
                return 1;
            }
        }
        else
        {
            cout<<"-! ERROR line id is not a number !-"<<endl;
            free(line);
            return 1;
        }

        docs[line_index] = (char *) malloc((strlen(content) + 1) * sizeof(char));  //plus one for \0
        strcpy(docs[line_index], content);  //storing docfile's line into doc array
        line_index++;
    }

    free(line);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rsp, %rax
andq $0x0, (%rax)
leaq 0x10(%rsp), %rax
andq $0x0, (%rax)
movq %rdi, %r13
xorl %r12d, %r12d
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x2120
movq %rax, %rbp
movq (%rsp), %rdi
cmpq $-0x1, %rax
je 0x2aa8
cmpb $0xa, -0x1(%rdi,%rbp)
jne 0x2a0c
movb $0x0, -0x1(%rdi,%rbp)
movq (%rsp), %rdi
leaq 0x1825(%rip), %rsi      # 0x4238
leaq 0x8(%rsp), %rdx
callq 0x2230
testq %rax, %rax
je 0x2a77
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
pushq $0xa
popq %rdx
callq 0x2160
movq %rax, %r15
movq %r14, %rdi
callq 0x298b
testb %al, %al
je 0x2a80
movl %r15d, %eax
cmpq %rax, %r12
jne 0x2a89
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2040
leaq 0x1(%rax), %rdi
callq 0x2130
movq %rax, (%r13,%r12,8)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2090
incq %r12
jmp 0x29db
leaq 0x17bd(%rip), %rsi      # 0x423b
jmp 0x2a90
leaq 0x17f8(%rip), %rsi      # 0x427f
jmp 0x2a90
leaq 0x17d2(%rip), %rsi      # 0x4262
movq 0x4539(%rip), %rdi      # 0x6fd0
callq 0x20a0
movq %rax, %rdi
callq 0x2050
movq (%rsp), %rdi
callq 0x2100
cmpq $-0x1, %rbp
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: insert_docs_into_trie(my_trie*, char**, unsigned int*, unsigned int)
unsigned int insert_docs_into_trie(my_trie * my_trie_ptr, char ** docs,
    unsigned int * docs_word_counter, unsigned int nlines)
{//inserting every doc's word into trie, counting each doc's number of words - returns total number of all docs' words
    unsigned int total_word_counter = 0;

    for(unsigned int i = 0; i < nlines; i++)
    { //for each doc
        char * line_cp = (char *) malloc((strlen(docs[i]) + 1) * sizeof(char));
        strcpy(line_cp, docs[i]);
        char * word = strtok (line_cp, " \t");
        unsigned int line_word_counter = 0;

        while (word != NULL)
        {//for each doc's word
            line_word_counter++;
            my_trie_ptr->insert_word(word, i);
            word = strtok (NULL, " \t");
        }

        free(line_cp);

        docs_word_counter[i] = line_word_counter;
        total_word_counter += line_word_counter;
    }

    return total_word_counter;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, (%rsp)
movq %rdi, %r15
movl %ecx, %eax
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
leaq 0x174a(%rip), %r13      # 0x4238
xorl %ebp, %ebp
cmpq 0x10(%rsp), %r12
je 0x2b67
movq (%rsp), %rax
movq (%rax,%r12,8), %r14
movq %r14, %rdi
callq 0x2040
leaq 0x1(%rax), %rdi
callq 0x2130
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2090
movq %rbx, %rdi
movq %r13, %rsi
callq 0x21b0
xorl %r14d, %r14d
testq %rax, %rax
je 0x2b4e
incl %r14d
movq %r15, %rdi
movq %rax, %rsi
movl %r12d, %edx
callq 0x38a8
xorl %edi, %edi
movq %r13, %rsi
callq 0x21b0
jmp 0x2b2c
movq %rbx, %rdi
callq 0x2100
movq 0x8(%rsp), %rax
movl %r14d, (%rax,%r12,4)
addl %r14d, %ebp
incq %r12
jmp 0x2af0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: strip_line_into_words(char*, unsigned int&)
char ** strip_line_into_words(char * cmd, unsigned int & cmd_nwords)
{//returns a char * array which contains each cmd's word
    char ** cmd_words = NULL;
    char * word = strtok (cmd, " \t");

    unsigned int word_counter = 0;

    while (word != NULL)
    { //for each cmd's word
        cmd_words = (char **) realloc(cmd_words, (word_counter + 1) * sizeof(char *));
        cmd_words[word_counter] = (char *) malloc((strlen(word) + 1) * sizeof(char));  // plus one for \0
        strcpy(cmd_words[word_counter], word);
        word_counter++;
        word = strtok (NULL, " \t");
    }

    cmd_nwords = word_counter;
    return cmd_words;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %r14d, %r14d
leaq 0x16a8(%rip), %r15      # 0x4238
xorl %r13d, %r13d
movq %r15, %rsi
callq 0x21b0
testq %rax, %rax
je 0x2be4
movq %rax, %r12
leal 0x1(%r13), %ebp
leaq (,%rbp,8), %rsi
movq %r14, %rdi
callq 0x21e0
movq %rax, %r14
movq %r12, %rdi
callq 0x2040
leaq 0x1(%rax), %rdi
callq 0x2130
movl %r13d, %ecx
movq %rax, (%r14,%rcx,8)
movq %rax, %rdi
movq %r12, %rsi
callq 0x2090
xorl %edi, %edi
movl %ebp, %r13d
jmp 0x2b93
movl %r13d, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: delete_docs(char**, unsigned int*, unsigned int)
void delete_docs(char ** docs, unsigned int * docs_word_counter, unsigned int nlines)
{
    for(unsigned int i = 0; i < nlines; i++)
    {
        if (docs[i] != NULL)
        {
            free(docs[i]);
        }
    }

    free(docs);
    free(docs_word_counter);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x2c4e
movq (%r14,%r12,8), %rdi
callq 0x2100
incq %r12
jmp 0x2c3b
movq %r14, %rdi
callq 0x2100
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: read_str(unsigned int)
char * read_str(unsigned int str_len)
{ //reads and returns string of unknown length
    char * str = (char *) malloc((str_len) * sizeof(char));
    int ch;
    unsigned int i = 0;

    while(((ch = getchar()) != '\n') && (ch != EOF))
    {
        str[i] = ch;
        i++;
        if(i == str_len)
        {
            str_len++;
            str = (char *) realloc(str, str_len * sizeof(char));
        }
    }

    str[i] = '\0';  // add \0 at the end of the string
    return str;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movl %edi, %edi
callq 0x2130
movq %rax, %r14
xorl %ebp, %ebp
callq 0x2140
movl %ebp, %ecx
cmpl $-0x1, %eax
je 0x2ca8
cmpl $0xa, %eax
je 0x2ca8
movb %al, (%r14,%rcx)
incl %ebp
cmpl %ebp, %ebx
jne 0x2c7b
incl %ebx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21e0
movq %rax, %r14
jmp 0x2c7b
movb $0x0, (%r14,%rcx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: get_unq_doc_ids(char**, posting_list**, my_trie*, unsigned int, unsigned int&)
unsigned int * get_unq_doc_ids(char ** cmd_words, posting_list ** pl_array, my_trie * trie_ptr,
    unsigned int nqs, unsigned int & unq_doc_ids_size)
{//returns an array that contains every unique doc id taken from each query's posting list
 //also all queries' posting lists pointers are stored in an array
    unsigned int * unq_doc_ids = NULL;
    unq_doc_ids_size = 0;

    for(unsigned int i = 1; i <= nqs; i++)
    { // for each query (max = 10)
        posting_list * pl_ptr = trie_ptr->search_word(cmd_words[i]);  //check if query exists in trie
        pl_array[i-1] = pl_ptr;  //store query's posting list pointer

        if(pl_ptr != NULL)
        { // if query exists
            unq_doc_ids = pl_ptr->add_doc_id_to_array(unq_doc_ids, unq_doc_ids_size);  //update unique doc ids array from query's posting list
        }
    }

    return unq_doc_ids;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
andl $0x0, (%r8)
movq %rsi, %r15
movq %rdi, %r12
xorl %r14d, %r14d
xorl %r13d, %r13d
leal 0x1(%r14), %ebx
cmpl %ebp, %ebx
ja 0x2dba
movl %ebx, %eax
movq (%r12,%rax,8), %rsi
movq 0x10(%rsp), %rdi
callq 0x3a4c
movl %r14d, %ecx
movq %rax, (%r15,%rcx,8)
testq %rax, %rax
je 0x2db5
movq %rax, %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rdx
callq 0x3cde
movq %rax, %r13
movl %ebx, %r14d
jmp 0x2d7e
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: underline(unsigned int, unsigned int&, int**, int&, bool)
void underline(unsigned int init_llen, unsigned int & curr_llen, int ** underline_info, int & underline_info_size, bool exit)
{//underlining words based on the underline info array

    cout<<endl;
    for(int i = 0; i < *underline_info[0]; i++)
    {//set cursor to the correct spot
        cout<<" ";
    }

    for(int i = 0; i <= underline_info_size - 2; i+=2)
    {
        unsigned int start_ul = *underline_info[i];
        unsigned int end_ul = *underline_info[i+1];

        for(unsigned int j = start_ul; j < end_ul; j++)
        {//underline word
            cout<<"^";
        }

        if(i != (underline_info_size - 2))
        {//if there are more than one words that needs underlining set cursor to the correct spot
            unsigned int start_sp = end_ul;
            unsigned int end_sp = *underline_info[i+2];

            for(unsigned int j = start_sp; j < end_sp; j++)
            {
                cout<<" ";
            }
        }
    }

    for(int i = 0; i < underline_info_size; i++)
    {
        free(underline_info[i]);
    }

    underline_info = NULL;
    underline_info_size = 0;

    if(exit == 0)
    {// if there are more words to be printed set cursor to the correct spot
        init_newline(init_llen, curr_llen);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, 0x20(%rsp)
movl %edi, 0x10(%rsp)
movq 0x4176(%rip), %rbx      # 0x6fd0
movq %rbx, %rdi
callq 0x2050
xorl %ebp, %ebp
leaq 0x169c(%rip), %r13      # 0x4507
movq (%r15), %rax
cmpl (%rax), %ebp
jge 0x2e81
movq %rbx, %rdi
movq %r13, %rsi
callq 0x20a0
incl %ebp
jmp 0x2e6b
xorl %r14d, %r14d
movq 0x4145(%rip), %r13      # 0x6fd0
leaq 0x1411(%rip), %rbx      # 0x42a3
leaq 0x166e(%rip), %rbp      # 0x4507
movq %r15, 0x18(%rsp)
movq 0x8(%rsp), %rax
movslq (%rax), %rax
leaq -0x2(%rax), %rcx
cmpq %rcx, %r14
jg 0x2f0f
movq (%r15,%r14,8), %rax
movq 0x8(%r15,%r14,8), %rcx
movl (%rax), %r12d
movl (%rcx), %r15d
cmpl %r15d, %r12d
jae 0x2ed3
movq %r13, %rdi
movq %rbx, %rsi
callq 0x20a0
incl %r12d
jmp 0x2ebe
movq 0x8(%rsp), %rax
movl (%rax), %eax
addl $-0x2, %eax
cmpq %rax, %r14
jne 0x2eed
addq $0x2, %r14
movq 0x18(%rsp), %r15
jmp 0x2e9e
movq 0x18(%rsp), %rax
movq 0x10(%rax,%r14,8), %rax
movl (%rax), %r12d
cmpl %r12d, %r15d
jae 0x2ee2
movq %r13, %rdi
movq %rbp, %rsi
callq 0x20a0
incl %r15d
jmp 0x2efa
xorl %ebx, %ebx
cltq
cmpq %rax, %rbx
jge 0x2f2d
movq (%r15,%rbx,8), %rdi
callq 0x2100
incq %rbx
movq 0x8(%rsp), %rax
movl (%rax), %eax
jmp 0x2f11
movq 0x8(%rsp), %rax
andl $0x0, (%rax)
cmpb $0x0, 0x14(%rsp)
je 0x2f4b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x10(%rsp), %edi
movq 0x20(%rsp), %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2f67
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: init_newline(unsigned int, unsigned int&)
void init_newline(unsigned int init_llen, unsigned int & curr_llen)
{//go to new line and set cursor to the correct spot for printing
    cout<<endl;
    curr_llen = init_llen;
    for(unsigned int i = 0; i < init_llen; i++)
    {
        cout<<" ";
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movl %edi, %ebx
movq 0x4058(%rip), %r14      # 0x6fd0
movq %r14, %rdi
callq 0x2050
movl %ebx, (%r15)
leaq 0x157d(%rip), %r15      # 0x4507
subl $0x1, %ebx
jb 0x2f9c
movq %r14, %rdi
movq %r15, %rsi
callq 0x20a0
jmp 0x2f8a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: manage_whitespace(char*, unsigned int, unsigned int, unsigned int&, int**, int&)
bool manage_whitespace(char * rest_line, unsigned int lwidth, unsigned int init_llen, unsigned int & curr_llen,
                       int ** underline_info, int & underline_info_size)
{
    unsigned int whitespace = calc_whitespace(rest_line); //calculate the whitespace from the beginning of the rest content
    if (whitespace == 0)
    {//the whole rest content is whitespace
        if (underline_info_size > 0)
        {//if there are some words to be underlined
            underline(init_llen, curr_llen, underline_info, underline_info_size, 1);
        }

        return 1;  //send stop signal
    }
    else
    {
        for(unsigned int i = 0; i < whitespace; i++)
        {//print whitespace space by space
            if ((curr_llen + 1) > lwidth)
            {// if there is no free space left in terminal's line
                if (underline_info_size > 0)
                {
                    underline(init_llen, curr_llen, underline_info, underline_info_size, 0);
                }
                else
                {
                    init_newline(init_llen, curr_llen);
                }
            }

            curr_llen++;
            cout<<" ";
        }

        return 0;  //keep printing
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, 0x10(%rsp)
movq %rcx, %r15
movl %edx, 0x8(%rsp)
movl %esi, %r13d
callq 0x2dfa
testl %eax, %eax
movl %eax, 0xc(%rsp)
je 0x302a
movq 0x3ffa(%rip), %rbp      # 0x6fd0
leaq 0x152a(%rip), %r14      # 0x4507
movl %eax, %r12d
subl $0x1, %r12d
jb 0x3047
movl (%r15), %eax
incl %eax
cmpl %r13d, %eax
jbe 0x301a
cmpl $0x0, (%rbx)
jle 0x300e
movl 0x8(%rsp), %edi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x2e2f
jmp 0x301a
movl 0x8(%rsp), %edi
movq %r15, %rsi
callq 0x2f67
incl (%r15)
movq %rbp, %rdi
movq %r14, %rsi
callq 0x20a0
jmp 0x2fe0
cmpl $0x0, (%rbx)
jle 0x3047
pushq $0x1
popq %r8
movl 0x8(%rsp), %edi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
callq 0x2e2f
cmpl $0x0, 0xc(%rsp)
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: reallocate_underline_info(int**, unsigned int, unsigned int, unsigned int)
int ** reallocate_underline_info(int ** underline_info, unsigned int underline_info_size, unsigned int ul_start, unsigned int ul_end)
{
    underline_info = (int **) realloc(underline_info, underline_info_size * sizeof(int *));
    underline_info[underline_info_size - 2] = (int *) malloc(sizeof(int));
    underline_info[underline_info_size - 1] = (int *) malloc(sizeof(int));
    *underline_info[underline_info_size - 2] = ul_start;
    *underline_info[underline_info_size - 1] = ul_end;
    return underline_info;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %esi, %esi
shlq $0x3, %rsi
callq 0x21e0
movq %rax, %r15
pushq $0x4
popq %r12
movq %r12, %rdi
callq 0x2130
movq %rax, %r13
leal -0x2(%r14), %eax
movq %r13, (%r15,%rax,8)
movq %r12, %rdi
callq 0x2130
decl %r14d
movq %rax, (%r15,%r14,8)
movl %ebp, (%r13)
movl %ebx, (%rax)
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/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: search_doc_word_into_queries(char*, char**, unsigned int)
bool search_doc_word_into_queries(char * doc_word, char ** queries, unsigned int nqs)
{//returns 1 if doc_word is contained in queries and 0 otherwise
    for(unsigned int i = 1; i <= nqs; i++)
    {
        if (strcmp(queries[i], doc_word) == 0)
        {
            return 1;
        }
    }

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rcx
movl %ecx, %r12d
cmpl %ebx, %ecx
ja 0x3270
movl %r12d, %eax
movq (%r14,%rax,8), %rdi
movq %r15, %rsi
callq 0x2150
leal 0x1(%r12), %ecx
testl %eax, %eax
jne 0x3251
cmpl %ebx, %r12d
setbe %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/trie.cpp
// Function: my_trie::destroy(my_trie::node*)
void my_trie::destroy(node * n)
{
    if (n != NULL)
    {
        destroy(n->down);
        destroy(n->right);
        if(n->pl_ptr != NULL)
        { //delete node's posting list before deleting the node itself
            delete n->pl_ptr;
        }
        delete n;
        trie_size--;
    }
}

// Assembly:
testq %rsi, %rsi
je 0x388b
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x3838
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x3838
movq 0x18(%r14), %r15
testq %r15, %r15
je 0x3879
movq %r15, %rdi
callq 0x3be8
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x20d0
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x20d0
decl (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/trie.cpp
// Function: my_trie::create_node(char)
my_trie::node * my_trie::create_node(char ch)
{
    node * new_node = new node;
    new_node->ch = ch;
    new_node->down = NULL;
    new_node->right = NULL;
    new_node->pl_ptr = NULL;
    return new_node;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
pushq $0x20
popq %rdi
callq 0x20c0
movb %bl, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/trie.cpp
// Function: my_trie::print(bool)
void my_trie::print(bool full_print)
{
    if(first == NULL)
    {
        cout<<"-> Trie cannot be printed because it is empty !"<<endl;
        return;
    }

    if(full_print == 1)
    {
        cout<<"-----> Printing whole trie <-----"<<endl;
    }
    else
    {
        cout<<"---> Printing document frequency vector <---"<<endl;
    }

    print_subtrie(first, full_print); //print trie recursively starting from the root
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0x39ee
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xae0(%rip), %rax       # 0x4496
leaq 0xafb(%rip), %rsi       # 0x44b8
testb %bpl, %bpl
cmovneq %rax, %rsi
movq 0x3605(%rip), %rdi      # 0x6fd0
callq 0x20a0
movq %rax, %rdi
callq 0x2050
movq 0x8(%rbx), %rsi
movzbl %bpl, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3a10
movq 0x35db(%rip), %rdi      # 0x6fd0
leaq 0xa6a(%rip), %rsi       # 0x4466
callq 0x20a0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2050
nop
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/trie.cpp
// Function: my_trie::print_subtrie(my_trie::node*, bool)
void my_trie::print_subtrie(node * n, bool full_print)
{
    if (n != NULL)
    {
        if(n->pl_ptr != NULL)
        {
            n->pl_ptr->print(full_print);
        }
        print_subtrie(n->down, full_print);
        print_subtrie(n->right, full_print);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzbl %dl, %ebp
testq %rbx, %rbx
je 0x3a46
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3a32
movl %ebp, %esi
callq 0x3ab4
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x3a10
movq 0x8(%rbx), %rbx
jmp 0x3a1d
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/posting_list.cpp
// Function: posting_list::print(bool)
void posting_list::print(bool full_print)
{
    if (full_print == 0) //only print df
    {
        cout<<word<<"  "<<pl_size<<endl;
        return;
    }

    node * temp = first;
    if (first == NULL)
    {
        cout<<"Posting list is empty"<<endl;
        return;
    }

    cout<<"-> word:'"<<word<<"'  "<<pl_size<<"  ";

    while(temp != NULL) //print whole posting list
    {
        cout<<"["<<temp->doc_id<<", "<<temp->freq<<"]"<<"  ";
        temp = temp->next;
    }

    cout<<endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
testl %esi, %esi
je 0x3b8b
movq 0x8(%r14), %rbp
testq %rbp, %rbp
je 0x3bb7
movq 0x34f2(%rip), %rbx      # 0x6fd0
leaq 0xa16(%rip), %rsi       # 0x44fb
movq %rbx, %rdi
callq 0x20a0
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x20a0
leaq 0xa05(%rip), %rsi       # 0x4505
movq %rax, %rdi
callq 0x20a0
movl (%r14), %esi
movq %rax, %rdi
callq 0x2070
leaq 0x9ec(%rip), %r14       # 0x4506
movq %rax, %rdi
movq %r14, %rsi
callq 0x20a0
leaq 0x933(%rip), %r15       # 0x445f
leaq 0x9d6(%rip), %r12       # 0x4509
leaq 0x9d2(%rip), %r13       # 0x450c
testq %rbp, %rbp
je 0x3bcd
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20a0
movl (%rbp), %esi
movq %rax, %rdi
callq 0x2070
movq %rax, %rdi
movq %r12, %rsi
callq 0x20a0
movl 0x4(%rbp), %esi
movq %rax, %rdi
callq 0x2070
movq %rax, %rdi
movq %r13, %rsi
callq 0x20a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x20a0
movq 0x8(%rbp), %rbp
jmp 0x3b3a
movq 0x10(%r14), %rsi
movq 0x343a(%rip), %rdi      # 0x6fd0
callq 0x20a0
leaq 0x964(%rip), %rsi       # 0x4506
movq %rax, %rdi
callq 0x20a0
movl (%r14), %esi
movq %rax, %rdi
callq 0x2070
jmp 0x3bca
movq 0x3412(%rip), %rdi      # 0x6fd0
leaq 0x920(%rip), %rsi       # 0x44e5
callq 0x20a0
movq %rax, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
nop
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/posting_list.cpp
// Function: posting_list::~posting_list()
posting_list::~posting_list()
{
    node * temp = first;
    node * temp2;

    while(temp != NULL) //iterate list
    {
        temp2 = temp->next;
        delete temp;
        temp = temp2;
        pl_size--;
    }

    free(word);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
pushq $0x10
popq %r14
testq %rdi, %rdi
je 0x3c10
movq 0x8(%rdi), %r15
movq %r14, %rsi
callq 0x20d0
decl (%rbx)
movq %r15, %rdi
jmp 0x3bf8
movq 0x10(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/posting_list.cpp
// Function: posting_list::create_node(unsigned int)
posting_list::node * posting_list::create_node(unsigned int doc_id)
{
    node * new_node = new node;
    new_node->doc_id = doc_id;
    new_node->freq = 1;
    new_node->next = NULL ;
    return new_node;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
pushq $0x10
popq %rdi
callq 0x20c0
movl %ebx, (%rax)
movl $0x1, 0x4(%rax)
andq $0x0, 0x8(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/JohnPapad[P]Mini-Search-Engine/posting_list.cpp
// Function: posting_list::add_doc_id_to_array(unsigned int*, unsigned int&)
unsigned int * posting_list::add_doc_id_to_array(unsigned int * unq_doc_ids, unsigned int & unq_doc_ids_size)
{// adding posting list's doc ids to an array. if a posting list's doc id is already contained in the array do not add it again
    node * temp = first;
    while(temp != NULL) //iterating posting list
    {
        bool doc_id_exists = 0;
        for(unsigned int i = 0; i < unq_doc_ids_size; i++)
        { // checking if current doc id is already contained in the array
            if (unq_doc_ids[i] == temp->doc_id)
            {
                doc_id_exists = 1;  // already exists
                break;
            }
        }

        if(doc_id_exists == 0)
        { //if current doc id is not already contained in the array add it now
            unq_doc_ids_size++;
            unq_doc_ids = (unsigned int *) realloc(unq_doc_ids, unq_doc_ids_size * sizeof(unsigned int));
            unq_doc_ids[unq_doc_ids_size - 1] = temp->doc_id;
        }

        temp = temp->next;
    }

    return unq_doc_ids;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x3d26
movl (%rbx), %esi
xorl %ecx, %ecx
cmpq %rcx, %rsi
je 0x3d0a
movl (%rax,%rcx,4), %edx
incq %rcx
cmpl (%r14), %edx
jne 0x3cf8
jmp 0x3ceb
incl %esi
movl %esi, (%rbx)
shlq $0x2, %rsi
movq %rax, %rdi
callq 0x21e0
movl (%r14), %ecx
movl (%rbx), %edx
decl %edx
movl %ecx, (%rax,%rdx,4)
jmp 0x3ceb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: GLUTStop()
void GLUTStop(void)
{
  // Write configuration
  if (output_configuration_filename) {
    if (!WriteConfigurationFile(configuration, output_configuration_filename)) exit(-1);
  }

  // Destroy window 
  glutDestroyWindow(GLUTwindow);

  // Exit
  exit(0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x13405e(%rip), %rbx    # 0x15aa78
testq %rbx, %rbx
jne 0x26a31
movl 0x13405b(%rip), %edi    # 0x15aa80
callq 0xdb3b1
xorl %edi, %edi
callq 0x23b30
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x98b3e
movq %r14, %rdi
callq 0x29e36
cmpb $0x1, 0x134073(%rip)    # 0x15aac0
jne 0x26a6f
leaq 0xbb846(%rip), %rdi     # 0xe229c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x23080
movq 0x12e4d9(%rip), %rax    # 0x154f40
movq (%rax), %rdi
callq 0x23ac0
movq 0x133e5a(%rip), %rax    # 0x15a8d0
leaq 0x133e53(%rip), %rdi    # 0x15a8d0
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq *0x98(%rax)
testl %eax, %eax
jne 0x26a95
pushq $-0x1
popq %rdi
callq 0x23b30
cmpb $0x1, 0x134024(%rip)    # 0x15aac0
jne 0x26a1f
leaq 0x8(%rsp), %rdi
callq 0x98b78
leaq 0xbb80e(%rip), %rdi     # 0xe22bd
movb $0x1, %al
callq 0x23080
movl 0x133e28(%rip), %esi    # 0x15a8e4
leaq 0xbb811(%rip), %rdi     # 0xe22d4
xorl %eax, %eax
callq 0x23080
movl 0x133e24(%rip), %esi    # 0x15a8f4
leaq 0xbb80e(%rip), %rdi     # 0xe22e5
xorl %eax, %eax
callq 0x23080
movq 0x12e45b(%rip), %rax    # 0x154f40
movq (%rax), %rdi
callq 0x23ac0
jmp 0x26a1f
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: DrawCameras(int)
static void
DrawCameras(int color_scheme = RGBD_INDEX_COLOR_SCHEME)
{
  // Draw cameras
  for (int i = 0; i < configuration.NImages(); i++) {
    RGBDImage *image = configuration.Image(i);
    if (!CheckVisibility(image, selected_position)) continue;
    if ((color_scheme != RGBD_INDEX_COLOR_SCHEME) && (i == selected_image_index))
      image->DrawCamera(RGBD_HIGHLIGHT_COLOR_SCHEME);
    else image->DrawCamera(color_scheme);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %r15d, %r15d
pushq $0x4
popq %rbp
movslq 0x1335c1(%rip), %rax    # 0x15a8e4
cmpq %rax, %r15
jge 0x2736c
movq 0x1335a9(%rip), %rax    # 0x15a8d8
movq (%rax,%r15,8), %r14
movq %r14, %rdi
callq 0x29cd4
testl %eax, %eax
je 0x27367
movl 0x12e6c3(%rip), %eax    # 0x155a08
cmpq %rax, %r15
movl %ebx, %esi
cmovel %ebp, %esi
cmpl $0x3, %ebx
movq (%r14), %rax
cmovel %ebx, %esi
movq %r14, %rdi
movsd 0xbacd7(%rip), %xmm0    # 0xe2038
callq *0xc0(%rax)
incq %r15
jmp 0x2731c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: DrawBBoxes(int)
static void
DrawBBoxes(int color_scheme = RGBD_INDEX_COLOR_SCHEME)
{
  // Draw pixels of all images as bboxs in world space
  for (int i = 0; i < configuration.NImages(); i++) {
    RGBDImage *image = configuration.Image(i);
    if ((color_scheme != RGBD_INDEX_COLOR_SCHEME) && (i == selected_image_index)) image->DrawBBox(RGBD_HIGHLIGHT_COLOR_SCHEME);
    else image->DrawBBox(color_scheme);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
xorl %r14d, %r14d
pushq $0x4
popq %rbp
movslq 0x13355a(%rip), %rax    # 0x15a8e4
cmpq %rax, %r14
jge 0x273bc
movl 0x12e673(%rip), %eax    # 0x155a08
cmpq %rax, %r14
movl %ebx, %esi
cmovel %ebp, %esi
cmpl $0x3, %ebx
movq 0x133531(%rip), %rax    # 0x15a8d8
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
cmovel %ebx, %esi
callq *0xc8(%rax)
incq %r14
jmp 0x27383
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: DrawFaces(int)
static void
DrawFaces(int color_scheme = RGBD_INDEX_COLOR_SCHEME)
{
  // Draw surfaces
  for (int i = 0; i < configuration.NSurfaces(); i++) {
    RGBDSurface *surface = configuration.Surface(i);
    if ((color_scheme != RGBD_INDEX_COLOR_SCHEME) && (i == selected_image_index)) surface->DrawFaces(RGBD_HIGHLIGHT_COLOR_SCHEME);
    else surface->DrawFaces(color_scheme);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
xorl %r14d, %r14d
pushq $0x4
popq %rbp
movslq 0x133520(%rip), %rax    # 0x15a8f4
cmpq %rax, %r14
jge 0x27403
movl 0x12e629(%rip), %eax    # 0x155a08
cmpq %rax, %r14
movl %ebx, %esi
cmovel %ebp, %esi
cmpl $0x3, %ebx
movq 0x1334f7(%rip), %rax    # 0x15a8e8
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
cmovel %ebx, %esi
callq *0x60(%rax)
incq %r14
jmp 0x273cd
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: DrawPoints(int, int)
static void
DrawPoints(int color_scheme = RGBD_PHOTO_COLOR_SCHEME, int skip = 1)
{
  // Draw pixels of all images as points in world space
  for (int i = 0; i < configuration.NImages(); i++) {
    RGBDImage *image = configuration.Image(i);
    if (!image->DepthChannel()) continue;
    if ((color_scheme != RGBD_INDEX_COLOR_SCHEME) && (i == selected_image_index)) image->DrawPoints(RGBD_HIGHLIGHT_COLOR_SCHEME, skip);
    else image->DrawPoints(color_scheme, skip);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %r14d, %r14d
pushq $0x4
popq %r15
pushq $0x1
popq %rbp
movslq 0x1334c2(%rip), %rax    # 0x15a8e4
cmpq %rax, %r14
jge 0x27468
movq 0x1334aa(%rip), %rax    # 0x15a8d8
movq (%rax,%r14,8), %rdi
cmpl $0x4, 0x24(%rdi)
jl 0x27463
movq 0x18(%rdi), %rax
cmpq $0x0, 0x18(%rax)
je 0x27463
movl 0x12e5bf(%rip), %eax    # 0x155a08
cmpq %rax, %r14
movl %ebx, %esi
cmovel %r15d, %esi
cmpl $0x3, %ebx
movq (%rdi), %rax
cmovel %ebx, %esi
movl %ebp, %edx
callq *0xd8(%rax)
incq %r14
jmp 0x2741b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq