LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: Euc_ang(Point)
double Euc_ang(Point P){
	Point Q;
	Q=P;
	Q.z=0.0;
	if(norm(Q)==0.0){
		return(0.0);
	};
	return(atan2(P.y,P.x));
}

// Assembly:
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
xorps %xmm2, %xmm2
sqrtsd %xmm3, %xmm2
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm2
jne 0x3933
jp 0x3933
xorpd %xmm0, %xmm0
retq
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::which_edge(int, int)
int Packing::which_edge(int i, int j){	// returns e if adj[i][e]=j and returns -1 if there is no e.
	int e;
	bool found_yet;
	found_yet=false;
	for(e=0;e<(int) adj[i].size();e++){
		if(adj[i][e]==j){
			found_yet=true;
			return(e);
		};
	};
	if(found_yet==false){
		return(-1);
	};
	return(-1);
}

// Assembly:
movslq %esi, %rax
movq (%rdi), %rsi
leaq (%rax,%rax,2), %rax
movq (%rsi,%rax,8), %rcx
movq 0x8(%rsi,%rax,8), %rsi
subq %rcx, %rsi
shrq $0x2, %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %esi, %esi
jle 0x3b20
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
xorl %edi, %edi
cmpl %edx, (%rcx,%rdi,4)
je 0x3b21
incq %rdi
cmpq %rdi, %rsi
jne 0x3b13
retq
movl %edi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::determine_inner_vertices()
void Packing::determine_inner_vertices(){
	int i;
	inner.clear();
	for(i=1;i<(int) adj.size();i++){
		if(which_edge(i,INFV)==-1){
			inner.push_back(i);
		};
	};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rax
cmpq %rax, 0x50(%rdi)
je 0x3b3e
movq %rax, 0x50(%rbx)
movl $0x1, 0xc(%rsp)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
imull $0xaaaaaaab, %edx, %edx # imm = 0xAAAAAAAB
cmpl $0x2, %edx
jl 0x3bf3
leaq 0x48(%rbx), %r14
movl $0x1, %edx
leaq 0xc(%rsp), %r15
movslq %edx, %rsi
leaq (%rsi,%rsi,2), %rdi
movq (%rax,%rdi,8), %rsi
movq 0x8(%rax,%rdi,8), %rdi
subq %rsi, %rdi
shrq $0x2, %rdi
testl %edi, %edi
jle 0x3bad
movl 0xbc(%rbx), %r8d
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %r9d, %r9d
cmpl %r8d, (%rsi,%r9,4)
je 0x3bd5
incq %r9
cmpq %r9, %rdi
jne 0x3b9f
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x3bc3
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x50(%rbx)
jmp 0x3bd5
movq %r14, %rdi
movq %r15, %rdx
callq 0x98b4
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movl 0xc(%rsp), %edx
incl %edx
movl %edx, 0xc(%rsp)
movq %rcx, %rsi
subq %rax, %rsi
shrq $0x3, %rsi
imull $0xaaaaaaab, %esi, %esi # imm = 0xAAAAAAAB
cmpl %esi, %edx
jl 0x3b74
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::determine_labels()
void Packing::determine_labels(){
	int i;
	lab.clear();
	lab.push_back(0.0);
	for(i=0;i<(int) adj.size();i++){
		lab.push_back(exp(-2.0*rad[i]));
	};
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rsi
cmpq %rax, %rsi
je 0x3c1d
movq %rax, 0x38(%rbx)
movq %rax, %rsi
leaq 0x30(%rbx), %r14
movq $0x0, (%rsp)
cmpq 0x40(%rbx), %rsi
je 0x3c40
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x3c4b
movq %rsp, %rdx
movq %r14, %rdi
callq 0x94a6
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x3cc0
xorl %r12d, %r12d
movq %rsp, %r15
movq 0x18(%rbx), %rax
movsd (%rax,%r12,8), %xmm0
mulsd 0x6418(%rip), %xmm0     # 0xa090
callq 0x23c0
movsd %xmm0, (%rsp)
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x3c9a
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x3ca5
movq %r14, %rdi
movq %r15, %rdx
callq 0x94a6
incq %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
cmpq %rax, %r12
jl 0x3c66
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Packing.cc
// Function: angle_at_C(double, double, double, char)
double angle_at_C(double a, double b, double c, char geometry){	
	// in a triangle with side lengths a,b,c, what is the angle at C (i.e. opposite c)?
	double t,u;
	if(geometry=='E'){	// Euclidean geometry
		// Euclidean cosine rule: c*c = a*a + b*b - 2*a*b*cos(C)
		// so C = acos((a*a + b*b - c*c)/(2*a*b));
		t=(a*a+b*b-c*c)/(2.0*a*b);
		return(acos(t));
	} else if(geometry=='S'){	// Spherical geometry
		// Spherical cosine rule: cos(c) = cos(a)*cos(b)+sin(a)*sin(b)*cos(C)
		// so C=acos((cos(c)-cos(a)*cos(b))/(sin(a)*sin(b)))
		u=sin(a)*sin(b);
		t=(cos(c)-(cos(a)*cos(b)))/u;
		return(acos(t));
	} else if(geometry=='H'){	// Hyperbolic geometry
		// Hyperbolic cosine rule: cosh(c) = cosh(a)*cosh(b)-sinh(a)*sinh(b)*cos(C)
		// so C=acos((cosh(c)-cosh(a)*cosh(b))/(sinh(a)*sinh(b)))
		u=-sinh(a)*sinh(b);
		t=(cosh(c)-(cosh(a)*cosh(b)))/u;
		return(acos(t));
	};
	return(0.0);
}

// Assembly:
subq $0x38, %rsp
cmpl $0x53, %edi
je 0x4085
cmpl $0x48, %edi
je 0x401c
cmpl $0x45, %edi
jne 0x4109
movapd %xmm1, %xmm4
mulsd %xmm1, %xmm4
movapd %xmm0, %xmm3
mulsd %xmm0, %xmm3
addsd %xmm4, %xmm3
mulsd %xmm2, %xmm2
subsd %xmm2, %xmm3
addsd %xmm0, %xmm0
mulsd %xmm1, %xmm0
divsd %xmm0, %xmm3
jmp 0x40fc
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x21b0
xorps 0x5fe6(%rip), %xmm0     # 0xa020
movaps %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x21b0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2290
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2290
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x2290
jmp 0x40e6
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x2060
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x2060
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x23d0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x23d0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x23d0
movsd 0x8(%rsp), %xmm3
mulsd 0x10(%rsp), %xmm0
subsd %xmm0, %xmm3
divsd 0x20(%rsp), %xmm3
movapd %xmm3, %xmm0
addq $0x38, %rsp
jmp 0x21c0
xorps %xmm0, %xmm0
addq $0x38, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::hyperbolic_wedge(int, int)
double Packing::hyperbolic_wedge(int i,int e){	// angle at vertex i between e and e+1; computed via labels
	int j,k;	// i -e-> j, i -(e+1)-> k
	j=adj[i][e];
	k=adj[i][(e+1)%adj[i].size()];	
	double v,u,w;
	v=lab[i];
	u=lab[j];
	w=lab[k];
	return(2.0*asin(sqrt(v*(1.0-u)*(1.0-w)/((1.0-v*u)*(1.0-v*w)))));
}

// Assembly:
pushq %rax
movslq %esi, %rcx
leaq (%rcx,%rcx,2), %rax
movslq %edx, %rdx
movq (%rdi), %rsi
movq 0x30(%rdi), %rdi
movq (%rsi,%rax,8), %r8
movq 0x8(%rsi,%rax,8), %rsi
movslq (%r8,%rdx,4), %r9
incl %edx
movslq %edx, %rax
subq %r8, %rsi
sarq $0x2, %rsi
xorl %edx, %edx
divq %rsi
movslq (%r8,%rdx,4), %rax
movsd (%rdi,%rcx,8), %xmm1
movsd (%rdi,%r9,8), %xmm2
movsd (%rdi,%rax,8), %xmm3
movsd 0x5ecc(%rip), %xmm0     # 0xa088
movapd %xmm0, %xmm4
subsd %xmm2, %xmm4
mulsd %xmm1, %xmm4
subsd %xmm3, %xmm0
mulsd %xmm4, %xmm0
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
mulpd %xmm1, %xmm2
movapd 0x5e5c(%rip), %xmm1     # 0xa040
subpd %xmm2, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
mulsd %xmm1, %xmm2
divsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4208
sqrtsd %xmm0, %xmm0
jmp 0x420d
callq 0x2170
callq 0x2370
addsd %xmm0, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::angle(int)
double Packing::angle(int i){	// angle at vertex i; for correct packing, this should be 2pi
	int e;
	double angle;
	angle=0.0;	// initialize
	for(e=0;e<(int) adj[i].size();e++){
		if(geometry=='E' || geometry=='S'){
			angle=angle+wedge(i,e);
		} else {
			angle=angle+hyperbolic_wedge(i,e);
		};
	};
	return(angle);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movslq %esi, %rax
movq (%rdi), %rcx
leaq (%rax,%rax,2), %r15
movq 0x8(%rcx,%r15,8), %rax
subq (%rcx,%r15,8), %rax
shrq $0x2, %rax
testl %eax, %eax
jle 0x4298
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movzbl 0x60(%r14), %eax
cmpl $0x53, %eax
je 0x4259
cmpl $0x45, %eax
jne 0x4267
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x4112
jmp 0x4273
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x4170
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
incl %ebp
movq (%r14), %rax
movq 0x8(%rax,%r15,8), %rcx
subq (%rax,%r15,8), %rcx
shrq $0x2, %rcx
cmpl %ecx, %ebp
jl 0x4245
jmp 0x429c
xorpd %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::hyperbolic_correct_radius(int)
void Packing::hyperbolic_correct_radius(int j){	// determines "label of best fit" given angle and valence
	double beta, delta;
	double dk;
	double vhat;
	double t,u;
	double v;
	dk = (double) adj[j].size();
	beta=sin(angle(j)/(2.0*dk));
	delta=sin(TWOPI/(2.0*dk));
	v=lab[j];
	vhat=(beta-sqrt(v))/((beta*v)-sqrt(v));
	if(vhat<0){
		vhat=0.0;
	};
	t=2.0*delta/(sqrt((1.0-vhat)*(1.0-vhat)+4.0*delta*delta*vhat) + (1.0-vhat));
	u=t*t;
	lab[j]=u;	// determine new label
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movslq %esi, %rbx
movq (%rdi), %rax
leaq (%rbx,%rbx,2), %rcx
movq 0x8(%rax,%rcx,8), %rdx
subq (%rax,%rcx,8), %rdx
sarq $0x2, %rdx
movq %rdx, %xmm0
punpckldq 0x5c42(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x5c4a(%rip), %xmm0     # 0xa070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movl %ebx, %esi
callq 0x4218
movapd 0x10(%rsp), %xmm1
addsd %xmm1, %xmm1
movapd %xmm1, 0x10(%rsp)
divsd %xmm1, %xmm0
callq 0x2060
movsd %xmm0, 0x8(%rsp)
movsd 0x5c3a(%rip), %xmm0     # 0xa0a0
divsd 0x10(%rsp), %xmm0
callq 0x2060
movsd %xmm0, 0x10(%rsp)
movq 0x30(%r14), %rax
movsd (%rax,%rbx,8), %xmm1
sqrtsd %xmm1, %xmm2
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm1
movapd %xmm2, %xmm0
movsd %xmm1, 0x30(%rsp)
jae 0x44b7
movapd %xmm1, %xmm0
movsd %xmm2, 0x28(%rsp)
callq 0x2170
xorpd %xmm4, %xmm4
movsd 0x28(%rsp), %xmm2
movsd 0x30(%rsp), %xmm1
movsd 0x8(%rsp), %xmm3
subsd %xmm0, %xmm3
ucomisd %xmm4, %xmm1
jae 0x44e6
movapd %xmm1, %xmm0
movsd %xmm3, 0x28(%rsp)
callq 0x2170
movsd 0x28(%rsp), %xmm3
movsd 0x30(%rsp), %xmm1
movapd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
subsd %xmm2, %xmm0
divsd %xmm0, %xmm3
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
maxsd %xmm3, %xmm0
movsd 0x10(%rsp), %xmm3
movapd %xmm3, %xmm4
addsd %xmm3, %xmm4
movsd 0x5b6e(%rip), %xmm5     # 0xa088
subsd %xmm0, %xmm5
movsd 0x5b82(%rip), %xmm2     # 0xa0a8
mulsd %xmm3, %xmm2
mulsd %xmm3, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm5, %xmm0
mulsd %xmm5, %xmm0
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x454a
sqrtsd %xmm0, %xmm0
jmp 0x4567
movsd %xmm4, 0x10(%rsp)
movsd %xmm5, 0x8(%rsp)
callq 0x2170
movsd 0x8(%rsp), %xmm5
movsd 0x10(%rsp), %xmm4
addsd %xmm5, %xmm0
divsd %xmm0, %xmm4
mulsd %xmm4, %xmm4
movq 0x30(%r14), %rax
movsd %xmm4, (%rax,%rbx,8)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::Euclidean_correct_radius(int)
void Packing::Euclidean_correct_radius(int j){	// determines "radius of best fit" given angle and valence
	double beta, delta;
	double dk;
	double vhat;
	dk = (double) adj[j].size();
	beta=sin(angle(j)/(2.0*dk));
	delta=sin(TWOPI/(2.0*dk));	
	vhat=rad[j]*beta/(1.0-beta);
	rad[j]=vhat*(1.0-delta)/delta;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movslq %esi, %rbx
movq (%rdi), %rax
leaq (%rbx,%rbx,2), %rcx
movq 0x8(%rax,%rcx,8), %rdx
subq (%rax,%rcx,8), %rdx
sarq $0x2, %rdx
movq %rdx, %xmm0
punpckldq 0x5aae(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x5ab6(%rip), %xmm0     # 0xa070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
movl %ebx, %esi
callq 0x4218
movapd (%rsp), %xmm1
addsd %xmm1, %xmm1
movapd %xmm1, (%rsp)
divsd %xmm1, %xmm0
callq 0x2060
movsd %xmm0, 0x10(%rsp)
movsd 0x5aa9(%rip), %xmm0     # 0xa0a0
divsd (%rsp), %xmm0
callq 0x2060
movq 0x18(%r14), %rax
movsd (%rax,%rbx,8), %xmm1
movsd 0x10(%rsp), %xmm4
mulsd %xmm4, %xmm1
movsd 0x5a6c(%rip), %xmm2     # 0xa088
movapd %xmm2, %xmm3
subsd %xmm4, %xmm3
divsd %xmm3, %xmm1
subsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, (%rax,%rbx,8)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::write_radii()
void Packing::write_radii(){
	cout << "geometry is " << geometry << "\n";
	int i;
	if(geometry=='H'){
		cout << "circle " << 0 << " is the ideal circle \n";
		for(i=0;i<(int) adj.size();i++){
			if(i==INFV){
				cout << "circle " << INFV << " is the ideal circle \n";
			} else {
				cout << "circle " << i << " has radius " << rad[i] << "\n";
			};
		};
	} else {
		for(i=0;i<(int) adj.size();i++){
			cout << "circle " << i << " has radius " << rad[i] << "\n";
		};	
	};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x94fd(%rip), %r14      # 0xdfd0
leaq 0x5eab(%rip), %rsi      # 0xa985
movl $0xc, %edx
movq %r14, %rdi
callq 0x2220
movb 0x60(%rbx), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x2220
leaq 0x5c1c(%rip), %rsi      # 0xa721
movl $0x1, %edx
movq %rax, %rdi
callq 0x2220
cmpb $0x48, 0x60(%rbx)
jne 0x4c28
movq 0x94ad(%rip), %r14      # 0xdfd0
leaq 0x576e(%rip), %rsi      # 0xa298
movl $0x7, %edx
movq %r14, %rdi
callq 0x2220
movq %r14, %rdi
xorl %esi, %esi
callq 0x2390
leaq 0x5758(%rip), %rsi      # 0xa2a0
movl $0x16, %edx
movq %rax, %rdi
callq 0x2220
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x4cc8
xorl %r14d, %r14d
movq 0x9458(%rip), %r15      # 0xdfd0
leaq 0x5719(%rip), %r12      # 0xa298
leaq 0x5b9b(%rip), %r13      # 0xa721
movl 0xbc(%rbx), %ebp
movl $0x7, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2220
cmpq %rbp, %r14
jne 0x4bc0
movl 0xbc(%rbx), %esi
movq %r15, %rdi
callq 0x2390
movl $0x16, %edx
movq %rax, %rdi
leaq 0x56e2(%rip), %rsi      # 0xa2a0
jmp 0x4bff
movq %r15, %rdi
movl %r14d, %esi
callq 0x2390
movq %rax, %rbp
movl $0xc, %edx
movq %rax, %rdi
leaq 0x56da(%rip), %rsi      # 0xa2b7
callq 0x2220
movq 0x18(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
movq %rbp, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2220
incq %r14
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
cmpq %rax, %r14
jl 0x4b86
jmp 0x4cc8
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x4cc8
xorl %r14d, %r14d
movq 0x9385(%rip), %r15      # 0xdfd0
leaq 0x5665(%rip), %r13      # 0xa2b7
leaq 0x5ac8(%rip), %rbp      # 0xa721
movl $0x7, %edx
movq %r15, %rdi
leaq 0x5630(%rip), %rsi      # 0xa298
callq 0x2220
movq %r15, %rdi
movl %r14d, %esi
callq 0x2390
movq %rax, %r12
movl $0xc, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2220
movq 0x18(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
movq %r12, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2220
incq %r14
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
cmpq %rax, %r14
jl 0x4c59
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Layout_routine.cc
// Function: Packing::write_distances_to_vertex_INFV()
void Packing::write_distances_to_vertex_INFV(){
	int i;
	for(i=0;i<(int) adj.size();i++){
		cout << "vertex " << i << " is distance " << dist[i] << " to vertex " << INFV << " (i.e. to vertex INFV).\n";
	};
	cout << "maximum distance is " << maximum_distance << "\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x512c
xorl %r14d, %r14d
movq 0x8f4b(%rip), %r15      # 0xdfd0
leaq 0x5268(%rip), %rbp      # 0xa2f4
leaq 0x526d(%rip), %r12      # 0xa300
movl $0x7, %edx
movq %r15, %rdi
leaq 0x5256(%rip), %rsi      # 0xa2f8
callq 0x2220
movq %r15, %rdi
movl %r14d, %esi
callq 0x2390
movq %rax, %r13
movl $0xd, %edx
movq %rax, %rdi
leaq 0x5222(%rip), %rsi      # 0xa2e6
callq 0x2220
movq 0x80(%rbx), %rax
movl (%rax,%r14,4), %esi
movq %r13, %rdi
callq 0x2390
movq %rax, %r13
movl $0xb, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2220
movl 0xbc(%rbx), %esi
movq %r13, %rdi
callq 0x2390
movl $0x18, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2220
incq %r14
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
cmpq %rax, %r14
jl 0x5093
movq 0x8e9d(%rip), %r14      # 0xdfd0
leaq 0x51df(%rip), %rsi      # 0xa319
movl $0x14, %edx
movq %r14, %rdi
callq 0x2220
movl 0x98(%rbx), %esi
movq %r14, %rdi
callq 0x2390
leaq 0x55c5(%rip), %rsi      # 0xa721
movl $0x1, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Layout_routine.cc
// Function: Packing::already_laid_out(int)
bool Packing::already_laid_out(int i){
	int j;
	bool found_index;
	found_index=false;
	for(j=0;j<(int) lay.size();j++){
		if(lay[j][0]==i){	// did we lay it out?
			found_index=true;
		};
	};
	return(found_index);
}

// Assembly:
movq 0x68(%rdi), %rcx
movq 0x70(%rdi), %rax
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
testl %edx, %edx
jle 0x51b8
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %eax, %eax
movq (%rcx), %rdi
cmpl %esi, (%rdi)
sete %dil
orb %dil, %al
addq $0x18, %rcx
decq %rdx
jne 0x51a1
jmp 0x51ba
xorl %eax, %eax
andb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Layout_routine.cc
// Function: Packing::initialize_centers()
void Packing::initialize_centers(){
	if(verbose){
		cout << "initializing centers to 0.\n";
	};
	Point P;
	int i;
	P.x=0.0;
	P.y=0.0;
	P.z=1.0;
	for(i=0;i<(int) adj.size();i++){
		center.push_back(P);	// initialize center to origin
	};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x1, 0xb8(%rdi)
jne 0x5d9e
movq 0x8243(%rip), %rdi      # 0xdfd0
leaq 0x45e8(%rip), %rsi      # 0xa37c
movl $0x1b, %edx
callq 0x2220
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x10(%rsp)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x5e21
leaq 0xa0(%rbx), %r14
xorl %ebp, %ebp
movq %rsp, %r15
movq 0xa8(%rbx), %rsi
cmpq 0xb0(%rbx), %rsi
je 0x5dff
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rsi)
movaps (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x18, 0xa8(%rbx)
jmp 0x5e0a
movq %r14, %rdi
movq %r15, %rdx
callq 0x9d7c
movq 0x8(%rbx), %rax
subq (%rbx), %rax
incl %ebp
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cmpl %eax, %ebp
jl 0x5dd5
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Layout_routine.cc
// Function: Packing::write_centers()
void Packing::write_centers(){
	cout << "geometry is " << geometry << "\n";
	int i;
	for(i=0;i<(int) adj.size();i++){
		if(i==INFV){
			cout << "INFV ";
		};
		cout << "vertex " << i << " has center " << center[i].x << " " << center[i].y << " " << center[i].z << "\n";
	};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7f59(%rip), %r14      # 0xdfd0
leaq 0x4907(%rip), %rsi      # 0xa985
movl $0xc, %edx
movq %r14, %rdi
callq 0x2220
movb 0x60(%rbx), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x2220
leaq 0x4678(%rip), %rsi      # 0xa721
movl $0x1, %edx
movq %rax, %rdi
callq 0x2220
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x61d6
xorl %r15d, %r15d
movq 0x7ef7(%rip), %r14      # 0xdfd0
leaq 0x45d8(%rip), %rbp      # 0xa6b8
xorl %r12d, %r12d
movl 0xbc(%rbx), %eax
cmpq %rax, %r12
jne 0x6102
movl $0x5, %edx
movq %r14, %rdi
leaq 0x42b1(%rip), %rsi      # 0xa3ae
callq 0x2220
movl $0x7, %edx
movq %r14, %rdi
leaq 0x41e7(%rip), %rsi      # 0xa2f8
callq 0x2220
movq %r14, %rdi
movl %r12d, %esi
callq 0x2390
movq %rax, %r13
movl $0xc, %edx
movq %rax, %rdi
leaq 0x4281(%rip), %rsi      # 0xa3b4
callq 0x2220
movq 0xa0(%rbx), %rax
movsd (%rax,%r15), %xmm0
movq %r13, %rdi
callq 0x2330
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2220
movq 0xa0(%rbx), %rax
movsd 0x8(%rax,%r15), %xmm0
movq %r13, %rdi
callq 0x2330
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2220
movq 0xa0(%rbx), %rax
movsd 0x10(%rax,%r15), %xmm0
movq %r13, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
leaq 0x4573(%rip), %rsi      # 0xa721
callq 0x2220
incq %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
addq $0x18, %r15
cmpq %rax, %r12
jl 0x60e3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x10(%rsp)
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x80(%rsp), %xmm0
movapd 0x3222(%rip), %xmm1     # 0xa020
movapd %xmm0, 0x30(%rsp)
xorpd %xmm0, %xmm1
movapd %xmm1, 0x20(%rsp)
movsd 0x32aa(%rip), %xmm2     # 0xa0c0
movl $0x8, %r14d
xorl %r15d, %r15d
movzbl 0x60(%rbx), %eax
cmpl $0x45, %eax
je 0x6ecc
cmpl $0x53, %eax
je 0x6e84
cmpl $0x48, %eax
jne 0x6efc
movq 0xa0(%rbx), %rax
movsd (%rax,%r14), %xmm0
mulsd 0x8(%rsp), %xmm0
movsd -0x8(%rax,%r14), %xmm1
mulsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x8(%rax,%r14), %xmm0
mulsd 0x20(%rsp), %xmm0
addsd %xmm1, %xmm0
xorpd 0x31a9(%rip), %xmm0     # 0xa020
movsd %xmm2, 0x18(%rsp)
callq 0x23a0
jmp 0x6ec4
movq 0xa0(%rbx), %rax
movsd (%rax,%r14), %xmm0
mulsd 0x8(%rsp), %xmm0
movsd -0x8(%rax,%r14), %xmm1
mulsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x8(%rax,%r14), %xmm0
mulsd 0x30(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm2, 0x18(%rsp)
callq 0x21c0
movsd 0x18(%rsp), %xmm2
jmp 0x6efc
movq 0xa0(%rbx), %rax
movsd 0x10(%rsp), %xmm0
subsd -0x8(%rax,%r14), %xmm0
movsd 0x8(%rsp), %xmm1
subsd (%rax,%r14), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
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 0x6e1f
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x72d9(%rip)      # 0xe228
movq 0xe8(%rax), %r10
movslq 0x72d3(%rip), %rcx      # 0xe230
shlq $0x7, %rcx
movl 0x18(%r10,%rcx), %edx
movl %edx, 0x72c8(%rip)      # 0xe234
movl 0x1c(%r10,%rcx), %ecx
movl %ecx, 0x72c1(%rip)      # 0xe238
movslq 0xe0(%rax), %r11
movl %r11d, 0x72ab(%rip)     # 0xe230
movl $0x258, %ecx            # imm = 0x258
movl %ecx, 0x7380(%rip)      # 0xe310
movl %ecx, 0x737e(%rip)      # 0xe314
shlq $0x7, %r11
movl 0x7268(%rip), %ebx      # 0xe208
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, 0x7331(%rip)      # 0xe308
movq 0x724a(%rip), %rdi      # 0xe228
movl $0x8001, %edx           # imm = 0x8001
movq %rax, %rsi
callq 0x2100
movq 0x7236(%rip), %rdi      # 0xe228
movq 0xe8(%rdi), %rax
movslq 0x7230(%rip), %rcx      # 0xe230
shlq $0x7, %rcx
movq 0x48(%rax,%rcx), %rsi
movq %rsi, 0x72f0(%rip)      # 0xe300
movq 0x60(%rax,%rcx), %rdx
callq 0x20b0
movq 0x7207(%rip), %rdi      # 0xe228
movq 0x72d8(%rip), %rsi      # 0xe300
movq 0xe8(%rdi), %rax
movslq 0x71fa(%rip), %rcx      # 0xe230
shlq $0x7, %rcx
movq 0x58(%rax,%rcx), %rdx
callq 0x2250
movq 0x71dd(%rip), %rdi      # 0xe228
movq 0x72b6(%rip), %rsi      # 0xe308
popq %rbx
jmp 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/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 0x23d0(%rip), %rsi      # 0xa721
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 0x84a1
xorl %ebp, %ebp
leaq 0x2335(%rip), %r12      # 0xa6b8
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 0x2304(%rip), %rsi      # 0xa6b7
callq 0x2220
movq (%r14), %rcx
movq (%rcx,%r15), %rax
movq 0x8(%rcx,%r15), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
testl %ecx, %ecx
jle 0x8417
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 0x83dd
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x22fb(%rip), %rsi      # 0xa721
callq 0x2220
incq %rbp
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
movslq %ecx, %rdx
cmpq %rdx, %rbp
jl 0x8383
testl %ecx, %ecx
jle 0x84a1
xorl %r12d, %r12d
leaq 0x22bd(%rip), %r15      # 0xa721
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 0x8464
movb 0x60(%r14), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2220
leaq 0x2261(%rip), %r15      # 0xa721
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_O3/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 0x8e68
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 0x8ed4
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x8ee1
movq %r12, %rdi
leaq 0x30(%rsp), %rdx
callq 0x94a6
incq %r13
cmpq $0x3, %r13
jne 0x8e76
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x8dc8
incq %rbp
cmpq $0x3, %rbp
jne 0x8e57
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x8f1b
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 0x8f31
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x8f4b
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21f0
movq 0x8(%rsp), %rdi
callq 0x9106
movq %r14, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsp, %rdi
callq 0x936a
movq %rsp, %r14
movq (%r14), %r15
movq %r15, (%rbx)
movups 0x8(%r14), %xmm0
movups %xmm0, 0x8(%rbx)
xorl %r12d, %r12d
leaq 0x20(%rsp), %rdi
movq %r12, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movaps %xmm0, (%r14)
movq %r12, 0x10(%r14)
callq 0x9106
movq %r14, %rdi
callq 0x9106
movaps 0x105e(%rip), %xmm0     # 0xa020
movq (%r15,%r12), %rax
movsd 0x10(%rax), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, 0x10(%rax)
addq $0x18, %r12
cmpq $0x48, %r12
jne 0x8fc2
movq 0x30(%r15), %rax
xorl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rax,%rcx,8)
incq %rcx
cmpq $0x3, %rcx
jne 0x8fe2
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x9106
movq %r14, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fa1(%rip), %r14      # 0xdfd0
leaq 0x1a77(%rip), %rsi      # 0xaaad
movl $0xb, %edx
movq %r14, %rdi
callq 0x2220
movzbl 0xb8(%rbx), %esi
movq %r14, %rdi
callq 0x2360
leaq 0x12bd(%rip), %rsi      # 0xa316
movl $0x2, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x93a6
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 0x93d9
movsd (%rdx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x93e1
movq %r15, %rdi
callq 0x978a
addq $0x18, %rbp
cmpq $0x48, %rbp
jne 0x93b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8dc8
incq %r12
cmpq $0x3, %r12
jne 0x9396
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9415
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 0x9429
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9442
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x9106
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x28276
movq %rax, %r13
testq %rax, %rax
je 0x19bf1
movq %r12, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movl (%r14), %eax
cmpl $0x1, %eax
je 0x19b89
testl %eax, %eax
jne 0x19bc4
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 0x19bc4
movq (%r13), %rax
movq %r13, %rdi
callq *0x58(%rax)
movq %rax, %rdi
callq 0x2911a
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 0x19d90
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x19b2d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x19b2d
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x19c0a
movq %rax, %r14
jmp 0x19c28
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x19c24
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x19dce
movq %r14, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x133b7(%rip), %rsi     # 0x2d004
callq 0x28202
testq %rax, %rax
je 0x19cad
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x133fb(%rip), %rdx     # 0x2d061
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2a67c
movq (%rbx), %rdx
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a67c
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x19ca3
movq (%rdi), %rax
callq *0x58(%rax)
testq %rax, %rax
je 0x19ca3
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
jmp 0x19ca5
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x13356(%rip), %rdi     # 0x2d00a
leaq 0x13354(%rip), %rsi     # 0x2d00f
leaq 0x13366(%rip), %rcx     # 0x2d028
movl $0x1a, %edx
callq 0x5210
// File: /workspace/github_cpp_makefile_star2_O3/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 0x28276
testq %rax, %rax
je 0x19d57
movq %rax, %rbx
movq (%rax), %rax
movq %rbx, %rdi
callq *0x58(%rax)
movq %rax, %r12
movq %rax, %rdi
leaq 0x1337d(%rip), %rsi     # 0x2d08d
callq 0x288ba
movq %r13, %rdi
movq %rax, %rsi
leaq 0x7(%rsp), %rdx
callq 0x19e2c
movq %r14, %rdi
movq %r13, %rsi
callq 0x5060
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x19d4e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
testl %ebp, %ebp
jne 0x19ce7
movq %r12, %rax
jmp 0x19d59
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x19d87
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x55c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/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 0x1a8f1
movl %edx, %ebp
testl %r8d, %r8d
je 0x1a8ee
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 0x1a844
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 0x1a844
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 0x1a844
addl 0x4(%rsp), %eax
cmpl 0x8(%rsp), %eax
cmovgl (%rsp), %eax
cmpl %r13d, %eax
cmovgel %r13d, %eax
jmp 0x1a8f4
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_O3/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
je 0x1ada5
movq %rsi, %rbx
leaq 0x12369(%rip), %r12     # 0x2d0b4
movq 0x28(%r15), %rdx
movb $0x1, %r13b
cmpq 0x8(%rbx), %rdx
jne 0x1ad74
testq %rdx, %rdx
je 0x1ad71
movq (%rbx), %rsi
movq 0x20(%r15), %rdi
callq 0x5360
testl %eax, %eax
setne %r13b
jmp 0x1ad74
xorl %r13d, %r13d
movq 0x40(%r15), %rdi
movq %r12, %rsi
callq 0x24cf0
movl %eax, %ebp
xorb $0x1, %bpl
orb %r13b, %bpl
cmpb $0x1, %bpl
jne 0x1ad9f
movq %r15, %rdi
callq 0x5240
movq %rax, %r15
cmpq %r14, %rax
jne 0x1ad4b
xorb $0x1, %bpl
jmp 0x1ada7
xorl %ebp, %ebp
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_O3/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 0x12845(%rip), %rdx     # 0x2d623
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x19e74
movq 0x100(%r14), %r15
leaq 0xf0(%r14), %rbx
cmpq %rbx, %r15
je 0x1ae51
leaq 0x122b1(%rip), %r12     # 0x2d0b4
movq %rsp, %r13
leaq 0x127f9(%rip), %rbp     # 0x2d606
cmpq 0x100(%r14), %r15
je 0x1ae21
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5620
movq 0x40(%r15), %rdi
movq %r12, %rsi
callq 0x24cf0
testb %al, %al
je 0x1ae41
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 0x1ae0d
leaq 0x127cb(%rip), %rsi     # 0x2d623
movq %rsp, %rdi
callq 0x5110
movq 0x20(%rsp), %rbx
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testl %eax, %eax
je 0x1ae8c
movq (%rsp), %rax
leaq 0x10(%rsp), %rdx
cmpq %rdx, %rax
je 0x1aebb
movq %rax, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x1aec1
leaq 0x12790(%rip), %rdx     # 0x2d623
movq %rbx, %rdi
movq %rdx, %rsi
leaq 0x10(%rsp), %r14
callq 0x19e74
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1aeca
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
jmp 0x1aeca
movups (%rdx), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1aede
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1aefc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/src/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 0x1a0b6
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 0x1b152
leaq 0x8(%rsp), %r14
movq 0x1eeff(%rip), %r15     # 0x39fc0
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 0x1b131
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 0x1b0c1
leaq 0x48(%rsp), %rdi
callq 0x50a0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1b152
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1b169
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 0x1b191
movq %rax, %rbx
jmp 0x1b1ab
movq %rax, %rbx
jmp 0x1b1c2
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1b1ab
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1b1c2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5340
leaq 0x48(%rsp), %rdi
callq 0x50e0
movq %rbx, %rdi
callq 0x55c0