LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Layout_routine.cc
// Function: Packing::find_closest_vertex(Point)
int Packing::find_closest_vertex(Point Q){	// finds vertex closest to given point; assumes spherical geometry
	int i,closest;
	double d,e;
	d=100000.0;	//initial value
	for(i=0;i<size();i++){
		if(geometry=='H'){
			e=hyp_dist(Q, center[i]);
		} else if (geometry=='E'){
			e=Euc_dist(Q,center[i]);
		} else if (geometry=='S'){
			e=sph_dist(Q,center[i]);
		};
		if(e<d){
			d=e;
			closest=i;
		};
	};
	return(closest);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x80(%rsp), %xmm0
movapd 0x401a(%rip), %xmm1     # 0xb0c0
movapd %xmm0, 0x30(%rsp)
xorpd %xmm0, %xmm1
movapd %xmm1, 0x20(%rsp)
movsd 0x3f9a(%rip), %xmm2     # 0xb058
movl $0x8, %r14d
xorl %r15d, %r15d
movzbl 0x60(%rbx), %eax
cmpl $0x45, %eax
je 0x7171
cmpl $0x53, %eax
je 0x712f
cmpl $0x48, %eax
jne 0x71be
movq 0xa0(%rbx), %rax
movsd (%rax,%r14), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd -0x8(%rax,%r14), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x8(%rax,%r14), %xmm0
mulsd 0x20(%rsp), %xmm0
addsd %xmm1, %xmm0
xorpd 0x3fa1(%rip), %xmm0     # 0xb0c0
movsd %xmm2, 0x8(%rsp)
callq 0x23a0
jmp 0x71b8
movq 0xa0(%rbx), %rax
movsd (%rax,%r14), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd -0x8(%rax,%r14), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x8(%rax,%r14), %xmm0
mulsd 0x30(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm2, 0x8(%rsp)
callq 0x21c0
jmp 0x71b8
movq 0xa0(%rbx), %rax
movsd 0x18(%rsp), %xmm0
subsd -0x8(%rax,%r14), %xmm0
movsd 0x10(%rsp), %xmm1
subsd (%rax,%r14), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd 0x3eab(%rip), %xmm0     # 0xb050
jb 0x71ad
sqrtsd %xmm0, %xmm0
jmp 0x71be
movsd %xmm2, 0x8(%rsp)
callq 0x2170
movsd 0x8(%rsp), %xmm2
ucomisd %xmm0, %xmm2
cmoval %r15d, %ebp
movapd %xmm0, %xmm1
minsd %xmm2, %xmm1
incq %r15
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
addq $0x18, %r14
movapd %xmm1, %xmm2
cmpq %rax, %r15
jl 0x70c7
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./graphics.cc
// Function: setup_graphics()
void setup_graphics(void){

  display=XOpenDisplay(NULL);
  display_width = DisplayWidth(display, screen_num);
  display_height = DisplayHeight(display, screen_num);
  
  screen_num = DefaultScreen(display);
//  screen_ptr = DefaultScreenOfDisplay(display);
  
  width = 600;
  height = 600;
  
  win = XCreateSimpleWindow(display, RootWindow(display, screen_num),
			    0, 0, width, height, border_width, 
			    BlackPixel(display, screen_num),
			    WhitePixel(display, screen_num));
 
  XSelectInput(display, win, ExposureMask | KeyPressMask);
  
  		//	| ButtonPressMask | StructureNotifyMask ); 


//  gc = XCreateGC(display, RootWindow(display, screen_num), 0, NULL);
  gc = DefaultGC(display, screen_num);
  XSetForeground(display, gc, BlackPixel(display, screen_num));
  XSetBackground(display, gc, WhitePixel(display, screen_num));
  
  XMapWindow(display, win);
}

// Assembly:
pushq %rbx
xorl %edi, %edi
callq 0x2280
movq %rax, 0x8017(%rip)      # 0xf228
movq 0xe8(%rax), %r10
movslq 0x8011(%rip), %rcx      # 0xf230
shlq $0x7, %rcx
movl 0x18(%r10,%rcx), %edx
movl %edx, 0x8006(%rip)      # 0xf234
movl 0x1c(%r10,%rcx), %ecx
movl %ecx, 0x7fff(%rip)      # 0xf238
movslq 0xe0(%rax), %r11
movl %r11d, 0x7fe9(%rip)     # 0xf230
movl $0x258, %ecx            # imm = 0x258
movl %ecx, 0x80be(%rip)      # 0xf310
movl %ecx, 0x80bc(%rip)      # 0xf314
shlq $0x7, %r11
movl 0x7fa6(%rip), %ebx      # 0xf208
movq 0x10(%r10,%r11), %rsi
subq $0x8, %rsp
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x258, %r8d            # imm = 0x258
movl $0x258, %r9d            # imm = 0x258
pushq 0x58(%r10,%r11)
pushq 0x60(%r10,%r11)
pushq %rbx
callq 0x2090
addq $0x20, %rsp
movq %rax, 0x806f(%rip)      # 0xf308
movq 0x7f88(%rip), %rdi      # 0xf228
movl $0x8001, %edx           # imm = 0x8001
movq %rax, %rsi
callq 0x2100
movq 0x7f74(%rip), %rdi      # 0xf228
movq 0xe8(%rdi), %rax
movslq 0x7f6e(%rip), %rcx      # 0xf230
shlq $0x7, %rcx
movq 0x48(%rax,%rcx), %rsi
movq %rsi, 0x802e(%rip)      # 0xf300
movq 0x60(%rax,%rcx), %rdx
callq 0x20b0
movq 0x7f45(%rip), %rdi      # 0xf228
movq 0x8016(%rip), %rsi      # 0xf300
movq 0xe8(%rdi), %rax
movslq 0x7f38(%rip), %rcx      # 0xf230
shlq $0x7, %rcx
movq 0x58(%rax,%rcx), %rdx
callq 0x2250
movq 0x7f1b(%rip), %rdi      # 0xf228
movq 0x7ff4(%rip), %rsi      # 0xf308
popq %rbx
jmp 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./output.cc
// Function: Packing::write_packing(std::basic_ofstream<char, std::char_traits<char>>&)
void Packing::write_packing(ofstream &outfile){
	int i,j;
	
	outfile << size() << "\n";
	for(i=0;i<size();i++){
		outfile << (int) adj[i].size() << "  ";
		for(j=0;j<(int) adj[i].size();j++){
			outfile << adj[i][j] << " ";
		};
		outfile << "\n";
	};
	for(i=0;i<size();i++){
		outfile << rad[i] << "\n";
	};
	outfile << geometry << "\n";
	outfile << INFV << "\n";
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
subq (%rdi), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %esi # imm = 0xAAAAAAAB
movq %rbx, %rdi
callq 0x2390
leaq 0x3068(%rip), %rsi      # 0xb709
movl $0x1, %edx
movq %rax, %rdi
callq 0x2220
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
testl %ecx, %ecx
jle 0x879e
xorl %ebp, %ebp
leaq 0x2fcd(%rip), %r12      # 0xb6a0
leaq (,%rbp,8), %rcx
leaq (%rcx,%rcx,2), %r15
movq 0x8(%rax,%r15), %rsi
subq (%rax,%r15), %rsi
shrq $0x2, %rsi
movq %rbx, %rdi
callq 0x2390
movl $0x2, %edx
movq %rax, %rdi
leaq 0x2f9c(%rip), %rsi      # 0xb69f
callq 0x2220
movq (%r14), %rcx
movq (%rcx,%r15), %rax
movq 0x8(%rcx,%r15), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
testl %ecx, %ecx
jle 0x8767
leaq (,%rbp,2), %r15
addq %rbp, %r15
xorl %r13d, %r13d
movl (%rax,%r13,4), %esi
movq %rbx, %rdi
callq 0x2390
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2220
incq %r13
movq (%r14), %rcx
movq (%rcx,%r15,8), %rax
movq 0x8(%rcx,%r15,8), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r13
jl 0x872d
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x2f93(%rip), %rsi      # 0xb709
callq 0x2220
incq %rbp
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
movslq %ecx, %rcx
cmpq %rcx, %rbp
jl 0x86d3
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x87fa
xorl %r12d, %r12d
leaq 0x2f4c(%rip), %r15      # 0xb709
movq 0x18(%r14), %rax
movsd (%rax,%r12,8), %xmm0
movq %rbx, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2220
incq %r12
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
cmpq %rax, %r12
jl 0x87bd
movb 0x60(%r14), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2220
leaq 0x2ef0(%rip), %r15      # 0xb709
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2220
movl 0xbc(%r14), %esi
movq %rbx, %rdi
callq 0x2390
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2220
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: Matrix::operator*(Matrix)
Matrix operator*(Matrix M){
			Matrix N;
			int i,j;
			vector<double> row;
			for(i=0;i<3;i++){
				row.clear();
				for(j=0;j<3;j++){
					row.push_back(e[i][0]*M.e[0][j]+e[i][1]*M.e[1][j]+e[i][2]*M.e[2][j]);
				};
				N.e.push_back(row);
			};
			return(N);
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
xorl %ebp, %ebp
movq %rbp, 0x10(%rdi)
xorpd %xmm0, %xmm0
movq %rdi, 0x8(%rsp)
movupd %xmm0, (%rdi)
leaq 0x10(%rsp), %r12
movq %rbp, 0x10(%r12)
movapd %xmm0, (%r12)
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x91d0
movq %rax, 0x18(%rsp)
leaq (,%rbp,2), %rbx
addq %rbp, %rbx
xorl %r13d, %r13d
movq (%r15), %rax
movq (%rax,%rbx,8), %rax
movq (%r14), %rcx
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movq (%rcx), %rdx
movq 0x18(%rcx), %rsi
mulsd (%rsi,%r13,8), %xmm0
mulsd (%rdx,%r13,8), %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%rax), %xmm0
movq 0x30(%rcx), %rax
mulsd (%rax,%r13,8), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x923c
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x9249
movq %r12, %rdi
leaq 0x30(%rsp), %rdx
callq 0x982a
incq %r13
cmpq $0x3, %r13
jne 0x91de
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x9130
incq %rbp
cmpq $0x3, %rbp
jne 0x91bf
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x9283
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21f0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9299
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x92b3
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21f0
movq 0x8(%rsp), %rdi
callq 0x9496
movq %r14, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: Matrix::hyp_inv()
Matrix hyp_inv(){	// inverse of M is JM^TJ
			Matrix N;
			int i;
			N=transpose();
			for(i=0;i<3;i++){
				N.e[i][2]=-N.e[i][2];
			};
			for(i=0;i<3;i++){
				N.e[2][i]=-N.e[2][i];
			};
			return(N);
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rdi
callq 0x96f4
leaq 0x20(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rbx), %rax
movups 0x8(%rbx), %xmm0
leaq 0x8(%rsp), %r14
movq (%r14), %rcx
movq %rcx, (%rbx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rbx)
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %rax, (%rdi)
movups %xmm0, 0x8(%rdi)
movq %rcx, (%r14)
movq %rdx, 0x8(%r14)
movq %rsi, 0x10(%r14)
callq 0x9496
movq %r14, %rdi
callq 0x9496
movq (%rbx), %rax
xorl %ecx, %ecx
movaps 0x1d6d(%rip), %xmm0     # 0xb0c0
movq (%rax,%rcx), %rdx
movsd 0x10(%rdx), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, 0x10(%rdx)
addq $0x18, %rcx
cmpq $0x48, %rcx
jne 0x9353
movq (%rbx), %rax
movq 0x30(%rax), %rax
xorl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rax,%rcx,8)
incq %rcx
cmpq $0x3, %rcx
jne 0x9376
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x9496
movq %r14, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::toggle_verbose()
void toggle_verbose(){			// toggle verbose flag
			if(verbose==true){
				verbose=false;
			} else {
				verbose=true;
			};
			cout << "verbose is " << verbose << ".\n";
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorb $0x1, 0xb8(%rdi)
movq 0x5c11(%rip), %r14      # 0xefd0
leaq 0x26cf(%rip), %rsi      # 0xba95
movl $0xb, %edx
movq %r14, %rdi
callq 0x2220
movzbl 0xb8(%rbx), %esi
movq %r14, %rdi
callq 0x2360
leaq 0x1f15(%rip), %rsi      # 0xb2fe
movl $0x2, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %r12d, %r12d
movq %r12, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsp, %r15
movq %r12, 0x10(%r15)
movaps %xmm0, (%r15)
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x9730
movq %rax, 0x8(%rsp)
leaq (,%r12,8), %r13
xorl %ebp, %ebp
movq (%r14), %rax
movq (%rax,%rbp), %rdx
addq %r13, %rdx
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x9763
movsd (%rdx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x976b
movq %r15, %rdi
callq 0x9b2c
addq $0x18, %rbp
cmpq $0x48, %rbp
jne 0x973a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9130
incq %r12
cmpq $0x3, %r12
jne 0x9720
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x979f
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21f0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x97b3
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x97cc
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x9496
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/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
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x18(%rsp), %r12
xorl %r13d, %r13d
movq %rdi, (%rsp)
movq (%r15), %rdi
movq %r13, %rsi
callq 0x284b2
movq %rax, %r13
testq %rax, %rax
je 0x19e01
movq %r12, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movl (%r14), %eax
cmpl $0x1, %eax
je 0x19d99
testl %eax, %eax
jne 0x19dd4
movq 0x38(%r13), %rbp
addq $0x10, %rbp
movq %rbp, %rdi
callq 0x5180
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbp, %rcx
movq %rax, %r8
callq 0x5500
jmp 0x19dd4
movq (%r13), %rax
movq %r13, %rdi
callq *0x58(%rax)
movq %rax, %rdi
callq 0x293d2
movq %rax, %rbp
movq 0x10(%rsp), %rbx
movq %rax, %rdi
callq 0x5180
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq (%rsp), %rbx
movq %rbp, %rcx
movq %rax, %r8
callq 0x5500
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x19faa
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x19d3d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x19d3d
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x19e1a
movq %rax, %r14
jmp 0x19e38
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x19e34
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x19fe8
movq %r14, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x141a7(%rip), %rsi     # 0x2e004
callq 0x2843e
testq %rax, %rax
je 0x19ebd
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x141eb(%rip), %rdx     # 0x2e061
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2a974
movq (%rbx), %rdx
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a974
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x19eb3
movq (%rdi), %rax
callq *0x58(%rax)
testq %rax, %rax
je 0x19eb3
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
jmp 0x19eb5
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x14146(%rip), %rdi     # 0x2e00a
leaq 0x14144(%rip), %rsi     # 0x2e00f
leaq 0x14156(%rip), %rcx     # 0x2e028
movl $0x1a, %edx
callq 0x5210
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
xorl %ebp, %ebp
leaq 0x18(%rsp), %r13
movq (%r14), %rdi
movq %rbp, %rsi
callq 0x284b2
testq %rax, %rax
je 0x19f6e
movq %rax, %rbp
movq (%rax), %rax
movq %rbp, %rdi
callq *0x58(%rax)
movq %rax, %r15
movq %rax, %rdi
leaq 0x1416b(%rip), %rsi     # 0x2e08d
callq 0x28b34
movq %r13, %rdi
movq %rax, %rsi
leaq 0xf(%rsp), %rdx
callq 0x1a044
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x5060
movl %eax, %ebx
testl %eax, %eax
cmoveq %r15, %r12
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x19f68
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x5340
testl %ebx, %ebx
jne 0x19ef9
jmp 0x19f71
xorl %r12d, %r12d
movq %r12, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x19fa2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ab35
movl %edx, %ebp
testl %r8d, %r8d
je 0x1ab32
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 0x1aa88
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 0x1aa88
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 0x1aa88
addl 0x4(%rsp), %eax
cmpl 0x8(%rsp), %eax
cmovgl (%rsp), %eax
cmpl %r13d, %eax
cmovgel %r13d, %eax
jmp 0x1ab38
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_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x100(%rdi), %r15
addq $0xf0, %r14
cmpq %r14, %r15
setne %bpl
je 0x1afe5
movq %rsi, %rbx
leaq 0x13121(%rip), %r12     # 0x2e0b4
movq 0x28(%r15), %rdx
movb $0x1, %r13b
cmpq 0x8(%rbx), %rdx
jne 0x1afbc
testq %rdx, %rdx
je 0x1afb9
movq (%rbx), %rsi
movq 0x20(%r15), %rdi
callq 0x5360
testl %eax, %eax
setne %r13b
jmp 0x1afbc
xorl %r13d, %r13d
movq 0x40(%r15), %rdi
movq %r12, %rsi
callq 0x24ece
testb %r13b, %r13b
jne 0x1afd1
testb %al, %al
jne 0x1afe5
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
cmpq %r14, %rax
setne %bpl
jne 0x1af93
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x13603(%rip), %rdx     # 0x2e623
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x1a08c
movq 0x100(%r14), %r15
leaq 0xf0(%r14), %rbx
cmpq %rbx, %r15
je 0x1b093
leaq 0x1306f(%rip), %r12     # 0x2e0b4
movq %rsp, %r13
leaq 0x135b7(%rip), %rbp     # 0x2e606
cmpq 0x100(%r14), %r15
je 0x1b063
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5620
movq 0x40(%r15), %rdi
movq %r12, %rsi
callq 0x24ece
testb %al, %al
je 0x1b083
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %r13, %rdi
callq 0x5120
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
cmpq %rbx, %rax
jne 0x1b04f
leaq 0x13589(%rip), %rsi     # 0x2e623
movq %rsp, %rdi
callq 0x5110
movq 0x20(%rsp), %r14
leaq 0x10(%r14), %rcx
movq %rcx, (%r14)
testl %eax, %eax
je 0x1b0ce
movq (%rsp), %rax
leaq 0x10(%rsp), %rbx
cmpq %rbx, %rax
je 0x1b0e7
movq %rax, (%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r14)
jmp 0x1b0ed
leaq 0x1354e(%rip), %rdx     # 0x2e623
movq %r14, %rdi
movq %rdx, %rsi
leaq 0x10(%rsp), %rbx
callq 0x1a08c
jmp 0x1b108
movups (%rbx), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r14)
movq %rbx, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x1b11e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b132
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1b150
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x53d0
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x118(%rbx), %rsi
movq 0x120(%rbx), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x1a300
movq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x52f0
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb $0x0, (%rbp)
leaq 0xc8(%rsp), %rdi
callq 0x50f0
testb %al, %al
je 0x1b38f
leaq 0x8(%rsp), %r14
movq 0x1fcab(%rip), %r15     # 0x3afc0
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5300
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5600
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1b385
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x53a0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x5300
movsbl %al, %esi
movq %r12, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x5230
jmp 0x1b315
leaq 0x48(%rsp), %rdi
callq 0x50a0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1b3a6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1b3bd
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5340
leaq 0x48(%rsp), %rdi
callq 0x50e0
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b3e5
movq %rax, %rbx
jmp 0x1b3ff
movq %rax, %rbx
jmp 0x1b416
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1b3ff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1b416
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5340
leaq 0x48(%rsp), %rdi
callq 0x50e0
movq %rbx, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13169(%rip), %rdx     # 0x2e623
movq %rdx, %rsi
callq 0x1a08c
leaq 0x88(%r14), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1bc5a
leaq 0x30(%rsp), %rbp
movq 0x10(%rbp), %r15
cmpq %rbp, %r15
je 0x1b560
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 0x1a300
movq %r14, %rdi
movq %r12, %rsi
callq 0x1ba76
cmpb $0x1, (%rax)
jne 0x1b539
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %rbx, %rdi
callq 0x5120
movq %rbx, %rdi
leaq 0x140d4(%rip), %rsi     # 0x2f608
callq 0x5620
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1b550
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
cmpq %rbp, %rax
jne 0x1b4f2
leaq 0x28(%rsp), %rdi
callq 0x1bbe2
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1b5aa
movq %rax, %r14
jmp 0x1b5a0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1b5a0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
leaq 0x28(%rsp), %rdi
callq 0x1bbe2
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x1b5c2
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5340
movq %r14, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a300
leaq 0x13028(%rip), %rsi     # 0x2e622
movq %rbx, %rdi
callq 0x5620
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1affa
leaq 0x1300f(%rip), %rsi     # 0x2e623
movq %rsp, %r15
movq %r15, %rdi
callq 0x5110
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x10(%rsp), %r15
cmpq %r15, %rdi
je 0x1b63b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
testl %ebp, %ebp
je 0x1b680
leaq 0x12fc2(%rip), %rsi     # 0x2e608
movq %rbx, %rdi
callq 0x5620
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1affa
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x5120
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1b680
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 0x1b6b2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x1b6b2
jmp 0x1b6af
jmp 0x1b6af
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1b6c6
movq (%r12), %rsi
incq %rsi
callq 0x5340
movq %r14, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1bc5a
leaq 0x8(%rsp), %r13
movq 0x10(%r13), %r14
cmpq %r13, %r14
je 0x1b740
leaq 0x13ef3(%rip), %r15     # 0x2f608
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 0x1b715
movq %rsp, %rdi
callq 0x1bbe2
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x1b769
movq %rax, %r14
movq %rsp, %rdi
callq 0x1bbe2
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1b77d
movq (%r12), %rsi
incq %rsi
callq 0x5340
movq %r14, %rdi
callq 0x55c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1cca4
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 0x1a300
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x1b46e
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1cc79
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 0x1a300
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1197a(%rip), %rdi     # 0x2e625
leaq 0x1197f(%rip), %rsi     # 0x2e631
leaq 0x11986(%rip), %rcx     # 0x2e63f
movl $0x6, %edx
callq 0x5210
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1ccdc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x284b2
movq %rax, %r13
testq %rax, %rax
je 0x1edb0
movq 0x38(%r13), %rsi
addq $0x10, %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x1a044
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19faa
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1ed66
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x1ed66
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ede0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1ede3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x1ede3
movq %rax, %r14
movq %rbx, %rdi
callq 0x19fe8
movq %r14, %rdi
callq 0x55c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x284b2
movq %rax, %r13
testq %rax, %rax
je 0x1ee7f
movq (%r13), %rax
movq %r13, %rdi
callq *0x58(%rax)
movq %rax, %rdi
callq 0x293d2
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1a044
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19faa
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1ee28
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x1ee28
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1eeb3
jmp 0x1eeb3
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1eeb6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x1eeb6
jmp 0x1eeb3
movq %rax, %r14
movq %rbx, %rdi
callq 0x19fe8
movq %r14, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf129(%rip), %rsi      # 0x2e004
callq 0x2843e
testq %rax, %rax
je 0x1ef3b
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xf16d(%rip), %rdx      # 0x2e061
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2a974
movq (%rbx), %rdx
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a974
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1ef31
movq (%rdi), %rax
callq *0x58(%rax)
testq %rax, %rax
je 0x1ef31
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
jmp 0x1ef33
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0xf0c8(%rip), %rdi      # 0x2e00a
leaq 0xf996(%rip), %rsi      # 0x2e8df
leaq 0xf99f(%rip), %rcx      # 0x2e8ef
movl $0x8f, %edx
callq 0x5210
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
xorl %ebp, %ebp
leaq 0x18(%rsp), %r13
movq %r14, %rdi
movq %rbp, %rsi
callq 0x284b2
testq %rax, %rax
je 0x1efec
movq %rax, %rbp
movq (%rax), %rax
movq %rbp, %rdi
callq *0x58(%rax)
movq %rax, %r15
movq %rax, %rdi
leaq 0xf0ed(%rip), %rsi      # 0x2e08d
callq 0x28b34
movq %r13, %rdi
movq %rax, %rsi
leaq 0xf(%rsp), %rdx
callq 0x1a044
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x5060
movl %eax, %ebx
testl %eax, %eax
cmoveq %r15, %r12
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x1efe6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x5340
testl %ebx, %ebx
jne 0x1ef77
jmp 0x1efef
xorl %r12d, %r12d
movq %r12, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x1f020
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xecf7(%rip), %rdx      # 0x2e623
movq %rdx, %rsi
callq 0x1a08c
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x1f9b2
leaq 0x18(%rsp), %rbp
leaq 0xfcbb(%rip), %r12      # 0x2f608
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 0x1a300
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x5120
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1f9a2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
cmpq %r14, %rax
jne 0x1f952
leaq 0xec6a(%rip), %rsi      # 0x2e623
movq %rbx, %rdi
callq 0x5110
testl %eax, %eax
jne 0x1f9e0
movq 0x8(%rbx), %rdx
leaq 0xf09a(%rip), %rcx      # 0x2ea6a
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 0x1f9f6
jmp 0x1f9f6
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x1fa11
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 0x1f9f9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x1f9f9
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
setne %bpl
je 0x1fa8b
movq %rsi, %rbx
movq 0x8(%rsi), %r12
movq 0x28(%r15), %rdx
cmpq %r12, %rdx
jne 0x1fa77
testq %rdx, %rdx
je 0x1fa8b
movq (%rbx), %rsi
movq 0x20(%r15), %rdi
callq 0x5360
testl %eax, %eax
je 0x1fa8b
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
cmpq %r14, %rax
setne %bpl
jne 0x1fa59
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
setne %bpl
je 0x1fb00
movq 0x40(%r14), %rdi
leaq 0xefba(%rip), %rsi      # 0x2ea86
callq 0x24ece
testb %al, %al
jne 0x1fb00
leaq 0xefaa(%rip), %r15      # 0x2ea86
movq %r14, %rdi
callq 0x5240
cmpq %rbx, %rax
setne %bpl
je 0x1fb00
movq %rax, %r14
movq 0x40(%rax), %rdi
movq %r15, %rsi
callq 0x24ece
testb %al, %al
je 0x1fadc
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fb51
leaq 0xef59(%rip), %r12      # 0x2ea86
xorl %ebx, %ebx
movq 0x40(%r15), %rdi
movq %r12, %rsi
callq 0x24ece
testb %al, %al
jne 0x1fb55
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
cmpq %r14, %rax
jne 0x1fb2f
jmp 0x1fb59
xorl %ebx, %ebx
jmp 0x1fb59
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_O1/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
setne %bpl
je 0x1fbc2
movq 0x40(%r14), %rdi
leaq 0xf351(%rip), %rsi      # 0x2eedf
callq 0x24ece
testb %al, %al
jne 0x1fbc2
leaq 0xf341(%rip), %r15      # 0x2eedf
movq %r14, %rdi
callq 0x5240
cmpq %rbx, %rax
setne %bpl
je 0x1fbc2
movq %rax, %r14
movq 0x40(%rax), %rdi
movq %r15, %rsi
callq 0x24ece
testb %al, %al
je 0x1fb9e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fc13
leaq 0xf2f0(%rip), %r12      # 0x2eedf
xorl %ebx, %ebx
movq 0x40(%r15), %rdi
movq %r12, %rsi
callq 0x24ece
testb %al, %al
jne 0x1fc17
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
cmpq %r14, %rax
jne 0x1fbf1
jmp 0x1fc1b
xorl %ebx, %ebx
jmp 0x1fc1b
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_O1/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 0x19fb3(%rip), %r12     # 0x3a4e0
movq %r12, (%rdi)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x29402
leaq 0x19f5d(%rip), %rax     # 0x3a4a0
movq %rax, (%rbx)
movq (%r15), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x29728
testb %al, %al
je 0x20563
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x60(%rbx), %rsi
addq $0x10, %rsi
leaq 0xe189(%rip), %rdi      # 0x2e6fb
xorl %eax, %eax
callq 0x5080
movl $0x1, %edi
callq 0x53e0
movq %rax, %r15
movq %r12, (%rbx)
movq %r14, %rdi
callq 0x1f028
movq %r15, %rdi
callq 0x55c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1f68e(%rip), %al      # 0x403b0
testb %al, %al
je 0x20d7a
leaq 0x1f653(%rip), %rdi     # 0x40380
callq 0x54c0
testl %eax, %eax
jne 0x20d81
cmpq $0x0, 0x1f63a(%rip)     # 0x40378
jne 0x20d5c
movl $0x208, %edi            # imm = 0x208
callq 0x5330
movq %rax, %r14
movq %rax, %rdi
callq 0x20e68
movq %r14, 0x1f61c(%rip)     # 0x40378
movq 0x1f615(%rip), %rbx     # 0x40378
leaq 0x1f616(%rip), %rdi     # 0x40380
callq 0x5280
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x572d
jmp 0x20d26
movl %eax, %edi
callq 0x5220
movq %rax, %rbx
movl $0x208, %esi            # imm = 0x208
movq %r14, %rdi
callq 0x5340
jmp 0x20d9d
movq %rax, %rbx
leaq 0x1f5dc(%rip), %rdi     # 0x40380
callq 0x5280
movq %rbx, %rdi
callq 0x55c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a300
leaq 0xb94d(%rip), %rsi      # 0x2e622
movq %rbx, %rdi
callq 0x5620
movq 0x150(%r14), %rsi
movq %rsp, %rdi
callq 0x1affa
leaq 0xb930(%rip), %rsi      # 0x2e623
movq %rsp, %r15
movq %r15, %rdi
callq 0x5110
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x10(%rsp), %r15
cmpq %r15, %rdi
je 0x22d1a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
testl %ebp, %ebp
je 0x22d63
leaq 0xbff7(%rip), %rsi      # 0x2ed1c
movq %rbx, %rdi
callq 0x5620
movq 0x150(%r14), %rsi
movq %rsp, %rdi
callq 0x1affa
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x5120
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x22d63
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 0x22d95
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x22d95
jmp 0x22d92
jmp 0x22d92
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x22da9
movq (%r12), %rsi
incq %rsi
callq 0x5340
movq %r14, %rdi
callq 0x55c0
nop