LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: HTR(double)
Matrix HTR(double dist){	// translation in hyperbolic plane along x axis
	// returns matrix c=cosh(dist), s=sinh(dist)
	// (c  0  s)
	// (0  1  0)
	// (s  0  c)
	Matrix M;
	vector<double> row;
	row.clear();
	row.push_back(cosh(dist));
	row.push_back(0.0);
	row.push_back(sinh(dist));
	M.e.push_back(row);
	row.clear();
	row.push_back(0.0);
	row.push_back(1.0);
	row.push_back(0.0);
	M.e.push_back(row);
	row.clear();
	row.push_back(sinh(dist));
	row.push_back(0.0);
	row.push_back(cosh(dist));
	M.e.push_back(row);
	return(M);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm1, %xmm1
movups %xmm1, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %r14
movaps %xmm1, (%r14)
andq $0x0, 0x10(%r14)
movsd %xmm0, 0x30(%rsp)
callq 0x22a0
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x7d62
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
movsd 0x30(%rsp), %xmm0
callq 0x21b0
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x2d0b
movq %rax, 0x18(%rsp)
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x2d6b
movq %rax, 0x18(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x21b0
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
movsd 0x30(%rsp), %xmm0
callq 0x22a0
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
leaq 0x10(%rsp), %rdi
callq 0x7b58
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x2dee
jmp 0x2dee
jmp 0x2dee
jmp 0x2dee
jmp 0x2dee
jmp 0x2dee
jmp 0x2dee
jmp 0x2dee
jmp 0x2dee
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x7b58
movq %rbx, %rdi
callq 0x78f0
movq %r14, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: ETR(double)
Matrix ETR(double dist){	//  translation in Euclidean plane along x axis
	// returns matrix
	// (1 0 d)
	// (0 1 0)
	// (0 0 1)
	Matrix M;
	vector<double> row;
	row.clear();
	row.push_back(1.0);
	row.push_back(0.0);
	row.push_back(dist);
	M.e.push_back(row);
	row.clear();
	row.push_back(0.0);
	row.push_back(1.0);
	row.push_back(0.0);
	M.e.push_back(row);
	row.clear();
	row.push_back(0.0);
	row.push_back(0.0);
	row.push_back(1.0);
	M.e.push_back(row);
	return(M);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %rdi
andq $0x0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movabsq $0x3ff0000000000000, %r14 # imm = 0x3FF0000000000000
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
callq 0x7d62
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x758c
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x2e8a
movq %rax, 0x18(%rsp)
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x2ee0
movq %rax, 0x18(%rsp)
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
leaq 0x10(%rsp), %rdi
callq 0x7b58
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x2f4a
jmp 0x2f4a
jmp 0x2f4a
jmp 0x2f4a
jmp 0x2f4a
jmp 0x2f4a
jmp 0x2f4a
jmp 0x2f4a
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x7b58
movq %rbx, %rdi
callq 0x78f0
movq %r14, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: DIL(double)
Matrix DIL(double t){	//  dilation by t in Euclidean plane centered at 0
	// returns matrix
	// (t 0 0)
	// (0 t 0)
	// (0 0 1)
	Matrix M;
	vector<double> row;
	row.clear();
	row.push_back(t);
	row.push_back(0.0);
	row.push_back(0.0);
	M.e.push_back(row);
	row.clear();
	row.push_back(0.0);
	row.push_back(t);
	row.push_back(0.0);
	M.e.push_back(row);
	row.clear();
	row.push_back(0.0);
	row.push_back(0.0);
	row.push_back(1.0);
	M.e.push_back(row);
	return(M);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %rsi
movsd %xmm0, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x758c
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x2fdb
movq %rax, 0x18(%rsp)
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x758c
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x302e
movq %rax, 0x18(%rsp)
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
leaq 0x10(%rsp), %rdi
callq 0x7b58
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x30a0
jmp 0x30a0
jmp 0x30a0
jmp 0x30a0
jmp 0x30a0
jmp 0x30a0
jmp 0x30a0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x7b58
movq %rbx, %rdi
callq 0x78f0
movq %r14, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: hyp_ang(Point)
double hyp_ang(Point P){	// hyperbolic angle from origin; also works as Euclidean angle
	double d;
	d=hyp_dist(P);
	if(d==0.0){
		return(0.0);
	};
	return(atan2(P.y,P.x));
}

// Assembly:
pushq %rax
movsd 0x20(%rsp), %xmm0
movsd 0x5f9f(%rip), %xmm1     # 0x9088
ucomisd %xmm0, %xmm1
ja 0x3100
callq 0x23b0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3106
jp 0x3106
xorpd %xmm0, %xmm0
popq %rax
retq
leaq 0x10(%rsp), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
popq %rax
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O2/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
sqrtsd %xmm3, %xmm2
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm2
jne 0x314f
jp 0x314f
xorpd %xmm0, %xmm0
retq
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O2/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: Euclidean_to_sphere(Point)
Point Euclidean_to_sphere(Point Q){
	Point R;
	R.x=2.0*Q.x/(1.0+Q.x*Q.x+Q.y*Q.y);
	R.y=2.0*Q.y/(1.0+Q.x*Q.x+Q.y*Q.y);
	R.z=(1.0-Q.x*Q.x-Q.y*Q.y)/(1.0+Q.x*Q.x+Q.y*Q.y);
	return(R);
}

// Assembly:
movq %rdi, %rax
movapd 0x8(%rsp), %xmm0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd 0x5e23(%rip), %xmm2     # 0x9088
movapd %xmm1, %xmm3
addsd %xmm2, %xmm3
movapd %xmm0, %xmm4
unpckhpd %xmm0, %xmm4            # xmm4 = xmm4[1],xmm0[1]
mulsd %xmm4, %xmm4
addsd %xmm4, %xmm3
addpd %xmm0, %xmm0
subsd %xmm1, %xmm2
subsd %xmm4, %xmm2
divsd %xmm3, %xmm2
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
divpd %xmm3, %xmm0
movupd %xmm0, (%rdi)
movsd %xmm2, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: hyperboloid_to_sphere(Point)
Point hyperboloid_to_sphere(Point P){
	Point Q,R;
	Q=hyperboloid_to_Poincare(P);
//	R.x=2.0*Q.x/(1.0+Q.x*Q.x+Q.y*Q.y);
//	R.y=2.0*Q.y/(1.0+Q.x*Q.x+Q.y*Q.y);
//	R.z=(1.0-Q.x*Q.x-Q.y*Q.y)/(1.0+Q.x*Q.x+Q.y*Q.y);
	R=Euclidean_to_sphere(Q);
	return(R);
}

// Assembly:
movq %rdi, %rax
movsd 0x5dde(%rip), %xmm0     # 0x9088
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd 0x8(%rsp), %xmm2
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm2
movapd %xmm2, %xmm1
mulsd %xmm2, %xmm1
movapd %xmm1, %xmm3
addsd %xmm0, %xmm3
movapd %xmm2, %xmm4
unpckhpd %xmm2, %xmm4            # xmm4 = xmm4[1],xmm2[1]
mulsd %xmm4, %xmm4
addsd %xmm4, %xmm3
addpd %xmm2, %xmm2
subsd %xmm1, %xmm0
subsd %xmm4, %xmm0
divsd %xmm3, %xmm0
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
divpd %xmm3, %xmm2
movupd %xmm2, (%rdi)
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
imulq $0x18, %rax, %rax
movq (%rsi,%rax), %rcx
movq 0x8(%rsi,%rax), %rax
subq %rcx, %rax
shrq $0x2, %rax
movslq %eax, %rdi
xorl %esi, %esi
pushq $-0x1
popq %rax
cmpq %rdi, %rsi
jge 0x3337
cmpl %edx, (%rcx,%rsi,4)
je 0x3335
incq %rsi
jmp 0x3326
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rax
cmpq %rax, 0x50(%rdi)
je 0x3355
movq %rax, 0x50(%rbx)
leaq 0x48(%rbx), %r14
pushq $0x1
popq %rbp
pushq $0x18
popq %r12
leaq 0xc(%rsp), %r15
movl %ebp, 0xc(%rsp)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r12
cmpl %eax, %ebp
jge 0x33a1
movl 0xbc(%rbx), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3304
cmpl $-0x1, %eax
jne 0x339d
movq %r14, %rdi
movq %r15, %rsi
callq 0x75ae
movl 0xc(%rsp), %ebp
incl %ebp
jmp 0x3365
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
movq 0x30(%rdi), %rax
cmpq %rax, 0x38(%rdi)
je 0x33d0
movq %rax, 0x38(%rbx)
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7d62
xorl %r12d, %r12d
pushq $0x18
popq %r13
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r13
cltq
cmpq %rax, %r12
jge 0x342b
movq 0x18(%rbx), %rax
movsd (%rax,%r12,8), %xmm0
mulsd 0x5c80(%rip), %xmm0     # 0x9090
callq 0x23d0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7d62
incq %r12
jmp 0x33eb
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3791
cmpl $0x48, %edi
je 0x3728
cmpl $0x45, %edi
jne 0x3815
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 0x3808
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x21b0
xorps 0x58da(%rip), %xmm0     # 0x9020
movaps %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x21b0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x22a0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x22a0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x22a0
jmp 0x37f2
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 0x23e0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x23e0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x23e0
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_O2/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::wedge(int, int)
double Packing::wedge(int i,int e){	// angle at vertex i between edge e and e+1
	int j,k;	// i -e-> j, i -(e+1)-> k
	j=adj[i][e];
	k=adj[i][(e+1)%adj[i].size()];	
	return(angle_at_C(rad[i]+rad[j],rad[i]+rad[k],rad[j]+rad[k],geometry));
}

// Assembly:
movslq %esi, %rcx
imulq $0x18, %rcx, %rax
movslq %edx, %rdx
movq (%rdi), %rsi
movq 0x18(%rdi), %r8
movq (%rsi,%rax), %r9
movq 0x8(%rsi,%rax), %rsi
movslq (%r9,%rdx,4), %r10
incl %edx
movslq %edx, %rax
subq %r9, %rsi
sarq $0x2, %rsi
xorl %edx, %edx
divq %rsi
movslq (%r9,%rdx,4), %rax
movsd (%r8,%rcx,8), %xmm1
movsd (%r8,%r10,8), %xmm2
movapd %xmm1, %xmm0
addsd %xmm2, %xmm0
movsd (%r8,%rax,8), %xmm3
addsd %xmm3, %xmm1
addsd %xmm3, %xmm2
movsbl 0x60(%rdi), %edi
jmp 0x36e0
// File: /workspace/github_cpp_makefile_star2_O2/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
imulq $0x18, %rcx, %rax
movslq %edx, %rdx
movq (%rdi), %rsi
movq 0x30(%rdi), %rdi
movq (%rsi,%rax), %r8
movq 0x8(%rsi,%rax), %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 0x57c0(%rip), %xmm0     # 0x9088
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 0x5750(%rip), %xmm1     # 0x9040
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 0x3914
sqrtsd %xmm0, %xmm0
jmp 0x3919
callq 0x2170
callq 0x2380
addsd %xmm0, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %rax
xorpd %xmm0, %xmm0
xorl %ebp, %ebp
imulq $0x18, %rax, %r15
movq (%r14), %rax
movq 0x8(%rax,%r15), %rcx
subq (%rax,%r15), %rcx
shrq $0x2, %rcx
cmpl %ecx, %ebp
jge 0x3990
movsd %xmm0, (%rsp)
movzbl 0x60(%r14), %eax
cmpl $0x53, %eax
je 0x3965
cmpl $0x45, %eax
jne 0x3973
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x381e
jmp 0x397f
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x387c
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
incl %ebp
jmp 0x393d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::fitness()
double Packing::fitness(){
	int i;
	double fitness;
	fitness=0.0;
	for(i=0;i<(int) adj.size();i++){
		fitness=fitness+fabs(TWOPI-angle(i));
	};
	return(fitness);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
xorl %ebp, %ebp
pushq $0x18
popq %r14
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r14
cmpl %eax, %ebp
jge 0x39f3
movq %rbx, %rdi
movl %ebp, %esi
movsd %xmm0, 0x8(%rsp)
callq 0x3924
movsd 0x56c7(%rip), %xmm1     # 0x90a0
subsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
andpd 0x5665(%rip), %xmm1     # 0x9050
addsd %xmm1, %xmm0
incl %ebp
jmp 0x39b1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::interior_fitness()
double Packing::interior_fitness(){
	int i;
	double fitness;
	fitness=0.0;
	for(i=0;i<(int) adj.size();i++){
		if(i!=INFV && which_edge(i,INFV)==-1){	// i is not equal to or adjacent to INFV
			fitness=fitness+fabs(TWOPI-angle(i));
		};
	};
	return(fitness);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %ebp, %ebp
pushq $0x18
popq %r14
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r14
cmpl %eax, %ebp
jge 0x3a72
movl 0xbc(%rbx), %edx
cmpl %edx, %ebp
je 0x3a6e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3304
cmpl $-0x1, %eax
jne 0x3a6e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3924
movsd 0x564e(%rip), %xmm1     # 0x90a0
subsd %xmm0, %xmm1
andpd 0x55f2(%rip), %xmm1     # 0x9050
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
incl %ebp
jmp 0x3a17
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
imulq $0x18, %rbx, %rcx
movq 0x8(%rax,%rcx), %rdx
subq (%rax,%rcx), %rdx
sarq $0x2, %rdx
movq %rdx, %xmm0
punpckldq 0x55b0(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x55b8(%rip), %xmm0     # 0x9070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movl %ebx, %esi
callq 0x3924
movapd 0x10(%rsp), %xmm1
addsd %xmm1, %xmm1
movapd %xmm1, 0x10(%rsp)
divsd %xmm1, %xmm0
callq 0x2060
movsd %xmm0, 0x8(%rsp)
movsd 0x55a8(%rip), %xmm0     # 0x90a0
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 0x3b49
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 0x3b78
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 0x54dc(%rip), %xmm5     # 0x9088
subsd %xmm0, %xmm5
movsd 0x54f0(%rip), %xmm2     # 0x90a8
mulsd %xmm3, %xmm2
mulsd %xmm3, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm5, %xmm0
mulsd %xmm5, %xmm0
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x3bdc
sqrtsd %xmm0, %xmm0
jmp 0x3bf9
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_O2/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
imulq $0x18, %rbx, %rcx
movq 0x8(%rax,%rcx), %rdx
subq (%rax,%rcx), %rdx
sarq $0x2, %rdx
movq %rdx, %xmm0
punpckldq 0x541c(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x5424(%rip), %xmm0     # 0x9070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
movl %ebx, %esi
callq 0x3924
movapd (%rsp), %xmm1
addsd %xmm1, %xmm1
movapd %xmm1, (%rsp)
divsd %xmm1, %xmm0
callq 0x2060
movsd %xmm0, 0x10(%rsp)
movsd 0x5417(%rip), %xmm0     # 0x90a0
divsd (%rsp), %xmm0
callq 0x2060
movq 0x18(%r14), %rax
movsd (%rax,%rbx,8), %xmm1
movsd 0x10(%rsp), %xmm4
mulsd %xmm4, %xmm1
movsd 0x53da(%rip), %xmm2     # 0x9088
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_O2/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 0x8f33(%rip), %rdi      # 0xcfd0
leaq 0x58f1(%rip), %rsi      # 0x9995
callq 0x21e0
movsbl 0x60(%rbx), %esi
movq %rax, %rdi
callq 0x2230
leaq 0x5675(%rip), %rsi      # 0x9731
movq %rax, %rdi
callq 0x21e0
cmpb $0x48, 0x60(%rbx)
jne 0x4191
movq 0x8efb(%rip), %r14      # 0xcfd0
leaq 0x51cc(%rip), %r15      # 0x92a8
movq %r14, %rdi
movq %r15, %rsi
callq 0x21e0
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
callq 0x23a0
leaq 0x51b5(%rip), %rsi      # 0x92b0
movq %rax, %rdi
callq 0x21e0
pushq $0x18
popq %rbp
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %rbp
cltq
cmpq %rax, %r12
jge 0x4207
movl 0xbc(%rbx), %r13d
movq %r14, %rdi
movq %r15, %rsi
callq 0x21e0
cmpq %r13, %r12
jne 0x414e
movl 0xbc(%rbx), %esi
movq %rax, %rdi
callq 0x23a0
movq %rax, %rdi
leaq 0x5164(%rip), %rsi      # 0x92b0
jmp 0x4184
movq %rax, %rdi
movl %r12d, %esi
callq 0x23a0
movq %rax, %rdi
leaq 0x5164(%rip), %rsi      # 0x92c7
callq 0x21e0
movq 0x18(%rbx), %rcx
movsd (%rcx,%r12,8), %xmm0
movq %rax, %rdi
callq 0x2340
movq %rax, %rdi
leaq 0x55ad(%rip), %rsi      # 0x9731
callq 0x21e0
incq %r12
jmp 0x4106
xorl %r14d, %r14d
pushq $0x18
popq %r15
leaq 0x5109(%rip), %r12      # 0x92a8
leaq 0x5121(%rip), %r13      # 0x92c7
leaq 0x5584(%rip), %rbp      # 0x9731
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r15
cltq
cmpq %rax, %r14
jge 0x4207
movq 0x8e09(%rip), %rdi      # 0xcfd0
movq %r12, %rsi
callq 0x21e0
movq %rax, %rdi
movl %r14d, %esi
callq 0x23a0
movq %rax, %rdi
movq %r13, %rsi
callq 0x21e0
movq 0x18(%rbx), %rcx
movsd (%rcx,%r14,8), %xmm0
movq %rax, %rdi
callq 0x2340
movq %rax, %rdi
movq %rbp, %rsi
callq 0x21e0
incq %r14
jmp 0x41ad
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::read_packing(std::basic_ifstream<char, std::char_traits<char>>&)
void Packing::read_packing(ifstream &packing_file){	// read packing from a file
	/* should give the option of reading radii, geometry, INFV and ZERV; these are commented out */
	int vertices, valence, i, j, k;
	vector<int> L;	// adjacency_list
//	double d;
//	char c;
//	int I;
	adj.clear();				// initialize, in case we already have a packing
	packing_file >> vertices;	// reading adj
	for(i=0;i<vertices;i++){
		packing_file >> valence;
		for(j=0;j<valence;j++){
			packing_file >> k;
			L.push_back(k);
		};
		adj.push_back(L);
		L.clear();
	};
	
	/* for the moment, just sets radii all to 0.1 and sets geometry to 'H', INFV to 0 and ZERV to -1 */
//	if(packing_file.eof()){	// didn't bother to set radii
		for(i=0;i<vertices;i++){ 
			rad.push_back(0.01);	// setting all initial radii to 0.01; default value
		};
//	} else {
	//	for(i=0;i<vertices;i++){
	//		packing_file >> d;	// reading radii; 
	//	};
//	};

//	if(packing_file.eof()){	// default values - old format
		geometry='H';		
		INFV=0;
		ZERV=-1;
//	} else {
//		packing_file >> c;	// reading geometry
//		geometry=c;
//		packing_file >> I;	// reading INFV
//		INFV=I;
//		packing_file >> I;	// reading ZERV
//		ZERV=I;
//	};
	verbose=true;			//	default values
	VIEWMATRIX=ROT(0.0);	//	default values
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
callq 0x75cc
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x20f0
xorl %ebp, %ebp
leaq 0x2c(%rsp), %r12
leaq 0x10(%rsp), %r13
movl 0x8(%rsp), %eax
cmpl %eax, %ebp
jge 0x42b0
movq %r14, %rdi
leaq 0xc(%rsp), %rsi
callq 0x20f0
xorl %r15d, %r15d
cmpl 0xc(%rsp), %r15d
jge 0x4290
movq %r14, %rdi
movq %r12, %rsi
callq 0x20f0
movq %r13, %rdi
movq %r12, %rsi
callq 0x75ae
incl %r15d
jmp 0x426e
movq %rbx, %rdi
movq %r13, %rsi
callq 0x75d4
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x42ac
movq %rax, 0x18(%rsp)
incl %ebp
jmp 0x4256
leaq 0x18(%rbx), %r14
xorl %ebp, %ebp
movabsq $0x3f847ae147ae147b, %r12 # imm = 0x3F847AE147AE147B
leaq 0x30(%rsp), %r15
cmpl %eax, %ebp
jge 0x42e1
movq %r12, 0x30(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7d62
incl %ebp
movl 0x8(%rsp), %eax
jmp 0x42c5
movb $0x48, 0x60(%rbx)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0xbc(%rbx)
movb $0x1, 0xb8(%rbx)
leaq 0x30(%rsp), %rdi
xorps %xmm0, %xmm0
callq 0x279b
addq $0xc8, %rbx
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x797e
movq %r14, %rdi
callq 0x78f0
leaq 0x10(%rsp), %rdi
callq 0x82b4
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x434a
jmp 0x434a
jmp 0x434a
jmp 0x434a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x82b4
movq %rbx, %rdi
callq 0x23c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dannycalegari[P]circle_pack/./Layout_routine.cc
// Function: Packing::compute_distances_to_vertex_INFV()
void Packing::compute_distances_to_vertex_INFV(){
	bool all_found, one_not_done;
	int i,j,nearest;
	if(verbose){
		cout << "computing distances to vertex 0.\n";
	};
	dist.clear();				// clear distance list
	maximum_distance=0;					// reset maximum
	for(i=0;i<(int) adj.size();i++){	// initialize distances
		dist.push_back(-1);
	};
	dist[INFV]=0;	// initial vertex
	all_found=false;
	while(all_found==false){
		one_not_done=false;
		for(i=0;i<(int) adj.size();i++){	// for each vertex i
			if(dist[i]==-1){		// if we don't yet know the distance to 0
				one_not_done=true;			// note this fact
				nearest=1000000;			// initialize guess
				for(j=0;j<(int) adj[i].size();j++){	// for all neighbors of i
					if(dist[adj[i][j]]!=-1){
						nearest=nearest < dist[adj[i][j]] ? nearest : dist[adj[i][j]];
					};
				};
				if(nearest<1000000){		// if we found a neighbor
					dist[i]=nearest+1;
					maximum_distance= maximum_distance > nearest+1 ? maximum_distance : nearest+1;	// let's remember this while we're at it
				};
			};
		};
		if(one_not_done==false){
			all_found=true;
		};
	};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x1, 0xb8(%rdi)
jne 0x438b
movq 0x8c51(%rip), %rdi      # 0xcfd0
leaq 0x4f4e(%rip), %rsi      # 0x92d4
callq 0x21e0
movq 0x80(%rbx), %rax
cmpq %rax, 0x88(%rbx)
je 0x43a2
movq %rax, 0x88(%rbx)
andl $0x0, 0x98(%rbx)
leaq 0x80(%rbx), %r14
xorl %ebp, %ebp
pushq $0x18
popq %r12
leaq 0xc(%rsp), %r15
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r12
cmpl %eax, %ebp
jge 0x43e2
orl $-0x1, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x8580
incl %ebp
jmp 0x43bb
movslq 0xbc(%rbx), %rsi
movq 0x80(%rbx), %rdx
andl $0x0, (%rdx,%rsi,4)
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
pushq $0x1
popq %rdi
xorl %r8d, %r8d
testb $0x1, %r8b
jne 0x44a1
xorl %r9d, %r9d
xorl %r11d, %r11d
cmpq %rax, %r9
je 0x4490
cmpl $-0x1, (%rdx,%r9,4)
jne 0x448b
imulq $0x18, %r9, %r10
movq (%rcx,%r10), %r11
movq 0x8(%rcx,%r10), %r14
subq %r11, %r14
shrq $0x2, %r14
testl %r14d, %r14d
cmovlel %esi, %r14d
movl $0xf4240, %r10d         # imm = 0xF4240
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x4464
movslq (%r11,%r15,4), %r12
movl (%rdx,%r12,4), %ebp
cmpl %ebp, %r10d
movl %ebp, %r12d
cmovll %r10d, %r12d
cmpl $-0x1, %ebp
cmovnel %r12d, %r10d
incq %r15
jmp 0x4441
movb $0x1, %r11b
cmpl $0xf423f, %r10d         # imm = 0xF423F
jg 0x448b
incl %r10d
movl %r10d, (%rdx,%r9,4)
movl 0x98(%rbx), %ebp
cmpl %r10d, %ebp
cmovgl %ebp, %r10d
movl %r10d, 0x98(%rbx)
incq %r9
jmp 0x4411
testb $0x1, %r11b
movzbl %r8b, %r8d
cmovel %edi, %r8d
jmp 0x4401
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r14d, %r14d
leaq 0x4e42(%rip), %r12      # 0x9308
leaq 0x4e29(%rip), %r13      # 0x92f6
leaq 0x4e30(%rip), %rbp      # 0x9304
leaq 0x4e35(%rip), %r15      # 0x9310
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cltq
movq 0x8add(%rip), %rdi      # 0xcfd0
cmpq %rax, %r14
jge 0x4552
movq %r12, %rsi
callq 0x21e0
movq %rax, %rdi
movl %r14d, %esi
callq 0x23a0
movq %rax, %rdi
movq %r13, %rsi
callq 0x21e0
movq 0x80(%rbx), %rcx
movl (%rcx,%r14,4), %esi
movq %rax, %rdi
callq 0x23a0
movq %rax, %rdi
movq %rbp, %rsi
callq 0x21e0
movl 0xbc(%rbx), %esi
movq %rax, %rdi
callq 0x23a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21e0
incq %r14
jmp 0x44db
leaq 0x4dd0(%rip), %rsi      # 0x9329
callq 0x21e0
movl 0x98(%rbx), %esi
movq %rax, %rdi
callq 0x23a0
leaq 0x51be(%rip), %rsi      # 0x9731
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %rdi
cqto
idivq %rdi
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
imulq $0x18, %rax, %rdi
xorl %eax, %eax
cmpq %rdx, %rdi
je 0x45c3
movq (%rcx,%rdx), %r8
cmpl %esi, (%r8)
sete %r8b
orb %r8b, %al
addq $0x18, %rdx
jmp 0x45aa
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x1, 0xb8(%rdi)
jne 0x4d47
movq 0x8295(%rip), %rdi      # 0xcfd0
leaq 0x464a(%rip), %rsi      # 0x938c
callq 0x21e0
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x10(%r14)
leaq 0xa0(%rbx), %r15
xorl %ebp, %ebp
pushq $0x18
popq %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r12
cmpl %eax, %ebp
jge 0x4d8b
movq %r15, %rdi
movq %r14, %rsi
callq 0x7836
incl %ebp
jmp 0x4d6c
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8051(%rip), %r14      # 0xcfd0
leaq 0x4a0f(%rip), %rsi      # 0x9995
movq %r14, %rdi
callq 0x21e0
movsbl 0x60(%rbx), %esi
movq %rax, %rdi
callq 0x2230
leaq 0x4790(%rip), %rsi      # 0x9731
movq %rax, %rdi
callq 0x21e0
xorl %r13d, %r13d
leaq 0x4411(%rip), %rbp      # 0x93c4
leaq 0x470e(%rip), %r12      # 0x96c8
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cltq
cmpq %rax, %r15
jge 0x5088
movl 0xbc(%rbx), %eax
cmpq %rax, %r15
jne 0x4ff1
movq %r14, %rdi
leaq 0x43d2(%rip), %rsi      # 0x93be
callq 0x21e0
movq %r14, %rdi
leaq 0x430d(%rip), %rsi      # 0x9308
callq 0x21e0
movq %rax, %rdi
movl %r15d, %esi
callq 0x23a0
movq %rax, %rdi
movq %rbp, %rsi
callq 0x21e0
movq 0xa0(%rbx), %rcx
movsd (%rcx,%r13), %xmm0
movq %rax, %rdi
callq 0x2340
movq %rax, %rdi
movq %r12, %rsi
callq 0x21e0
movq 0xa0(%rbx), %rcx
movsd 0x8(%rcx,%r13), %xmm0
movq %rax, %rdi
callq 0x2340
movq %rax, %rdi
movq %r12, %rsi
callq 0x21e0
movq 0xa0(%rbx), %rcx
movsd 0x10(%rcx,%r13), %xmm0
movq %rax, %rdi
callq 0x2340
movq %rax, %rdi
leaq 0x46ba(%rip), %rsi      # 0x9731
callq 0x21e0
incq %r15
addq $0x18, %r13
jmp 0x4fbd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %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 0x3516(%rip), %xmm1     # 0x9020
movapd %xmm0, 0x30(%rsp)
xorpd %xmm0, %xmm1
movapd %xmm1, 0x20(%rsp)
movsd 0x35ae(%rip), %xmm2     # 0x90d0
pushq $0x8
popq %r14
xorl %r15d, %r15d
pushq $0x18
popq %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r12
cltq
cmpq %rax, %r15
jge 0x5c41
movzbl 0x60(%rbx), %eax
cmpl $0x45, %eax
je 0x5bf1
cmpl $0x53, %eax
je 0x5ba9
cmpl $0x48, %eax
jne 0x5c21
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 0x3484(%rip), %xmm0     # 0x9020
movsd %xmm2, 0x18(%rsp)
callq 0x23b0
jmp 0x5be9
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 0x5c21
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
addq $0x18, %r14
movapd %xmm1, %xmm2
jmp 0x5b2d
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2290
movq %rax, 0x75d1(%rip)      # 0xd230
movq 0xe8(%rax), %r10
movslq 0x75cb(%rip), %rcx      # 0xd238
shlq $0x7, %rcx
movl 0x18(%r10,%rcx), %edx
movl %edx, 0x75c0(%rip)      # 0xd23c
movl 0x1c(%r10,%rcx), %ecx
movl %ecx, 0x75b9(%rip)      # 0xd240
movslq 0xe0(%rax), %r11
movl %r11d, 0x75a3(%rip)     # 0xd238
movl $0x258, %ecx            # imm = 0x258
movl %ecx, 0x7678(%rip)      # 0xd318
movl %ecx, 0x7676(%rip)      # 0xd31c
shlq $0x7, %r11
movl 0x7560(%rip), %ebx      # 0xd210
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, 0x7629(%rip)      # 0xd310
movq 0x7542(%rip), %rdi      # 0xd230
movl $0x8001, %edx           # imm = 0x8001
movq %rax, %rsi
callq 0x2100
movq 0x752e(%rip), %rdi      # 0xd230
movq 0xe8(%rdi), %rax
movslq 0x7528(%rip), %rcx      # 0xd238
shlq $0x7, %rcx
movq 0x48(%rax,%rcx), %rsi
movq %rsi, 0x75e8(%rip)      # 0xd308
movq 0x60(%rax,%rcx), %rdx
callq 0x20a0
movq 0x74ff(%rip), %rdi      # 0xd230
movq 0x75d0(%rip), %rsi      # 0xd308
movq 0xe8(%rdi), %rax
movslq 0x74f2(%rip), %rcx      # 0xd238
shlq $0x7, %rcx
movq 0x58(%rax,%rcx), %rdx
callq 0x2260
movq 0x74d5(%rip), %rdi      # 0xd230
movq 0x75ae(%rip), %rsi      # 0xd310
popq %rbx
jmp 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %rbp
cqto
idivq %rbp
movq %rsi, %rdi
movl %eax, %esi
callq 0x23a0
leaq 0x2a58(%rip), %rsi      # 0x9731
movq %rax, %rdi
callq 0x21e0
xorl %r15d, %r15d
leaq 0x29dd(%rip), %r13      # 0x96c8
movq (%r14), %rdi
movq 0x8(%r14), %rcx
movq %rcx, %rax
subq %rdi, %rax
cqto
idivq %rbp
cltq
cmpq %rax, %r15
jge 0x6d7e
imulq $0x18, %r15, %r12
movq 0x8(%rdi,%r12), %rsi
subq (%rdi,%r12), %rsi
shrq $0x2, %rsi
movq %rbx, %rdi
callq 0x23a0
movq %rax, %rdi
leaq 0x29a0(%rip), %rsi      # 0x96c7
callq 0x21e0
xorl %ebp, %ebp
movq (%r14), %rcx
movq (%rcx,%r12), %rax
movq 0x8(%rcx,%r12), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbp
jge 0x6d64
movl (%rax,%rbp,4), %esi
movq %rbx, %rdi
callq 0x23a0
movq %rax, %rdi
movq %r13, %rsi
callq 0x21e0
incq %rbp
jmp 0x6d2e
movq %rbx, %rdi
leaq 0x29c3(%rip), %rsi      # 0x9731
callq 0x21e0
incq %r15
pushq $0x18
popq %rbp
jmp 0x6ceb
xorl %r12d, %r12d
leaq 0x29a9(%rip), %r15      # 0x9731
subq %rdi, %rcx
movq %rcx, %rax
cqto
idivq %rbp
cltq
cmpq %rax, %r12
jge 0x6dc3
movq 0x18(%r14), %rax
movsd (%rax,%r12,8), %xmm0
movq %rbx, %rdi
callq 0x2340
movq %rax, %rdi
movq %r15, %rsi
callq 0x21e0
incq %r12
movq (%r14), %rdi
movq 0x8(%r14), %rcx
jmp 0x6d88
movsbl 0x60(%r14), %esi
movq %rbx, %rdi
callq 0x2230
leaq 0x295a(%rip), %r15      # 0x9731
movq %rax, %rdi
movq %r15, %rsi
callq 0x21e0
movl 0xbc(%r14), %esi
movq %rbx, %rdi
callq 0x23a0
movq %rax, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: Matrix::operator()(Point)
Point operator()(Point P){
			Point Q;
			Q.x = P.x*e[0][0]+P.y*e[0][1]+P.z*e[0][2];
			Q.y = P.x*e[1][0]+P.y*e[1][1]+P.z*e[1][2];
			Q.z = P.x*e[2][0]+P.y*e[2][1]+P.z*e[2][2];
			return(Q);
		}

// Assembly:
movq %rdi, %rax
movq (%rsi), %rcx
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
movq (%rcx), %rdx
movq 0x18(%rcx), %rsi
movapd %xmm2, %xmm3
unpcklpd %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0]
movsd (%rdx), %xmm4
movsd 0x8(%rdx), %xmm5
movsd 0x10(%rdx), %xmm6
movhpd 0x8(%rsi), %xmm5        # xmm5 = xmm5[0],mem[0]
mulpd %xmm3, %xmm5
movapd %xmm0, %xmm3
unpcklpd %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0]
movhpd (%rsi), %xmm4           # xmm4 = xmm4[0],mem[0]
mulpd %xmm3, %xmm4
addpd %xmm5, %xmm4
movapd %xmm1, %xmm3
unpcklpd %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0]
movhpd 0x10(%rsi), %xmm6       # xmm6 = xmm6[0],mem[0]
mulpd %xmm3, %xmm6
addpd %xmm4, %xmm6
movupd %xmm6, (%rdi)
movq 0x30(%rcx), %rcx
mulsd 0x8(%rcx), %xmm2
mulsd (%rcx), %xmm0
mulsd 0x10(%rcx), %xmm1
addsd %xmm2, %xmm0
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
xorpd %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %r12
andq $0x0, 0x10(%r12)
movq %rdi, 0x8(%rsp)
movupd %xmm0, (%rdi)
movapd %xmm0, (%r12)
xorl %ecx, %ecx
leaq 0x30(%rsp), %r13
cmpq $0x3, %rcx
je 0x7760
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x76e5
movq %rax, 0x18(%rsp)
movq %rcx, 0x28(%rsp)
imulq $0x18, %rcx, %rbx
xorl %ebp, %ebp
cmpq $0x3, %rbp
je 0x7746
movq (%r15), %rax
movq (%rax,%rbx), %rax
movq (%r14), %rcx
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movq (%rcx), %rdx
movq 0x18(%rcx), %rsi
mulsd (%rsi,%rbp,8), %xmm1
mulsd (%rdx,%rbp,8), %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%rax), %xmm1
movq 0x30(%rcx), %rax
mulsd (%rax,%rbp,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x30(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x7d62
incq %rbp
jmp 0x76f0
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x7560
movq 0x28(%rsp), %rcx
incq %rcx
jmp 0x76ca
leaq 0x10(%rsp), %rdi
callq 0x7b58
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7780
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x7b58
movq 0x8(%rsp), %rdi
callq 0x78f0
movq %r14, %rdi
callq 0x23c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsp, %rdi
callq 0x7bee
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x797e
movq %r14, %rdi
callq 0x78f0
movq (%rbx), %rax
xorl %ecx, %ecx
movaps 0x1841(%rip), %xmm0     # 0x9020
cmpq $0x48, %rcx
je 0x77fb
movq (%rax,%rcx), %rdx
movsd 0x10(%rdx), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, 0x10(%rdx)
addq $0x18, %rcx
jmp 0x77df
movq 0x30(%rax), %rax
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x7818
movsd (%rax,%rcx,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rax,%rcx,8)
incq %rcx
jmp 0x7801
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x78f0
movq %r14, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
xorb $0x1, 0xb8(%rdi)
movq 0x5762(%rip), %rdi      # 0xcfd0
leaq 0x2248(%rip), %rsi      # 0x9abd
callq 0x21e0
movzbl 0xb8(%rbx), %esi
movq %rax, %rdi
callq 0x2370
leaq 0x1a96(%rip), %rsi      # 0x9326
movq %rax, %rdi
popq %rbx
jmp 0x21e0
nop