LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: Matrix::transpose()
Matrix transpose(){
			Matrix N;
			int i,j;
			vector<double> row;
			for(i=0;i<3;i++){
				row.clear();
				for(j=0;j<3;j++){	// ith column of matrix
					row.push_back(e[j][i]);
				};
				N.e.push_back(row);	// is made into ith row of result
			};
			return(N);
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsp, %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
xorl %r12d, %r12d
cmpq $0x3, %r12
je 0x7c6a
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x7c32
movq %rax, 0x8(%rsp)
leaq (,%r12,8), %r13
xorl %ebp, %ebp
cmpq $0x48, %rbp
je 0x7c5a
movq (%r14), %rax
movq (%rax,%rbp), %rsi
addq %r13, %rsi
movq %r15, %rdi
callq 0x758c
addq $0x18, %rbp
jmp 0x7c3c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7560
incq %r12
jmp 0x7c1c
movq %rsp, %rdi
callq 0x7b58
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7c86
movq %rax, %r14
movq %rsp, %rdi
callq 0x7b58
movq %rbx, %rdi
callq 0x78f0
movq %r14, %rdi
callq 0x23c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/rcolomina[P]the_charmed_house/src/abstract_creator.cpp
// Function: AbstractGameCreator::getInfoList[abi:cxx11](TiXmlNode* const&, InfoClass const&)
vector<std::string> AbstractGameCreator::getInfoList(const pNode &parent,const InfoClass &info)
{

     std::vector<std::string> output;
     pNode child = 0;
     while((child = parent->IterateChildren(child)))
     {
	  string value_text;
	  if(info==Name)
	       value_text = child->Value();
	  else if(info==Text){
	       pElem temp = child->ToElement();
	       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 %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x18(%rsp), %rbp
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq (%r15), %rdi
movq %r13, %rsi
callq 0x1d35e
movq %rax, %r13
testq %rax, %rax
je 0x1206e
movq %rbp, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movl (%r14), %eax
cmpl $0x1, %eax
je 0x1203c
testl %eax, %eax
jne 0x12059
movq 0x38(%r13), %rsi
addq $0x10, %rsi
movq %r12, %rdi
callq 0x5600
jmp 0x12059
movq (%r13), %rax
movq %r13, %rdi
callq *0x58(%rax)
movq %rax, %rdi
callq 0x1de4a
movq %r12, %rdi
movq %rax, %rsi
callq 0x5600
movq %rbx, %rdi
movq %r12, %rsi
callq 0x121bc
movq %r12, %rdi
callq 0x5638
jmp 0x11ffb
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12087
movq %rax, %r14
jmp 0x12094
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5638
movq %rbx, %rdi
callq 0x121e8
movq %r14, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O2/rcolomina[P]the_charmed_house/src/abstract_creator.cpp
// Function: AbstractGameCreator::searchForGame(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
pElem AbstractGameCreator::searchForGame(const string &name){
     // 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 $0x8, %rdi
leaq 0xef4b(%rip), %rsi      # 0x21004
callq 0x1d2e6
testq %rax, %rax
je 0x12100
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xef8f(%rip), %rdx      # 0x21061
movq %rsp, %r14
movq %r14, %rdi
callq 0x1edb8
movq (%rbx), %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1edb8
movq %rbx, %rdi
callq 0x1220a
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0xef03(%rip), %rdi      # 0x2100a
leaq 0xef01(%rip), %rsi      # 0x2100f
leaq 0xef13(%rip), %rcx      # 0x21028
pushq $0x1a
popq %rdx
callq 0x5210
nop
// File: /workspace/github_cpp_makefile_star2_O2/rcolomina[P]the_charmed_house/src/abstract_creator.cpp
// Function: AbstractGameCreator::searchForId(TiXmlElement* const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
pElem AbstractGameCreator::searchForId(const pElem &parent,const std::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 0x1d35e
testq %rax, %rax
je 0x12195
movq %rax, %rbx
movq (%rax), %rax
movq %rbx, %rdi
callq *0x58(%rax)
movq %rax, %r12
movq %rax, %rdi
leaq 0xef2b(%rip), %rsi      # 0x2108d
callq 0x1d7fa
movq %r13, %rdi
movq %rax, %rsi
leaq 0x7(%rsp), %rdx
callq 0x12230
movq %r14, %rdi
movq %r13, %rsi
callq 0x5050
movl %eax, %ebp
movq %r13, %rdi
callq 0x5638
testl %ebp, %ebp
jne 0x12139
movq %r12, %rax
jmp 0x12197
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5638
movq %rbx, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/rcolomina[P]the_charmed_house/src/distance.cpp
// Function: DistLevenshtein::LevenshteinDistance(char const*, int, char const*, int)
int DistLevenshtein::LevenshteinDistance(const char *s, const int len_s, const char *t, const int len_t)
{
    int cost;

    /* base case: empty strings */
    if (len_s == 0)
        return len_t;
    if (len_t == 0)
        return len_s;

    /* test if last characters of the strings match */
    if (s[len_s-1] == t[len_t-1])
        cost = 0;
    else
        cost = 1;

    /* return minimum of delete char from s, delete char from t, and delete char from both */
    return min(this->LevenshteinDistance(s,len_s-1,t,len_t)+1, min(
                   this->LevenshteinDistance(s,len_s,t,len_t-1)+1,
                   this->LevenshteinDistance(s,len_s-1,t,len_t-1)+cost));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %edx, %edx
je 0x12bc1
movl %edx, %ebp
testl %r8d, %r8d
je 0x12bbe
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq %ebp, %r12
movb -0x1(%rsi,%r12), %al
decq %r12
movslq %r8d, %rcx
leaq -0x1(%rcx), %rdx
movq %rdx, 0x10(%rsp)
xorl %edx, %edx
cmpb -0x1(%rbx,%rcx), %al
setne %dl
movl %edx, 0x4(%rsp)
movl %r12d, %edx
movq %rbx, %rcx
callq 0x12b14
movl %eax, %r13d
incl %r13d
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
movq 0x10(%rsp), %rbp
movl %ebp, %r8d
callq 0x12b14
movq %rax, 0x8(%rsp)
incl %eax
movl %eax, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x12b14
addl 0x4(%rsp), %eax
cmpl 0x8(%rsp), %eax
cmovgl (%rsp), %eax
cmpl %r13d, %eax
cmovgel %r13d, %eax
jmp 0x12bc4
movl %ebp, %r8d
movl %r8d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/rcolomina[P]the_charmed_house/src/escenario.cpp
// Function: Escenario::get_existe_objeto_escenario(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Escenario::get_existe_objeto_escenario(string nombre){
	 
     for(auto it=objetos.begin();
	 it!=objetos.end();
	 it++)
     {
	  bool matchName = (it->first==nombre);
	  bool isVisible =it->second->get_value<bool>("visibility");
			 
	  if(matchName and isVisible)
	       return true;
			 
//	 		 if(it->first==nombre and it->second->get_value<bool>("visibility"))
//					return true;
     }
     return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x100(%rdi), %r15
addq $0xf0, %rbx
leaq 0xe136(%rip), %r12      # 0x210b9
cmpq %rbx, %r15
je 0x12fb8
leaq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0x136b7
movl %eax, %ebp
movq 0x40(%r15), %rdi
movq %r12, %rsi
callq 0x1a8f8
testb %bpl, %bpl
je 0x12fab
testb %al, %al
jne 0x12fb8
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
jmp 0x12f83
cmpq %rbx, %r15
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/rcolomina[P]the_charmed_house/src/escenario.cpp
// Function: Escenario::get_objetos_disponibles[abi:cxx11]()
string Escenario::get_objetos_disponibles(){

     string lista_objetos="";
     //Recorrer map
     for(map<string,Objeto*>::iterator it=objetos.begin();
	 it!=objetos.end();it++)
     {
	  if(it!=objetos.begin())
	  {
	       lista_objetos+=",";
	  }	  
	       
	  if(it->second->get_value<bool>("visibility"))
	       lista_objetos+=it->first;
     }
     if(lista_objetos=="")
	  return string("");
     else
	  return lista_objetos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0xe656(%rip), %rsi      # 0x2163b
leaq 0x18(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x12230
movq 0x100(%r14), %r13
leaq 0xf0(%r14), %rbx
leaq 0xe0ad(%rip), %r12      # 0x210b9
leaq 0xe60b(%rip), %rbp      # 0x2161e
cmpq %rbx, %r13
je 0x13055
cmpq 0x100(%r14), %r13
je 0x1302c
movq %r15, %rdi
movq %rbp, %rsi
callq 0x55f0
movq 0x40(%r13), %rdi
movq %r12, %rsi
callq 0x1a8f8
testb %al, %al
je 0x13048
leaq 0x20(%r13), %rsi
movq %r15, %rdi
callq 0x5620
movq %r13, %rdi
callq 0x5240
movq %rax, %r13
jmp 0x13013
leaq 0xe5df(%rip), %rsi      # 0x2163b
leaq 0x18(%rsp), %rdi
callq 0x136e0
testb %al, %al
je 0x13085
leaq 0xe5ca(%rip), %rsi      # 0x2163b
leaq 0xf(%rsp), %rdx
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x12230
jmp 0x130cc
movq 0x10(%rsp), %rbx
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0x130ad
movq %rdx, (%rbx)
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x130b3
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
movb $0x0, 0x28(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x5638
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x130ea
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5638
movq %rbx, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/rcolomina[P]the_charmed_house/src/escenario.cpp
// Function: Escenario::pintar()
void Escenario::pintar(){

     fstream fs;
     string fileImagetext=pathFileImageText;
     fs.open(fileImagetext.c_str(),fstream::in);
     string line;
     if(fs.is_open()){
	  while(getline(fs,line)){
	       cout<<line<<endl;
	  }
	  fs.close(); 
     }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
callq 0x53c0
addq $0x118, %rbx            # imm = 0x118
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x5430
movq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x52f0
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0xc0(%rsp), %rdi
callq 0x50f0
testb %al, %al
je 0x1326a
leaq 0x40(%rsp), %rbx
movq %rsp, %r14
movq 0x1bd86(%rip), %r15     # 0x2efb8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x50d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x13260
movq %r15, %rdi
movq %r14, %rsi
callq 0x52d0
movq %rax, %rdi
callq 0x51a0
jmp 0x13232
leaq 0x40(%rsp), %rdi
callq 0x5090
movq %rsp, %rdi
callq 0x5638
leaq 0x20(%rsp), %rdi
callq 0x5638
leaq 0x40(%rsp), %rdi
callq 0x50e0
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1329f
movq %rax, %rbx
jmp 0x132aa
movq %rax, %rbx
jmp 0x132b4
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5638
leaq 0x20(%rsp), %rdi
callq 0x5638
leaq 0x40(%rsp), %rdi
callq 0x50e0
movq %rbx, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe2ee(%rip), %rsi      # 0x2163b
leaq 0x8(%rsp), %rdx
callq 0x12230
leaq 0x88(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x13956
leaq 0x10(%rsp), %r13
movq 0x10(%r13), %r15
addq $0xb8, %r14
leaq 0x38(%rsp), %r12
cmpq %r13, %r15
je 0x133d0
leaq 0x20(%r15), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x5430
movq %r14, %rdi
movq %r12, %rsi
callq 0x137c4
cmpb $0x1, (%rax)
jne 0x133bb
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5620
movq %rbx, %rdi
leaq 0xf282(%rip), %rsi      # 0x22638
callq 0x55f0
movq %r12, %rdi
callq 0x5638
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
jmp 0x1337d
leaq 0x8(%rsp), %rdi
callq 0x138f2
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1340d
movq %rax, %r14
jmp 0x13403
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x5638
leaq 0x8(%rsp), %rdi
callq 0x138f2
movq %rbx, %rdi
callq 0x5638
movq %r14, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x48, %rsi
callq 0x5430
leaq 0xe1fc(%rip), %rsi      # 0x2163a
movq %rbx, %rdi
callq 0x55f0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x12fc8
leaq 0xe1e1(%rip), %rsi      # 0x2163b
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x136ed
movl %eax, %ebp
movq %r15, %rdi
callq 0x5638
testb %bpl, %bpl
je 0x134a9
leaq 0xe1a3(%rip), %rsi      # 0x21620
movq %rbx, %rdi
callq 0x55f0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x12fc8
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5620
leaq 0x8(%rsp), %rdi
callq 0x5638
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5638
jmp 0x134cd
jmp 0x134ca
jmp 0x134ca
movq %rax, %r14
movq %rbx, %rdi
callq 0x5638
movq %r14, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
addq $0x88, %rsi
leaq 0x8(%rsp), %rdi
callq 0x13956
leaq 0x10(%rsp), %r12
movq 0x10(%r12), %r15
leaq 0xf11a(%rip), %r14      # 0x22638
cmpq %r12, %r15
je 0x13547
leaq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x5620
movq %rbx, %rdi
movq %r14, %rsi
callq 0x55f0
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
jmp 0x1351e
leaq 0x8(%rsp), %rdi
callq 0x138f2
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x13572
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x138f2
movq %rbx, %rdi
callq 0x5638
movq %r14, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x14b19
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x5430
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1330c
leaq 0x8(%rsp), %rdi
callq 0x5638
addq $0x30, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5430
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xcb1d(%rip), %rdi      # 0x2163d
leaq 0xcb22(%rip), %rsi      # 0x21649
leaq 0xcb29(%rip), %rcx      # 0x21657
pushq $0x6
popq %rdx
callq 0x5210
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5638
movq %rbx, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %r13d, %r13d
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %r12
movq %r14, %rdi
movq %r13, %rsi
callq 0x1d35e
movq %rax, %r13
testq %rax, %rax
je 0x161da
movq 0x38(%r13), %rsi
addq $0x10, %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x12230
movq %rbx, %rdi
movq %r15, %rsi
callq 0x121bc
movq %r15, %rdi
callq 0x5638
jmp 0x1619f
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x161fc
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5638
jmp 0x161ff
movq %rax, %r14
movq %rbx, %rdi
callq 0x121e8
movq %r14, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %r13d, %r13d
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %r12
movq %r14, %rdi
movq %r13, %rsi
callq 0x1d35e
movq %rax, %r13
testq %rax, %rax
je 0x16283
movq (%r13), %rax
movq %r13, %rdi
callq *0x58(%rax)
movq %rax, %rdi
callq 0x1de4a
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x12230
movq %rbx, %rdi
movq %r15, %rsi
callq 0x121bc
movq %r15, %rdi
callq 0x5638
jmp 0x1623b
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x162a9
jmp 0x162a9
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5638
jmp 0x162ac
jmp 0x162a9
movq %rax, %r14
movq %rbx, %rdi
callq 0x121e8
movq %r14, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xad33(%rip), %rsi      # 0x21004
callq 0x1d2e6
testq %rax, %rax
je 0x16318
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xad77(%rip), %rdx      # 0x21061
movq %rsp, %r14
movq %r14, %rdi
callq 0x1edb8
movq (%rbx), %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1edb8
movq %rbx, %rdi
callq 0x1220a
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0xaceb(%rip), %rdi      # 0x2100a
leaq 0xb5d1(%rip), %rsi      # 0x218f7
leaq 0xb5da(%rip), %rcx      # 0x21907
movl $0x8f, %edx
callq 0x5210
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1d35e
testq %rax, %rax
je 0x163af
movq %rax, %rbx
movq (%rax), %rax
movq %rbx, %rdi
callq *0x58(%rax)
movq %rax, %r12
movq %rax, %rdi
leaq 0xad11(%rip), %rsi      # 0x2108d
callq 0x1d7fa
movq %r13, %rdi
movq %rax, %rsi
leaq 0x7(%rsp), %rdx
callq 0x12230
movq %r14, %rdi
movq %r13, %rsi
callq 0x5050
movl %eax, %ebp
movq %r13, %rdi
callq 0x5638
testl %ebp, %ebp
jne 0x16353
movq %r12, %rax
jmp 0x163b1
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5638
movq %rbx, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xab49(%rip), %rsi      # 0x2163b
movq %rsp, %r15
movq %r15, %rdx
callq 0x12230
movq 0x18(%r14), %r13
addq $0x8, %r14
leaq 0xbb2c(%rip), %r12      # 0x22638
cmpq %r14, %r13
je 0x16b4c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x55f0
movq 0x40(%r13), %rsi
addq $0x28, %rsi
movq %r15, %rdi
callq 0x5430
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5620
movq %r15, %rdi
callq 0x5638
movq %r13, %rdi
callq 0x5240
movq %rax, %r13
jmp 0x16b0c
leaq 0xaae8(%rip), %rsi      # 0x2163b
movq %rbx, %rdi
callq 0x136e0
testb %al, %al
je 0x16b6e
leaq 0xaf1c(%rip), %rsi      # 0x21a82
movq %rbx, %rdi
callq 0x5600
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x16b83
jmp 0x16b83
movq %rax, %r14
jmp 0x16b93
movq %rax, %r14
movq %rsp, %rdi
callq 0x5638
movq %rbx, %rdi
callq 0x5638
movq %r14, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x16bd9
leaq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0x136b7
testb %al, %al
jne 0x16bd9
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
jmp 0x16bb7
cmpq %rbx, %r15
setne %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
addq $0x8, %rbx
leaq 0xae95(%rip), %r15      # 0x21a9e
cmpq %rbx, %r14
je 0x16c2b
movq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0x1a8f8
testb %al, %al
jne 0x16c2b
movq %r14, %rdi
callq 0x5240
movq %rax, %r14
jmp 0x16c09
cmpq %rbx, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %ebx, %ebx
leaq 0xae4a(%rip), %r12      # 0x21a9e
cmpq %r14, %r15
je 0x16c7a
movq 0x40(%r15), %rdi
movq %r12, %rsi
callq 0x1a8f8
testb %al, %al
jne 0x16c76
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
jmp 0x16c54
movq 0x40(%r15), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
addq $0x8, %rbx
leaq 0xb272(%rip), %r15      # 0x21f13
cmpq %rbx, %r14
je 0x16cc3
movq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0x1a8f8
testb %al, %al
jne 0x16cc3
movq %r14, %rdi
callq 0x5240
movq %rax, %r14
jmp 0x16ca1
cmpq %rbx, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %ebx, %ebx
leaq 0xb227(%rip), %r12      # 0x21f13
cmpq %r14, %r15
je 0x16d12
movq 0x40(%r15), %rdi
movq %r12, %rsi
callq 0x1a8f8
testb %al, %al
jne 0x16d0e
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
jmp 0x16cec
movq 0x40(%r15), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x179f0
leaq 0x1708a(%rip), %rax     # 0x2e4d8
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq (%r14), %rsi
xorl %edx, %edx
callq 0x1e062
testb %al, %al
je 0x1746b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x60(%rbx), %rsi
addq $0x10, %rsi
leaq 0xa299(%rip), %rdi      # 0x21713
xorl %eax, %eax
callq 0x5070
pushq $0x1
popq %rdi
callq 0x53d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x17a04
movq %r14, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1c98a(%rip), %al      # 0x343b0
testb %al, %al
je 0x17a75
leaq 0x1c94f(%rip), %rdi     # 0x34380
callq 0x17cec
movq 0x1c93b(%rip), %rbx     # 0x34378
testq %rbx, %rbx
jne 0x17a5e
movl $0x208, %edi            # imm = 0x208
callq 0x5330
movq %rax, %rbx
movq %rax, %rdi
callq 0x17b5a
movq %rbx, 0x1c91a(%rip)     # 0x34378
leaq 0x1c91b(%rip), %rdi     # 0x34380
callq 0x5280
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1c934(%rip), %rdi     # 0x343b0
callq 0x55c0
testl %eax, %eax
je 0x17a2a
leaq 0x4e(%rip), %rdi        # 0x17ada
leaq 0x1c915(%rip), %rsi     # 0x343a8
leaq 0x1788e(%rip), %rdx     # 0x2f328
callq 0x52c0
leaq 0x1c90a(%rip), %rdi     # 0x343b0
callq 0x5200
jmp 0x17a2a
movq %rax, %r14
movl $0x208, %esi            # imm = 0x208
movq %rbx, %rdi
callq 0x5340
jmp 0x17ac5
movq %rax, %r14
leaq 0x1c8b4(%rip), %rdi     # 0x34380
callq 0x5280
movq %r14, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x150(%rsi), %rsi
addq $0x48, %rsi
callq 0x5430
leaq 0x86cb(%rip), %rsi      # 0x2163a
movq %rbx, %rdi
callq 0x55f0
movq 0x150(%r14), %rsi
movq %rsp, %rdi
callq 0x12fc8
leaq 0x86ae(%rip), %rsi      # 0x2163b
movq %rsp, %rdi
callq 0x136ed
movl %eax, %ebp
movq %rsp, %rdi
callq 0x5638
testb %bpl, %bpl
je 0x18fd5
leaq 0x8d91(%rip), %rsi      # 0x21d3c
movq %rbx, %rdi
callq 0x55f0
movq 0x150(%r14), %rsi
movq %rsp, %rdi
callq 0x12fc8
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5620
movq %rsp, %rdi
callq 0x5638
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x18fe5
jmp 0x18ff4
movq %rax, %r14
movq %rsp, %rdi
callq 0x5638
jmp 0x18ff7
jmp 0x18ff4
movq %rax, %r14
movq %rbx, %rdi
callq 0x5638
movq %r14, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x12c, %r14d           # imm = 0x12C
leaq 0x8d08(%rip), %r15      # 0x21d4b
leaq 0x8d0e(%rip), %r12      # 0x21d58
leaq 0x8bf5(%rip), %r13      # 0x21c46
pushq $0x1
popq %rbp
cmpb $0x1, 0x30(%rbx)
jne 0x190b4
cvttsd2si 0x8(%rbx), %eax
cltd
idivl %r14d
testl %edx, %edx
jne 0x19099
movq 0x15f4a(%rip), %rdi     # 0x2efb8
movq %r15, %rsi
callq 0x5310
movsd 0x8(%rbx), %xmm0
movq %rax, %rdi
callq 0x5520
movq %rax, %rdi
movq %r12, %rsi
callq 0x5310
movq %rax, %rdi
movq %r13, %rsi
callq 0x5310
movl %ebp, %edi
callq 0x5270
movsd 0x8(%rbx), %xmm0
addsd 0x8b13(%rip), %xmm0     # 0x21bc0
movsd %xmm0, 0x8(%rbx)
jmp 0x19054
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x147dd(%rip), %rdi     # 0x2efb8
callq 0x51a0
leaq 0x178(%rbx), %rsi
movq %rax, %rdi
callq 0x52d0
movq %rax, %rdi
callq 0x51a0
movq 0x198(%rbx), %rbx
testq %rbx, %rbx
je 0x1a83c
leaq 0x68af(%rip), %rsi      # 0x210b9
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x12230
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a712
leaq 0x8(%rsp), %rdi
callq 0x5638
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x14775(%rip), %rdi     # 0x2efb8
leaq 0x7561(%rip), %rsi      # 0x21dab
callq 0x5310
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x51a0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5638
movq %rbx, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x1a8d6
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, 0x198(%rdi)
leaq 0x681e(%rip), %rsi      # 0x210b9
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x12230
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x1a712
leaq 0x8(%rsp), %rdi
callq 0x5638
addq $0x178, %r14            # imm = 0x178
movq %r14, %rdi
movq %rbx, %rsi
callq 0x51d0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5638
movq %rbx, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x12230
addq $0xc8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1aa1c
movq (%rax), %rbx
leaq 0x8(%rsp), %rdi
callq 0x5638
testq %rbx, %rbx
je 0x1a93d
movb 0x20(%rbx), %al
jmp 0x1a93f
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5638
movq %rbx, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x12230
addq $0x128, %rbx            # imm = 0x128
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ab6a
movq (%rax), %rbx
leaq 0x8(%rsp), %rdi
callq 0x5638
testq %rbx, %rbx
je 0x1a9a1
movl 0x20(%rbx), %eax
jmp 0x1a9a3
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5638
movq %rbx, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13946(%rip), %r14     # 0x2efb8
leaq 0x674a(%rip), %rsi      # 0x21dc3
movq %r14, %rdi
callq 0x5310
movq %rax, %rdi
callq 0x51a0
movq 0x28(%rbx), %r15
leaq 0x6fa4(%rip), %r12      # 0x22638
cmpq 0x30(%rbx), %r15
je 0x1b6b6
movq %r14, %rdi
movq %r15, %rsi
callq 0x52d0
movq %rax, %rdi
movq %r12, %rsi
callq 0x5310
addq $0x20, %r15
jmp 0x1b694
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x17a1c
movq %rax, %r14
leaq 0x66fd(%rip), %rsi      # 0x21dd9
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x12230
leaq 0x18c28(%rip), %rdx     # 0x34318
movq %rsp, %rsi
movq %r14, %rdi
callq 0x17bee
movq %rsp, %rdi
callq 0x5638
movq 0x138ae(%rip), %rdi     # 0x2efb8
leaq 0x66ed(%rip), %rsi      # 0x21dfe
callq 0x5310
movq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0x5290
movq %rax, %rdi
callq 0x51a0
movq 0x28(%rbx), %rax
movq (%rax), %rsi
addq $0x48, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x5430
leaq 0x5ef3(%rip), %rsi      # 0x2163a
movq %r14, %rdi
callq 0x55f0
movq 0x28(%rbx), %rax
movq (%rax), %rsi
leaq 0x20(%rsp), %rdi
callq 0x12fc8
leaq 0x5ed4(%rip), %rsi      # 0x2163b
leaq 0x20(%rsp), %rdi
callq 0x136ed
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x5638
testb %bpl, %bpl
je 0x1b7b9
leaq 0x6690(%rip), %rsi      # 0x21e19
movq %rsp, %rdi
callq 0x55f0
movq 0x28(%rbx), %rax
movq (%rax), %rsi
leaq 0x20(%rsp), %rdi
callq 0x12fc8
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x5620
leaq 0x20(%rsp), %rdi
callq 0x5638
movq 0x137f8(%rip), %rdi     # 0x2efb8
leaq 0x1af09(%rip), %rsi     # 0x366d0
callq 0x1c978
movq %rsp, %rsi
movq %rax, %rdi
callq 0x52d0
leaq 0x1aee2(%rip), %rsi     # 0x366c0
movq %rax, %rdi
callq 0x1c978
movq %rsp, %rdi
callq 0x5638
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1b7fb
jmp 0x1b813
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5638
jmp 0x1b816
jmp 0x1b813
jmp 0x1b813
movq %rax, %rbx
jmp 0x1b81e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5638
movq %rbx, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O2/rcolomina[P]the_charmed_house/src/operaciones.cpp
// Function: Cardinal::execute()
void Cardinal::execute(){
    //cout<<"existeSalida "<<existeSalida<<endl;
    Logger::instance().log("Entering into Cardinal::execute() method ", Logger::kLogLevelInfo);
	  
    pScene psce=*escena_actual;
     

     
    bool existeSalida=(psce->get_salida(cardinal)!=NULL);
    bool estadoSalida=psce->get_estado_salida(cardinal);


    if(existeSalida and estadoSalida)
    {			
        *escena_actual = (*escena_actual)->get_salida(cardinal);
        primera_entrada=true;
        // cout<<"cambiando de escena"<<endl;
    } 
    else
        cout<<Color::red<<"No puedes ir: "<<cardinal<<Color::def<<endl;					

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
callq 0x17a1c
movq %rax, %r14
leaq 0x6310(%rip), %rsi      # 0x21e7f
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x12230
leaq 0x18793(%rip), %rdx     # 0x34318
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x17bee
leaq 0x10(%rsp), %rdi
callq 0x5638
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rsi
movq (%rax), %r14
leaq 0x70(%rsp), %r15
movq %r15, %rdi
callq 0x5430
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c9b4
movq %rax, %r15
leaq 0x70(%rsp), %rdi
callq 0x5638
movq 0x30(%rbx), %rsi
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x5430
movq %r14, %rdi
movq %r12, %rsi
callq 0x13320
movl %eax, %ebp
testq %r15, %r15
sete %r14b
leaq 0x50(%rsp), %rdi
callq 0x5638
xorb $0x1, %bpl
orb %r14b, %bpl
jne 0x1bc41
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rsi
movq (%rax), %r14
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x5430
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c9b4
movq 0x28(%rbx), %rcx
movq %rax, (%rcx)
leaq 0x30(%rsp), %rdi
callq 0x5638
movq 0x38(%rbx), %rax
movb $0x1, (%rax)
jmp 0x1bc86
movq 0x13370(%rip), %rdi     # 0x2efb8
leaq 0x1aa75(%rip), %rsi     # 0x366c4
callq 0x1c978
leaq 0x624e(%rip), %rsi      # 0x21ea9
movq %rax, %rdi
callq 0x5310
movq 0x30(%rbx), %rsi
movq %rax, %rdi
callq 0x52d0
leaq 0x1aa4a(%rip), %rsi     # 0x366c0
movq %rax, %rdi
callq 0x1c978
movq %rax, %rdi
callq 0x51a0
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x1bcbc
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x1bcbc
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x1bcbc
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5638
jmp 0x1bcc6
movq %rax, %rbx
movq %rbx, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_22_main.cc
// Function: main
int main(int argc, char const *argv[])
{
	// open the file from which user will query words
	ifstream infile;
	// open returns void, so we use the comma operator XREF(commaOp)
	// to check the state of infile after the open
	if (argc < 2 || !(infile.open(argv[1]), infile)) {
		cerr << "No input file!" << endl;
		return EXIT_FAILURE;
	}
	runQueries(infile);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %rbx
movl %edi, %r14d
leaq -0x218(%rbp), %rdi
callq 0x21c0
cmpl $0x2, %r14d
jl 0x258b
movq 0x8(%rbx), %rsi
leaq -0x218(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x20f0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1f8(%rbp,%rax)
je 0x25c3
movq 0x4a5e(%rip), %rdi      # 0x6ff0
leaq 0x1a94(%rip), %rsi      # 0x402d
callq 0x2180
movq %rax, %rdi
callq 0x20d0
pushq $0x1
popq %rbx
leaq -0x218(%rbp), %rdi
callq 0x2060
movl %ebx, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebx, %ebx
leaq -0x218(%rbp), %rdi
callq 0x241c
jmp 0x25a9
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/TextQuery.cc
// Function: TextQuery::query(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
QueryResult TextQuery::query(const string& sought) const
{
	// we will return a pointer to this set if we dont't find sought
	static auto nodata = make_shared<set<line_no>>();

	// use find and not a subscript to avoid adding words to wm!
	auto loc = wm.find(cleanup_str(sought));

	if (loc == wm.end()){
		return QueryResult(sought, nodata, file);
	} else {
		return QueryResult(sought, loc->second, file);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movb 0x473b(%rip), %al       # 0x7190
testb %al, %al
je 0x2b5c
leaq 0x10(%r14), %r15
leaq -0x88(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x29aa
movq %r15, %rdi
movq %r13, %rsi
callq 0x3d56
movq %rax, %r13
leaq -0x88(%rbp), %rdi
callq 0x20b0
leaq 0x18(%r14), %rax
cmpq %rax, %r13
je 0x2ae5
leaq -0xa8(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2210
addq $0x40, %r13
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x2f2c
leaq -0x38(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x2f6a
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x2eee
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %r14
jmp 0x2b32
leaq -0xc8(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2210
leaq 0x4682(%rip), %rsi      # 0x7180
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x2f2c
leaq -0x58(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x2f6a
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x2eee
leaq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %r14
callq 0x2648
movq %r14, %rdi
callq 0x2648
movq %r15, %rdi
callq 0x20b0
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x462d(%rip), %rdi      # 0x7190
callq 0x2290
testl %eax, %eax
je 0x2a5d
leaq 0x4609(%rip), %rdi      # 0x7180
callq 0x2ed2
leaq 0xc9b(%rip), %rdi       # 0x381e
leaq 0x45f6(%rip), %rsi      # 0x7180
leaq 0x45cf(%rip), %rdx      # 0x7160
callq 0x2160
leaq 0x45f3(%rip), %rdi      # 0x7190
callq 0x2110
jmp 0x2a5d
movq %rax, %rbx
leaq 0x45df(%rip), %rdi      # 0x7190
callq 0x2100
jmp 0x2c03
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2648
leaq -0x60(%rbp), %rdi
callq 0x2648
leaq -0xc8(%rbp), %rdi
jmp 0x2bfe
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2648
leaq -0x40(%rbp), %rdi
callq 0x2648
leaq -0xa8(%rbp), %rdi
jmp 0x2bfe
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %r15
addq $0x18, %rdi
movq %rdi, -0x30(%rbp)
movq 0x4398(%rip), %r12      # 0x6fc8
leaq 0x140f(%rip), %r13      # 0x4046
cmpq -0x30(%rbp), %r15
je 0x2cda
movq %r12, %rdi
leaq 0x13f1(%rip), %rsi      # 0x403c
callq 0x2180
leaq 0x20(%r15), %rsi
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
leaq 0x13dd(%rip), %rsi      # 0x4043
callq 0x2180
leaq 0x40(%r15), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2f2c
movq -0x40(%rbp), %r14
movq 0x18(%r14), %rbx
addq $0x8, %r14
cmpq %r14, %rbx
je 0x2cb2
movq 0x20(%rbx), %rsi
movq %r12, %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x21d0
movq %rax, %rbx
cmpq %r14, %rax
je 0x2c84
movq %r12, %rdi
movq %r13, %rsi
callq 0x2180
jmp 0x2c84
movq %r12, %rdi
leaq 0x138d(%rip), %rsi      # 0x4049
callq 0x2180
leaq -0x38(%rbp), %rdi
callq 0x2648
movq %r15, %rdi
callq 0x21d0
movq %rax, %r15
jmp 0x2c37
movq 0x42e7(%rip), %rdi      # 0x6fc8
callq 0x20d0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2cf7
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2648
movq %rbx, %rdi
callq 0x2280