LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/escenario.cpp
// Function: Escenario::salidasDisponibles[abi:cxx11]()
string Escenario::salidasDisponibles(){
	  
     string lista_salidas="";
     map<string,pScene> salidas=this->get_salidas();

     for(map<string,pScene>::iterator it=salidas.begin();
	 it!=salidas.end();it++)
     {
	  string coordenada=it->first;
	  if(estadoSalidas[coordenada]==true)
	  {
	       lista_salidas+=it->first;
	       lista_salidas+=" ";				  
	  }		  
     }
     return lista_salidas;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0x123bd(%rip), %rdx     # 0x2d623
movq %rdx, %rsi
callq 0x19e74
leaq 0x88(%r14), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1ba08
leaq 0x30(%rsp), %rbp
movq 0x10(%rbp), %r15
cmpq %rbp, %r15
je 0x1b30c
leaq 0x18(%rsp), %r13
addq $0xb8, %r14
leaq 0x8(%rsp), %r12
movq %r13, 0x8(%rsp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x1a0b6
movq %r14, %rdi
movq %r12, %rsi
callq 0x1b824
cmpb $0x1, (%rax)
jne 0x1b2e5
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %rbx, %rdi
callq 0x5120
movq %rbx, %rdi
leaq 0x13330(%rip), %rsi     # 0x2e610
callq 0x5620
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1b2fc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
cmpq %rbp, %rax
jne 0x1b29e
leaq 0x28(%rsp), %rdi
callq 0x1b990
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1b356
movq %rax, %r14
jmp 0x1b34c
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1b34c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
leaq 0x28(%rsp), %rdi
callq 0x1b990
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x1b36e
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5340
movq %r14, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/escenario.cpp
// Function: Escenario::get_description[abi:cxx11]()
string Escenario::get_description(){
     string descripcion=this->examine();
     descripcion+="\n";
     if(this->get_objetos_disponibles()!="")
     {
	  descripcion+="Puedes ver lo siguiente : \n";
	  descripcion+=this->get_objetos_disponibles();	  
     }
     return descripcion;	  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq 0x48(%rsi), %rsi
movq 0x50(%r14), %rdx
addq %rsi, %rdx
callq 0x1a0b6
leaq 0x1227c(%rip), %rsi     # 0x2d622
movq %rbx, %rdi
callq 0x5620
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1adb8
leaq 0x12263(%rip), %rsi     # 0x2d623
movq %rsp, %r15
movq %r15, %rdi
callq 0x5110
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x10(%rsp), %r15
cmpq %r15, %rdi
je 0x1b3e7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
testl %ebp, %ebp
je 0x1b42c
leaq 0x12216(%rip), %rsi     # 0x2d608
movq %rbx, %rdi
callq 0x5620
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1adb8
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x5120
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1b42c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1b45e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x1b45e
jmp 0x1b45b
jmp 0x1b45b
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1b472
movq (%r12), %rsi
incq %rsi
callq 0x5340
movq %r14, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/escenario.cpp
// Function: Escenario::salidas[abi:cxx11]()
string Escenario::salidas(){
     string lista_salidas;
     map<string,pScene> salidas=this->get_salidas();
     for(map<string,pScene>::iterator it=salidas.begin();
	 it!=salidas.end();it++)
     {
	  lista_salidas+=it->first;
	  lista_salidas+=" ";
     }
     return lista_salidas;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
addq $0x88, %rsi
movq %rsp, %rdi
callq 0x1ba08
leaq 0x8(%rsp), %r13
movq 0x10(%r13), %r14
cmpq %r13, %r14
je 0x1b4ec
leaq 0x1314f(%rip), %r15     # 0x2e610
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x5120
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5620
movq %r14, %rdi
callq 0x5240
movq %rax, %r14
cmpq %r13, %rax
jne 0x1b4c1
movq %rsp, %rdi
callq 0x1b990
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x1b515
movq %rax, %r14
movq %rsp, %rdi
callq 0x1b990
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1b529
movq (%r12), %rsi
incq %rsi
callq 0x5340
movq %r14, %rdi
callq 0x55c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/event.cpp
// Function: EventOpenConnection::activate[abi:cxx11]()
const string EventOpenConnection::activate(){

    assert(scene!=NULL);
    scene->set_estado_salida(cardinal,true);
    /// TODO: If something goes wrong this should return an error messages
//	  return string("message");
    return postMessage;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x1ca5c
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x10(%rsi), %rsi
movq 0x18(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0x1a0b6
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x1b21a
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1ca31
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1a0b6
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x10bc2(%rip), %rdi     # 0x2d625
leaq 0x10bc7(%rip), %rsi     # 0x2d631
leaq 0x10bce(%rip), %rcx     # 0x2d63f
movl $0x6, %edx
callq 0x5210
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1ca94
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/factory.cpp
// Function: FactoryGame::getNameListFromNode[abi:cxx11](TiXmlNode*)
vector<string> FactoryGame::getNameListFromNode(pNode parent){

     vector<string> output;
     pNode child = 0;
     while((child = parent->IterateChildren(child)))
     {
	  string value_text = child->Value();
	  output.push_back(value_text);
     }
     return output;	  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x18(%rsp), %rbp
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
movq %r14, %rdi
movq %r13, %rsi
callq 0x28276
movq %rax, %r13
testq %rax, %rax
je 0x1eb78
movq 0x38(%r13), %rsi
addq $0x10, %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x19e2c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19d90
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1eb2e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x1eb2e
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1eba8
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1ebab
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x1ebab
movq %rax, %r14
movq %rbx, %rdi
callq 0x19dce
movq %r14, %rdi
callq 0x55c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/factory.cpp
// Function: FactoryGame::getTextListFromNode[abi:cxx11](TiXmlNode*)
vector<string> FactoryGame::getTextListFromNode(pNode parent){

     vector<string> output;
     pNode child = 0;
     while((child = parent->IterateChildren(child)))
     {
	  pElem temp = child->ToElement();
	  string value_text = temp->GetText();
	  output.push_back(value_text);
     }
     return output;	  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x18(%rsp), %rbp
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
movq %r14, %rdi
movq %r13, %rsi
callq 0x28276
movq %rax, %r13
testq %rax, %rax
je 0x1ec47
movq (%r13), %rax
movq %r13, %rdi
callq *0x58(%rax)
movq %rax, %rdi
callq 0x2911a
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x19e2c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19d90
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1ebf0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x1ebf0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ec7b
jmp 0x1ec7b
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1ec7e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x1ec7e
jmp 0x1ec7b
movq %rax, %r14
movq %rbx, %rdi
callq 0x19dce
movq %r14, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/factory.cpp
// Function: FactoryGame::getGameElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
pElem FactoryGame::getGameElement(string name){

    // TODO: Depending on data origin setup work on JSON, XML or SQL table
    
    // Looking for the Element Items
    pNode node=NULL;
    node = xmlDoc.FirstChild("games");
    assert(node);	  
    TiXmlHandle docHandle(node);
    pElem elem = docHandle.FirstChild("game").FirstChild(name.c_str()).ToElement();
    return elem;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
addq $0x20, %rdi
leaq 0xe361(%rip), %rsi      # 0x2d004
callq 0x28202
testq %rax, %rax
je 0x1ed03
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xe3a5(%rip), %rdx      # 0x2d061
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2a67c
movq (%rbx), %rdx
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a67c
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1ecf9
movq (%rdi), %rax
callq *0x58(%rax)
testq %rax, %rax
je 0x1ecf9
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
jmp 0x1ecfb
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0xe300(%rip), %rdi      # 0x2d00a
leaq 0xebce(%rip), %rsi      # 0x2d8df
leaq 0xebd7(%rip), %rcx      # 0x2d8ef
movl $0x8f, %edx
callq 0x5210
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/factory.cpp
// Function: FactoryGame::searchForElementId(TiXmlElement*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
pElem FactoryGame::searchForElementId(pElem parent,string id){

     pNode child = 0;
     while((child = parent->IterateChildren(child)))
     {
	  pElem temp = child->ToElement();
	  string value_attribute = temp->Attribute("id");
	  if(id.compare(value_attribute)==0 )
	  {
	       return temp;
	  }
     }	  
     return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
leaq 0x8(%rsp), %r13
xorl %ebx, %ebx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x28276
testq %rax, %rax
je 0x1edad
movq %rax, %rbx
movq (%rax), %rax
movq %rbx, %rdi
callq *0x58(%rax)
movq %rax, %r12
movq %rax, %rdi
leaq 0xe327(%rip), %rsi      # 0x2d08d
callq 0x288ba
movq %r13, %rdi
movq %rax, %rsi
leaq 0x7(%rsp), %rdx
callq 0x19e2c
movq %r14, %rdi
movq %r13, %rsi
callq 0x5060
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1eda4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
testl %ebp, %ebp
jne 0x1ed3d
movq %r12, %rax
jmp 0x1edaf
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1eddd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x55c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/inventario.cpp
// Function: Inventario::listar[abi:cxx11]()
string Inventario::listar(){
    string lista_inventario=string("");
    //Recorrer map
    for(map<string,Objeto*>::iterator it=objetos_inventario.begin();
        it!=objetos_inventario.end();it++){
        lista_inventario+=" ";			
        lista_inventario+=it->second->Name();
    }
    if(lista_inventario=="")
        lista_inventario="Tu inventario está vacío.";
	 
    return lista_inventario;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0xdf3b(%rip), %rdx      # 0x2d623
movq %rdx, %rsi
callq 0x19e74
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x1f76e
leaq 0x18(%rsp), %rbp
leaq 0xef07(%rip), %r12      # 0x2e610
leaq 0x8(%rsp), %r13
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5620
movq 0x40(%r15), %rax
movq %rbp, 0x8(%rsp)
movq 0x28(%rax), %rsi
movq 0x30(%rax), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x1a0b6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x5120
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1f75e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
cmpq %r14, %rax
jne 0x1f70e
leaq 0xdeae(%rip), %rsi      # 0x2d623
movq %rbx, %rdi
callq 0x5110
testl %eax, %eax
jne 0x1f79c
movq 0x8(%rbx), %rdx
leaq 0xe2de(%rip), %rcx      # 0x2da6a
movl $0x1b, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5500
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1f7b2
jmp 0x1f7b2
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x1f7cd
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5340
movq %r14, %rdi
callq 0x55c0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1f7b5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x1f7b5
nop
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/inventario.cpp
// Function: Inventario::get_existe_objeto(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Inventario::get_existe_objeto(string nombre){
    for(map<string,Objeto*>::iterator it=objetos_inventario.begin();
        it!=objetos_inventario.end();it++){
        if(it->first==nombre)
            return true;
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x1f842
movq %rsi, %rbx
movq 0x8(%rsi), %r12
cmpq %r12, 0x28(%r15)
jne 0x1f832
movb $0x1, %bpl
testq %r12, %r12
je 0x1f844
movq (%rbx), %rsi
movq 0x20(%r15), %rdi
movq %r12, %rdx
callq 0x5360
testl %eax, %eax
je 0x1f844
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
cmpq %r14, %rax
jne 0x1f811
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/inventario.cpp
// Function: Inventario::posee_alcanzador()
bool Inventario::posee_alcanzador(){
    map<string,Objeto*>::iterator it;
    for(it=objetos_inventario.begin();it!=objetos_inventario.end();it++)
    {
        if(it->second->get_value<bool>("reacher"))
            return true;
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x1f89e
leaq 0xe20c(%rip), %r15      # 0x2da86
movq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0x24cf0
movl %eax, %ebp
testb %al, %al
jne 0x1f8a0
movq %r14, %rdi
callq 0x5240
movq %rax, %r14
cmpq %rbx, %rax
jne 0x1f87a
jmp 0x1f8a0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/inventario.cpp
// Function: Inventario::tomar_alcanzador()
Objeto* Inventario::tomar_alcanzador(){
    map<string,Objeto*>::iterator it;
    for(it=objetos_inventario.begin();it!=objetos_inventario.end();it++)
    {
        if(it->second->get_value<bool>("reacher"))
            return it->second;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x1f8f1
leaq 0xe1b9(%rip), %r12      # 0x2da86
xorl %ebx, %ebx
movq 0x40(%r15), %rdi
movq %r12, %rsi
callq 0x24cf0
testb %al, %al
jne 0x1f8f5
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
cmpq %r14, %rax
jne 0x1f8cf
jmp 0x1f8f9
xorl %ebx, %ebx
jmp 0x1f8f9
movq 0x40(%r15), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/inventario.cpp
// Function: Inventario::posee_desatascador()
bool Inventario::posee_desatascador(){
    map<string,Objeto*>::iterator it;
    for(it=objetos_inventario.begin();it!=objetos_inventario.end();it++)
    {
        if(it->second->get_value<bool>("desatascador"))
            return true;
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x1f94a
leaq 0xe5c1(%rip), %r15      # 0x2dee7
movq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0x24cf0
movl %eax, %ebp
testb %al, %al
jne 0x1f94c
movq %r14, %rdi
callq 0x5240
movq %rax, %r14
cmpq %rbx, %rax
jne 0x1f926
jmp 0x1f94c
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/inventario.cpp
// Function: Inventario::tomar_desatascador()
Objeto* Inventario::tomar_desatascador(){
    map<string,Objeto*>::iterator it;
    for(it=objetos_inventario.begin();it!=objetos_inventario.end();it++)
    {
        if(it->second->get_value<bool>("desatascador"))
            return it->second;
    }
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x1f99d
leaq 0xe56e(%rip), %r12      # 0x2dee7
xorl %ebx, %ebx
movq 0x40(%r15), %rdi
movq %r12, %rsi
callq 0x24cf0
testb %al, %al
jne 0x1f9a1
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
cmpq %r14, %rax
jne 0x1f97b
jmp 0x1f9a5
xorl %ebx, %ebx
jmp 0x1f9a5
movq 0x40(%r15), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/item_creator.cpp
// Function: ItemGameCreator::ItemGameCreator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ItemGameCreator::ItemGameCreator(const string xmlGameSpecs)
{
    bool loadOkay = xmlDoc.LoadFile(xmlGameSpecs.c_str());
    if (!loadOkay)
    {
        printf("Could not load test xml file. Error='%s'. Exiting.\n", xmlDoc.ErrorDesc());
        exit(1);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x19253(%rip), %r12     # 0x39510
movq %r12, (%rdi)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x29144
leaq 0x191fd(%rip), %rax     # 0x394d0
movq %rax, (%rbx)
movq (%r15), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2946a
testb %al, %al
je 0x202f3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x60(%rbx), %rsi
addq $0x10, %rsi
leaq 0xd3f9(%rip), %rdi      # 0x2d6fb
xorl %eax, %eax
callq 0x5080
movl $0x1, %edi
callq 0x53e0
movq %rax, %r15
movq %r12, (%rbx)
movq %r14, %rdi
callq 0x1ede6
movq %r15, %rdi
callq 0x55c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/logger.cpp
// Function: Logger::instance()
Logger& Logger::instance()
{
    static Cleanup cleanup;

    lock_guard<mutex> guard(sMutex);
    if (pInstance == nullptr)
        pInstance = new Logger();
    return *pInstance;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movb 0x1e8f6(%rip), %al      # 0x3f3b0
testb %al, %al
je 0x20b0d
leaq 0x1e8bb(%rip), %rdi     # 0x3f380
callq 0x54c0
testl %eax, %eax
jne 0x20b14
movq 0x1e8a3(%rip), %rbx     # 0x3f378
testq %rbx, %rbx
jne 0x20af6
movl $0x208, %edi            # imm = 0x208
callq 0x5330
movq %rax, %rbx
movq %rax, %rdi
callq 0x20bfa
movq %rbx, 0x1e882(%rip)     # 0x3f378
leaq 0x1e883(%rip), %rdi     # 0x3f380
callq 0x5280
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x572d
jmp 0x20abe
movl %eax, %edi
callq 0x5220
movq %rax, %r14
movl $0x208, %esi            # imm = 0x208
movq %rbx, %rdi
callq 0x5340
jmp 0x20b30
movq %rax, %r14
leaq 0x1e849(%rip), %rdi     # 0x3f380
callq 0x5280
movq %r14, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/manager.cpp
// Function: Manager::get_descripcion_estado_actual[abi:cxx11]()
string Manager::get_descripcion_estado_actual(){
    string descripcion=escena_actual->examine();
    descripcion+="\n";
    if(escena_actual->get_objetos_disponibles()!="")
    {
        descripcion+="Puedes ver : \n";
        descripcion+=escena_actual->get_objetos_disponibles();
    }
    return descripcion;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x150(%rsi), %rax
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq 0x48(%rax), %rsi
movq 0x50(%rax), %rdx
addq %rsi, %rdx
callq 0x1a0b6
leaq 0xabc1(%rip), %rsi      # 0x2d622
movq %rbx, %rdi
callq 0x5620
movq 0x150(%r14), %rsi
movq %rsp, %rdi
callq 0x1adb8
leaq 0xaba4(%rip), %rsi      # 0x2d623
movq %rsp, %r15
movq %r15, %rdi
callq 0x5110
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x10(%rsp), %r15
cmpq %r15, %rdi
je 0x22aa6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
testl %ebp, %ebp
je 0x22aef
leaq 0xb273(%rip), %rsi      # 0x2dd24
movq %rbx, %rdi
callq 0x5620
movq 0x150(%r14), %rsi
movq %rsp, %rdi
callq 0x1adb8
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x5120
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x22aef
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x22b21
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x22b21
jmp 0x22b1e
jmp 0x22b1e
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x22b35
movq (%r12), %rsi
incq %rsi
callq 0x5340
movq %r14, %rdi
callq 0x55c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/manager.cpp
// Function: Manager::clock()
void Manager::clock(){

    while(continuar_loop)
    {
        int itime = (int) tiempo;
        if( itime % (5*60) == 0 )
        {
            cout<<"\nHan pasado "<<tiempo<<" segundos desde el inicio del juego\n"<<">>>";
        }

        sleep(1); //detiene el hilo durante 1 segundo
        tiempo++;
    }
}

// Assembly:
cmpb $0x1, 0x30(%rdi)
jne 0x22c32
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x8(%rdi), %xmm0
movq 0x1742c(%rip), %r14     # 0x39fc0
leaq 0xb198(%rip), %r15      # 0x2dd33
leaq 0xb19e(%rip), %r12      # 0x2dd40
leaq 0xb085(%rip), %r13      # 0x2dc2e
cvttsd2si %xmm0, %eax
imull $0x962fc963, %eax, %eax # imm = 0x962FC963
addl $0x1b4e818, %eax        # imm = 0x1B4E818
rorl $0x2, %eax
cmpl $0xda740c, %eax         # imm = 0xDA740C
ja 0x22c02
movl $0xc, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x53a0
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0x5540
movq %rax, %rbp
movl $0x24, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x53a0
movl $0x3, %edx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x53a0
movl $0x1, %edi
callq 0x5270
movsd 0x8(%rbx), %xmm0
addsd 0xaf8f(%rip), %xmm0     # 0x2dba8
movsd %xmm0, 0x8(%rbx)
cmpb $0x0, 0x30(%rbx)
jne 0x22ba9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/objeto.cpp
// Function: Objeto::tirar()
void Objeto::tirar()
{
     cout<<endl<<descripcion_tirar<<endl;
     if(objeto_rel_tirar!=NULL)
     {
	  objeto_rel_tirar->set_value(string("visibility"),true);
     }
     else
     {
	  cout<<"ERROR: Null object"<<endl;
     }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq 0x154a3(%rip), %rbx     # 0x39fc0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x5230
movq 0x178(%r14), %rsi
movq 0x180(%r14), %rdx
movq %rax, %rdi
callq 0x53a0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5300
movsbl %al, %esi
movq %r15, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x5230
movq 0x198(%r14), %r14
testq %r14, %r14
je 0x24be2
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8514(%rip), %rsi      # 0x2d0b4
leaq 0x8517(%rip), %rdx      # 0x2d0be
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x19e74
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x249f8
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x24bd8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x9196(%rip), %rsi      # 0x2dd7f
movl $0x12, %edx
movq %rbx, %rdi
callq 0x53a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x5230
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x24c3f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x55c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/objeto.cpp
// Function: Objeto::set_tirable(Objeto*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Objeto::set_tirable(Objeto *objeto,string descrip_tirable)
{
     if(objeto!=NULL)
     {
	  this->objeto_rel_tirar=objeto;
	  objeto_rel_tirar->set_value(string("visibility"),false);
	  this->descripcion_tirar=descrip_tirable;
     }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rsi, %rsi
je 0x24cc1
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, 0x198(%rdi)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x843a(%rip), %rsi      # 0x2d0b4
leaq 0x843d(%rip), %rdx      # 0x2d0be
movq %rsp, %r12
movq %r12, %rdi
callq 0x19e74
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x249f8
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x24caf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
addq $0x178, %r14            # imm = 0x178
movq %r14, %rdi
movq %rbx, %rsi
callq 0x51d0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x24ce8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/objeto.cpp
// Function: bool Objeto::get_value<bool>(char const*)
bool Objeto::get_value<bool>(const char* pro)
{			 
    pBool pb=map_pBools[string(pro)];
    bool value=false; // TODO: Return false value by default 
    if(pb!=NULL)
    {
        value=pb->Value();
    }
#ifdef _DEBUG
    cout<<"get_value:"<<pro<<" valueProp:"<<value<<endl;
    cout<<"get_value:"<<pro<<" valueBool:"<<mapBool[string(pro)]<<endl;
#endif			 
    return value;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x19e2c
addq $0xc8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24e60
movq (%rax), %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24d3c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
testq %rbx, %rbx
je 0x24d46
movb 0x20(%rbx), %al
jmp 0x24d48
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24d6e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/objeto.cpp
// Function: int Objeto::get_value<int>(char const*)
int Objeto::get_value<int>(const char* pro)
{			 
    pInt pI=map_pInts[string(pro)];
    int value=0; 
    if(pI!=NULL)
    {
        value=pI->Value();
    }
#ifdef _DEBUG
    cout<<"get_value:"<<pro<<" valueProp:"<<value<<endl;
    cout<<"get_value:"<<pro<<" valueInts:"<<map_pInts[string(pro)]<<endl;
#endif			 
    return value;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x19e2c
addq $0x128, %rbx            # imm = 0x128
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24fd4
movq (%rax), %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24dc2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
testq %rbx, %rbx
je 0x24dcc
movl 0x20(%rbx), %eax
jmp 0x24dce
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24df4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/operaciones.cpp
// Function: Ayuda::execute()
void Ayuda::execute(){

    cout<<"Comandos disponibles:"<<endl;
				 
    for(vector<string>::iterator it=v_comandos.begin();
        it!=v_comandos.end();
        it++)
    {
        cout<<*it<<" ";
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x146ee(%rip), %r14     # 0x39fc0
leaq 0x84be(%rip), %rsi      # 0x2dd97
movl $0x15, %edx
movq %r14, %rdi
callq 0x53a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5300
movsbl %al, %esi
movq %r14, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x5230
movq 0x28(%rbx), %r12
cmpq 0x30(%rbx), %r12
je 0x25950
movq 0x146a2(%rip), %r14     # 0x39fc0
leaq 0x8ceb(%rip), %r15      # 0x2e610
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x53a0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x53a0
addq $0x20, %r12
cmpq 0x30(%rbx), %r12
jne 0x25925
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/operaciones.cpp
// Function: Ver::execute()
void Ver::execute(){

    Logger::instance().log("Entering into Ver::execute() method ", Logger::kLogLevelInfo);

    cout<<"escenario actual address: "<<escena_actual<<endl;
    //cout<<escena_actual->
        
        
    string descripcion=(*escena_actual)->examine();
    descripcion+="\n";
    if((*escena_actual)->get_objetos_disponibles()!="")
    {
        descripcion+="Puedes ver los siguiente: ";
        descripcion+=(*escena_actual)->get_objetos_disponibles();
    }
    cout<<Color::cyan<<descripcion<<Color::def;	 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x20ab0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x842c(%rip), %rsi      # 0x2ddad
leaq 0x8449(%rip), %rdx      # 0x2ddd1
leaq 0x8(%rsp), %rdi
callq 0x19e74
leaq 0x1997f(%rip), %rdx     # 0x3f318
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x20c92
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x259bd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq 0x145fc(%rip), %r14     # 0x39fc0
leaq 0x8407(%rip), %rsi      # 0x2ddd2
movl $0x1a, %edx
movq %r14, %rdi
callq 0x53a0
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x5290
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5300
movsbl %al, %esi
movq %r14, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x5230
movq 0x28(%rbx), %rax
movq (%rax), %rax
leaq 0x8(%rsp), %r14
movq %r15, (%r14)
movq 0x48(%rax), %rsi
movq 0x50(%rax), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x1a0b6
leaq 0x7beb(%rip), %rsi      # 0x2d622
movq %r14, %rdi
callq 0x5620
movq 0x28(%rbx), %rax
movq (%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1adb8
leaq 0x7bcc(%rip), %rsi      # 0x2d623
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x5110
movl %eax, %ebp
movq (%r14), %rdi
leaq 0x38(%rsp), %r14
cmpq %r14, %rdi
je 0x25a80
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5340
testl %ebp, %ebp
je 0x25ad1
leaq 0x8362(%rip), %rsi      # 0x2dded
leaq 0x8(%rsp), %rdi
callq 0x5620
movq 0x28(%rbx), %rax
movq (%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1adb8
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x5120
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x25ad1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5340
movq 0x144e8(%rip), %rdi     # 0x39fc0
leaq 0x1bbf1(%rip), %rsi     # 0x416d0
callq 0x276b8
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0x53a0
leaq 0x1bbc3(%rip), %rsi     # 0x416c0
movq %rax, %rdi
callq 0x276b8
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x25b1c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x25b51
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x25b51
jmp 0x25b4e
jmp 0x25b4e
jmp 0x25b4e
movq %rax, %rbx
jmp 0x25b68
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x25b68
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_22_main.cc
// Function: runQueries(std::basic_ifstream<char, std::char_traits<char>>&)
void runQueries(ifstream& infile)
{
	// infile is an ifstream that is the file we want to query
	TextQuery tq(infile);  // store the file and build the query map
	// iterate with the user: prompt for a word to find and print results
	while (true) {
		cout << "enter word to look for, or q to quit: ";
		string s;
		// stop if we hit end-of-file on the input or if a 'q' is entered
		if (!(cin >> s) || s == "q")
			break;
		// run the query and print the results
		print(cout, tq.query(s)) << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rsi
leaq -0xc8(%rbp), %rdi
callq 0x2868
leaq -0x38(%rbp), %r15
movq 0x4b4e(%rip), %r14      # 0x6fc8
leaq -0x48(%rbp), %r13
leaq -0x88(%rbp), %rbx
movq %rbx, %r12
movl $0x26, %edx
movq %r14, %rdi
leaq 0x1b6d(%rip), %rsi      # 0x4004
callq 0x21d0
movq %r15, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq 0x4b25(%rip), %rdi      # 0x6fd8
movq %r13, %rsi
callq 0x2200
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x24d0
xorl %ebx, %ebx
jmp 0x2564
movq %r13, %rdi
leaq 0x1b51(%rip), %rsi      # 0x402b
callq 0x2080
testl %eax, %eax
je 0x24c9
movq %rbx, %rdi
leaq -0xc8(%rbp), %rsi
movq %r13, %rdx
callq 0x2be8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x303a
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2538
callq 0x2748
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x2546
callq 0x2748
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x2562
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21a0
movb $0x1, %bl
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x2579
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
testb %bl, %bl
movq %r12, %rbx
jne 0x2488
leaq -0xb8(%rbp), %rbx
movq %rbx, %rdi
callq 0x27c2
movq -0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x25a1
callq 0x2748
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25cb
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x26d4
jmp 0x25ce
movq %rax, %rbx
jmp 0x25e3
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x25e3
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
leaq -0xc8(%rbp), %rdi
callq 0x271e
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/TextQuery.cc
// Function: TextQuery::display_map()
void TextQuery::display_map()
{
	// auto iter = wm.cbegin();
	// auto iter_end = wm.cend();
	for (auto iter = wm.cbegin(); iter != wm.cend(); ++iter) {
		cout << "word: " << iter->first << " {";
		// fetch location vector as a cosnt reference to avoid coping it
		auto text_locs = iter->second;
		auto loc_iter = text_locs->cbegin();
		auto loc_iter_end = text_locs->cend();
		// print all line number for this word
		while (loc_iter != loc_iter_end) {
			cout << *loc_iter;

			if (++loc_iter != loc_iter_end)
				cout << ", ";
		}
		cout << "}\n";
	}

	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x28(%rdi), %r14
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
cmpq %rdi, %r14
je 0x2fe3
movq 0x40c5(%rip), %r15      # 0x6fc8
leaq 0x113c(%rip), %r13      # 0x4046
movl $0x6, %edx
movq %r15, %rdi
leaq 0x1123(%rip), %rsi      # 0x403c
callq 0x21d0
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r15, %rdi
callq 0x21d0
movl $0x2, %edx
movq %rax, %rdi
leaq 0x1106(%rip), %rsi      # 0x4043
callq 0x21d0
movq 0x40(%r14), %r12
movq 0x48(%r14), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x2f70
movq 0x4066(%rip), %rax      # 0x6fc0
cmpb $0x0, (%rax)
je 0x2f68
movq -0x30(%rbp), %rax
incl 0x8(%rax)
jmp 0x2f70
movq -0x30(%rbp), %rax
lock
incl 0x8(%rax)
movq 0x18(%r12), %rbx
addq $0x8, %r12
cmpq %r12, %rbx
je 0x2fac
movq 0x20(%rbx), %rsi
movq %r15, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x21e0
cmpq %r12, %rax
je 0x2fac
movq %rax, %rbx
movl $0x2, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x21d0
jmp 0x2f7e
movl $0x2, %edx
movq %r15, %rdi
leaq 0x108e(%rip), %rsi      # 0x4049
callq 0x21d0
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x2fce
callq 0x2748
movq %r14, %rdi
callq 0x21e0
movq %rax, %r14
cmpq -0x38(%rbp), %rax
jne 0x2f0a
movq 0x3fde(%rip), %rbx      # 0x6fc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2110
jmp 0x3021
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x3032
callq 0x2748
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/TextQuery.cc
// Function: print(std::ostream&, QueryResult const&)
ostream& print(ostream& os, const QueryResult& qr)
{
	os << qr.sought << " occurs " << qr.lines->size() << " "
	   << "time(s)" << endl;

	// print each line in chich the word appeared
	for (auto num : *qr.lines) {
		os << "\t(line " << num + 1 << ") "
		   << *(qr.file->begin() + num) << endl;
	}

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x21d0
movq %rax, %r15
leaq 0xfe8(%rip), %rsi       # 0x404c
movl $0x8, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x20(%r14), %rax
movq 0x28(%rax), %rsi
movq %r15, %rdi
callq 0x2100
movq %rax, %r15
leaq 0xfdb(%rip), %rsi       # 0x4066
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
leaq 0xfb6(%rip), %rsi       # 0x4055
movl $0x7, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq %r14, -0x30(%rbp)
movq 0x20(%r14), %r13
movq 0x18(%r13), %r15
addq $0x8, %r13
cmpq %r13, %r15
je 0x3185
movq 0x20(%r15), %r14
movl $0x7, %edx
movq %rbx, %rdi
leaq 0xf5e(%rip), %rsi       # 0x405d
callq 0x21d0
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
callq 0x2100
movq %rax, %r12
movl $0x2, %edx
movq %rax, %rdi
leaq 0xf43(%rip), %rsi       # 0x4065
callq 0x21d0
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rax
shlq $0x5, %r14
movq (%rax,%r14), %rsi
movq 0x8(%rax,%r14), %rdx
movq %r12, %rdi
callq 0x21d0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq %r15, %rdi
callq 0x21e0
movq %rax, %r15
cmpq %r13, %rax
jne 0x30ec
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Cicko[P]Ram-Machine/Program.cpp
// Function: Program::readFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Program::readFile (string fileName){
  ifstream file;
  string fileData = "";
  fileName_ = fileName;
  file.open (fileName.c_str());
  if (file.is_open()) {
    while (!file.eof()) {
      string temp;
      getline (file,temp);
      fileData += temp + "\n";
    }
    file.close();
  }
  else {
    cerr << "El fichero no existe" << endl;
  }
  return fileData;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
callq 0x53c0
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
leaq 0x12ae8(%rip), %rdx     # 0x191ce
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x807e
addq $0x30, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x51e0
movq (%r14), %rsi
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x5230
leaq 0xc8(%rsp), %rdi
callq 0x50c0
testb %al, %al
je 0x680e
movq %r12, 0x8(%rsp)
movq 0x50(%rsp), %rax
movq -0x18(%rax), %rcx
testb $0x2, 0x70(%rsp,%rcx)
jne 0x67fd
addq $-0x18, %rax
leaq 0x20(%rsp), %rbp
leaq 0x40(%rsp), %r15
leaq 0x30(%rsp), %r12
leaq 0x12a70(%rip), %r13     # 0x191cd
movq %rbp, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movq (%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5340
movsbl %al, %edx
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x55f0
movq %r15, 0x30(%rsp)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x63c2
movq %r12, %rdi
movq %r13, %rsi
callq 0x5630
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x5100
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x67d6
callq 0x5330
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x67e5
callq 0x5330
movq 0x50(%rsp), %rax
movq -0x18(%rax), %rcx
addq $-0x18, %rax
testb $0x2, 0x70(%rsp,%rcx)
je 0x675d
leaq 0x50(%rsp), %rdi
movq 0x8(%rsp), %r12
callq 0x50a0
jmp 0x6854
movq 0x1c7db(%rip), %r14     # 0x22ff0
leaq 0x12b2c(%rip), %rsi     # 0x19348
movl $0x14, %edx
movq %r14, %rdi
callq 0x53d0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x5340
movsbl %al, %esi
movq 0x1c7a9(%rip), %rdi     # 0x22ff0
callq 0x5040
movq %rax, %rdi
callq 0x5270
leaq 0x50(%rsp), %rdi
callq 0x50d0
movq %rbx, %rax
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x68bb
movq %r12, 0x8(%rsp)
movq %rax, %r14
jmp 0x68ac
jmp 0x689a
jmp 0x6886
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x689d
callq 0x5330
jmp 0x689d
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x68ac
callq 0x5330
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x68bb
callq 0x5330
leaq 0x50(%rsp), %rdi
callq 0x50d0
movq %r14, %rdi
callq 0x55c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Cicko[P]Ram-Machine/Program.cpp
// Function: Program::getTagFromString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Program::getTagFromString(string data) {
    string result = "noTag";
    //cout << "Analize string for tag : " << endl << data << endl;
    if (data.find(":") != string::npos) {                                    // If there is a tag
      for (int i = 0; i < data.size(); i++) {
        if (data[i] == ':'){                                              // When we detect Tag
          int it = i;                                                // we create iterator to go backwards
          string tag;
          while(data[--it] == ' ' || data[it] == '\t' || data[it] == ':');                         // until we search any character to save the tag name
          while(data[it] != ' '  &&                                          // then we continue saving characters backwards until we reach space again
                data[it] != '\t' && it >= 0) {                                          // or tabulator.
             //cout << "We push : data[" << it << "] = " << data[it] << endl;
              tag.push_back(data[it--]);
          }
          reverse(tag.rbegin(), tag.rend());
          result = tag;
        }
      }
    }
    return result;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
leaq 0x10(%rdi), %rax
movq %rax, 0x30(%rsp)
movq %rax, (%rdi)
leaq 0x11c82(%rip), %rsi     # 0x19398
leaq 0x11c80(%rip), %rdx     # 0x1939d
movq %rdi, 0x8(%rsp)
callq 0x807e
leaq 0x12dde(%rip), %rsi     # 0x1a50c
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x55b0
cmpq $-0x1, %rax
je 0x7834
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x7834
movq $-0x1, %rbx
leaq 0x20(%rsp), %rbp
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
movabsq $0x400000100000200, %r13 # imm = 0x400000100000200
movq (%r14), %rcx
cmpb $0x3a, (%rcx,%r12)
jne 0x7825
movq %rbp, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movq %rbx, %rbp
movzbl (%rcx,%rbp), %eax
cmpq $0x3a, %rax
ja 0x77b9
btq %rax, %r13
jae 0x77b9
decq %rbp
jmp 0x7796
decq %rbp
movsbl %al, %esi
movq %r15, %rdi
callq 0x52f0
movq (%r14), %rax
movb (%rax,%rbp), %al
cmpb $0x20, %al
je 0x77cc
testq %rbp, %rbp
js 0x77cc
cmpb $0x9, %al
jne 0x77ab
movq 0x18(%rsp), %rax
cmpq $0x2, %rax
jl 0x7800
movq 0x10(%rsp), %rcx
addq %rcx, %rax
addq $0x2, %rcx
movb -0x1(%rax), %dl
movb -0x2(%rcx), %sil
movb %sil, -0x1(%rax)
decq %rax
movb %dl, -0x2(%rcx)
leaq 0x1(%rcx), %rdx
cmpq %rax, %rcx
movq %rdx, %rcx
jb 0x77e3
movq 0x8(%rsp), %rdi
movq %r15, %rsi
leaq 0x20(%rsp), %rbp
callq 0x51e0
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7821
callq 0x5330
movq 0x8(%r14), %rax
incq %r12
incq %rbx
cmpq %r12, %rax
ja 0x7772
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x784a
movq %rax, %r14
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x7861
callq 0x5330
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq 0x30(%rsp), %rdi
je 0x7875
callq 0x5330
movq %r14, %rdi
callq 0x55c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Cicko[P]Ram-Machine/./Instruction.h
// Function: Instruction::Instruction()
Instruction () {
    line_ = -1;
    tag_ = "";
    op_ = "";
    type_ = '\0';
    operand_ = "";
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, (%rsp)
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r14
leaq 0x38(%rdi), %rbp
movq %rbp, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x50(%rdi), %r15
leaq 0x60(%rdi), %r13
movq %r13, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movb %al, 0x60(%rdi)
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
leaq 0x1141c(%rip), %rcx     # 0x191ce
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x5520
movq 0x30(%r12), %rdx
leaq 0x11401(%rip), %rcx     # 0x191ce
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x5520
movb $0x0, 0x48(%r12)
movq 0x58(%r12), %rdx
leaq 0x113e2(%rip), %rcx     # 0x191ce
movq %r15, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x5520
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x7e18
callq 0x5330
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x7e25
callq 0x5330
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x7e33
callq 0x5330
movq %r12, %rdi
callq 0x55c0
nop