LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: XZ_ROT(double)
Matrix XZ_ROT(double angle){	// rotation in xz-plane
	// returns matrix C=cos(angle), S=sin(angle)
	// (C  0 -S)
	// (0  1  0)
	// (S  0  C)
	Matrix M;
	M.e.clear();
	vector<double> row;
	row.clear();
	row.push_back(cos(angle));
	row.push_back(0.0);
	row.push_back(-sin(angle));
	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(sin(angle));
	row.push_back(0.0);
	row.push_back(cos(angle));
	M.e.push_back(row);
	return(M);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xa290
movq -0x98(%rbp), %rdi
callq 0xa2b0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xa2d0
movq -0x90(%rbp), %rdi
callq 0xa2f0
movsd -0x10(%rbp), %xmm0
callq 0x23f0
movq -0x90(%rbp), %rdi
movsd %xmm0, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xa310
jmp 0x2c17
movq $0x0, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa310
jmp 0x2c2e
movsd -0x10(%rbp), %xmm0
callq 0x2060
movaps 0xe481(%rip), %xmm1     # 0x110c0
pxor %xmm1, %xmm0
movlpd %xmm0, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa310
jmp 0x2c57
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x2c69
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xa2f0
movq -0xa8(%rbp), %rdi
movq $0x0, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0xa310
jmp 0x2c93
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xa310
jmp 0x2cb0
movq $0x0, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xa310
jmp 0x2cc7
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x2cd9
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa2f0
movsd -0x10(%rbp), %xmm0
callq 0x2060
movq -0xb0(%rbp), %rdi
movsd %xmm0, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0xa310
jmp 0x2d0a
movq $0x0, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xa310
jmp 0x2d21
movsd -0x10(%rbp), %xmm0
callq 0x23f0
movsd %xmm0, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xa310
jmp 0x2d45
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x2d57
movb $0x1, -0x11(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa3b0
testb $0x1, -0x11(%rbp)
jne 0x2d9b
jmp 0x2d8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa3b0
movq -0x98(%rbp), %rdi
callq 0xa410
jmp 0x2dab
movq -0x98(%rbp), %rdi
callq 0xa410
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x23c0
nopw %cs:(%rax,%rax)
// File: dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: YZ_ROT(double)
Matrix YZ_ROT(double angle){	// rotation in xz-plane
	// returns matrix C=cos(angle), S=sin(angle)
	// (1  0  0)
	// (0  C -S)
	// (0  S  C)
	Matrix M;
	M.e.clear();
	vector<double> row;
	row.clear();
	row.push_back(1.0);
	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(cos(angle));
	row.push_back(-sin(angle));
	M.e.push_back(row);
	row.clear();
	row.push_back(0.0);
	row.push_back(sin(angle));
	row.push_back(cos(angle));
	M.e.push_back(row);
	return(M);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xa290
movq -0x98(%rbp), %rdi
callq 0xa2b0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xa2d0
movq -0x90(%rbp), %rdi
callq 0xa2f0
movq -0x90(%rbp), %rdi
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xa310
jmp 0x2e36
movq $0x0, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa310
jmp 0x2e4d
movq $0x0, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa310
jmp 0x2e64
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x2e76
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xa2f0
movq -0xa8(%rbp), %rdi
movq $0x0, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0xa310
jmp 0x2ea0
movsd -0x10(%rbp), %xmm0
callq 0x23f0
movsd %xmm0, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xa310
jmp 0x2ebe
movsd -0x10(%rbp), %xmm0
callq 0x2060
movaps 0xe1f1(%rip), %xmm1     # 0x110c0
pxor %xmm1, %xmm0
movlpd %xmm0, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xa310
jmp 0x2ee7
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x2ef9
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa2f0
movq -0xb0(%rbp), %rdi
movq $0x0, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0xa310
jmp 0x2f23
movsd -0x10(%rbp), %xmm0
callq 0x2060
movsd %xmm0, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xa310
jmp 0x2f41
movsd -0x10(%rbp), %xmm0
callq 0x23f0
movsd %xmm0, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xa310
jmp 0x2f65
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x2f77
movb $0x1, -0x11(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa3b0
testb $0x1, -0x11(%rbp)
jne 0x2fbb
jmp 0x2faf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa3b0
movq -0x98(%rbp), %rdi
callq 0xa410
jmp 0x2fcb
movq -0x98(%rbp), %rdi
callq 0xa410
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x23c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xa290
leaq -0x30(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xa2d0
movq -0x90(%rbp), %rdi
callq 0xa2f0
movsd -0x10(%rbp), %xmm0
callq 0x22c0
movq -0x90(%rbp), %rdi
movsd %xmm0, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xa310
jmp 0x304b
movq $0x0, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa310
jmp 0x3062
movsd -0x10(%rbp), %xmm0
callq 0x21c0
movsd %xmm0, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa310
jmp 0x3080
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x3092
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xa2f0
movq -0xa8(%rbp), %rdi
movq $0x0, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0xa310
jmp 0x30bc
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xa310
jmp 0x30d9
movq $0x0, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xa310
jmp 0x30f0
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x3102
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa2f0
movsd -0x10(%rbp), %xmm0
callq 0x21c0
movq -0xb0(%rbp), %rdi
movsd %xmm0, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0xa310
jmp 0x3133
movq $0x0, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xa310
jmp 0x314a
movsd -0x10(%rbp), %xmm0
callq 0x22c0
movsd %xmm0, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xa310
jmp 0x316e
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x3180
movb $0x1, -0x11(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa3b0
testb $0x1, -0x11(%rbp)
jne 0x31c4
jmp 0x31b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa3b0
movq -0xa0(%rbp), %rdi
callq 0xa410
jmp 0x31d4
movq -0xa0(%rbp), %rdi
callq 0xa410
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x23c0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xa290
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xa2d0
movq -0x88(%rbp), %rdi
callq 0xa2f0
movq -0x88(%rbp), %rdi
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xa310
jmp 0x324a
movq $0x0, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa310
jmp 0x3261
leaq -0x30(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa430
jmp 0x3270
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x3282
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xa2f0
movq -0xa0(%rbp), %rdi
movq $0x0, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
callq 0xa310
jmp 0x32ac
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xa310
jmp 0x32c9
movq $0x0, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xa310
jmp 0x32e0
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x32f2
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xa2f0
movq -0xa8(%rbp), %rdi
movq $0x0, -0x70(%rbp)
leaq -0x70(%rbp), %rsi
callq 0xa310
jmp 0x331c
movq $0x0, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xa310
jmp 0x3333
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xa310
jmp 0x3350
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x3362
movb $0x1, -0x11(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa3b0
testb $0x1, -0x11(%rbp)
jne 0x33a6
jmp 0x339a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa3b0
movq -0x98(%rbp), %rdi
callq 0xa410
jmp 0x33b6
movq -0x98(%rbp), %rdi
callq 0xa410
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x23c0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xa290
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xa2d0
movq -0x80(%rbp), %rdi
callq 0xa2f0
movq -0x80(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa430
jmp 0x3413
movq $0x0, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xa310
jmp 0x342a
movq $0x0, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa310
jmp 0x3441
movq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x3453
leaq -0x30(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xa2f0
movq -0x98(%rbp), %rdi
movq $0x0, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
callq 0xa310
jmp 0x347d
leaq -0x30(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa430
jmp 0x348c
movq $0x0, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xa310
jmp 0x34a3
movq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x34b5
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xa2f0
movq -0xa0(%rbp), %rdi
movq $0x0, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
callq 0xa310
jmp 0x34df
movq $0x0, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xa310
jmp 0x34f6
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xa310
jmp 0x3513
movq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x3525
movb $0x1, -0x11(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa3b0
testb $0x1, -0x11(%rbp)
jne 0x3569
jmp 0x355d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa3b0
movq -0x90(%rbp), %rdi
callq 0xa410
jmp 0x3579
movq -0x90(%rbp), %rdi
callq 0xa410
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x23c0
nopw %cs:(%rax,%rax)
// File: dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: hyp_dist(Point)
double hyp_dist(Point P){	// hyperbolic distance from origin
	if(P.z<1.0){
		return(0.0);
	};
	return(acosh(P.z));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movsd 0xda68(%rip), %xmm0     # 0x11010
ucomisd 0x10(%rax), %xmm0
jbe 0x35b9
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x35cc
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
callq 0x23b0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x3590
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3648
jp 0x3648
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x365f
movq -0x30(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd (%rax), %xmm1
callq 0x2040
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x2640
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x36ee
jp 0x36ee
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x3705
movq -0x40(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd (%rax), %xmm1
callq 0x2040
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
// File: dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: hyperboloid_to_Poincare(Point)
Point hyperboloid_to_Poincare(Point P){	// change coordinates from hyperboloid to Poincare model
	// this can be used to change geometry from hyperbolic to Euclidean
	Point Q;
	Q.x=P.x/(P.z+1.0);
	Q.y=P.y/(P.z+1.0);
	Q.z=1.0;
	return(Q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
leaq 0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd 0xd6f9(%rip), %xmm1     # 0x11010
addsd 0x10(%rcx), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rcx), %xmm0
movsd 0xd6df(%rip), %xmm1     # 0x11010
addsd 0x10(%rcx), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0xd6c9(%rip), %xmm0     # 0x11010
movsd %xmm0, 0x10(%rdi)
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
leaq 0x10(%rbp), %rcx
movsd 0xd6a5(%rip), %xmm0     # 0x11008
mulsd (%rcx), %xmm0
movsd (%rcx), %xmm2
movsd (%rcx), %xmm1
mulsd %xmm1, %xmm2
movsd 0xd695(%rip), %xmm1     # 0x11010
addsd %xmm1, %xmm2
movsd 0x8(%rcx), %xmm1
movsd 0x8(%rcx), %xmm3
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
movsd 0xd667(%rip), %xmm0     # 0x11008
mulsd 0x8(%rcx), %xmm0
movsd (%rcx), %xmm2
movsd (%rcx), %xmm1
mulsd %xmm1, %xmm2
movsd 0xd656(%rip), %xmm1     # 0x11010
addsd %xmm1, %xmm2
movsd 0x8(%rcx), %xmm1
movsd 0x8(%rcx), %xmm3
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rdi)
movsd (%rcx), %xmm1
movsd (%rcx), %xmm0
movq %xmm1, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorq %rsi, %rdx
movq %rdx, %xmm1
mulsd %xmm0, %xmm1
movsd 0xd60c(%rip), %xmm0     # 0x11010
addsd %xmm0, %xmm1
movsd 0x8(%rcx), %xmm0
movsd 0x8(%rcx), %xmm2
movq %xmm0, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorq %rsi, %rdx
movq %rdx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd (%rcx), %xmm2
movsd (%rcx), %xmm1
mulsd %xmm1, %xmm2
movsd 0xd5cb(%rip), %xmm1     # 0x11010
addsd %xmm1, %xmm2
movsd 0x8(%rcx), %xmm1
movsd 0x8(%rcx), %xmm3
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rdi)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, -0x80(%rbp)
leaq 0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x3900
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x3950
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rdi)
movq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movq -0x50(%rbp), %rcx
movq %rcx, 0x10(%rdi)
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x1d(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movslq -0x14(%rbp), %rsi
callq 0xa4a0
movq %rax, %rdi
callq 0xa4c0
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x3bd3
movq -0x28(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0xa4a0
movq %rax, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xa4e0
movl (%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x3bc6
movb $0x1, -0x1d(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3bf0
jmp 0x3bc8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3b75
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3be9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3bf0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x48, %rdi
callq 0xa500
movl $0x1, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0xa520
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x3c72
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movl 0xbc(%rdi), %edx
callq 0x3b50
cmpl $-0x1, %eax
jne 0x3c65
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
leaq -0xc(%rbp), %rsi
callq 0xa550
jmp 0x3c67
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3c24
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x30, %rdi
callq 0xa2f0
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xa310
movl $0x0, -0xc(%rbp)
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0xa520
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x3d20
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0x38(%rbp)
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa270
movsd 0xd31e(%rip), %xmm0     # 0x11018
mulsd (%rax), %xmm0
callq 0x23e0
movq -0x38(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0xa310
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3cbd
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movslq -0xc(%rbp), %rsi
callq 0xa4a0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0xa4e0
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movslq -0xc(%rbp), %rsi
callq 0xa4a0
movq -0x20(%rbp), %rdi
movq %rax, -0x58(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
cltq
movq %rax, -0x50(%rbp)
movslq -0xc(%rbp), %rsi
callq 0xa4a0
movq %rax, %rdi
callq 0xa4c0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movq -0x50(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rsi
callq 0xa4e0
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x18(%rbp)
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa270
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0xa270
movsd -0x48(%rbp), %xmm0
movq -0x20(%rbp), %rdi
addsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa270
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x18, %rdi
movslq -0x18(%rbp), %rsi
callq 0xa270
movsd -0x40(%rbp), %xmm0
movq -0x20(%rbp), %rdi
addsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0xa270
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0x18, %rdi
movslq -0x18(%rbp), %rsi
callq 0xa270
movsd -0x38(%rbp), %xmm2
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movq %rax, %rcx
movq -0x20(%rbp), %rax
addsd (%rcx), %xmm2
movsbl 0x60(%rax), %edi
callq 0x40c0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movslq -0xc(%rbp), %rsi
callq 0xa4a0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0xa4e0
movq -0x38(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movslq -0xc(%rbp), %rsi
callq 0xa4a0
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
cltq
movq %rax, -0x40(%rbp)
movslq -0xc(%rbp), %rsi
callq 0xa4a0
movq %rax, %rdi
callq 0xa4c0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movq -0x40(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rsi
callq 0xa4e0
movq -0x38(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x18(%rbp)
addq $0x30, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa270
movq -0x38(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
addq $0x30, %rdi
movslq -0x14(%rbp), %rsi
callq 0xa270
movq -0x38(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
addq $0x30, %rdi
movslq -0x18(%rbp), %rsi
callq 0xa270
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0xcb02(%rip), %xmm1     # 0x11010
subsd -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0xcaf1(%rip), %xmm1     # 0x11010
subsd -0x30(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm1
movsd 0xcabb(%rip), %xmm2     # 0x11010
addsd %xmm2, %xmm1
movsd -0x20(%rbp), %xmm2
movsd -0x30(%rbp), %xmm3
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
mulsd %xmm3, %xmm2
movsd 0xca8a(%rip), %xmm3     # 0x11010
addsd %xmm3, %xmm2
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x2170
callq 0x2380
movaps %xmm0, %xmm1
movsd 0xca61(%rip), %xmm0     # 0x11008
mulsd %xmm1, %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movslq -0xc(%rbp), %rsi
callq 0xa4a0
movq %rax, %rdi
callq 0xa4c0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x468f
movq -0x20(%rbp), %rax
movsbl 0x60(%rax), %eax
cmpl $0x45, %eax
je 0x4629
movq -0x20(%rbp), %rax
movsbl 0x60(%rax), %eax
cmpl $0x53, %eax
jne 0x4655
movq -0x20(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x42e0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x467f
movq -0x20(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x4430
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x4681
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x45e6
movsd -0x18(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0xa520
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x4725
movq -0x20(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0xc(%rbp), %esi
callq 0x45c0
movaps %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
movsd 0xc926(%rip), %xmm1     # 0x11028
subsd %xmm2, %xmm1
movaps 0xc9c3(%rip), %xmm2     # 0x110d0
pand %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x46c3
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0xa520
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x47e0
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xbc(%rcx), %eax
je 0x47d0
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movl 0xbc(%rdi), %edx
callq 0x3b50
cmpl $-0x1, %eax
jne 0x47d0
movq -0x20(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0xc(%rbp), %esi
callq 0x45c0
movaps %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
movsd 0xc870(%rip), %xmm1     # 0x11028
subsd %xmm2, %xmm1
movaps 0xc90d(%rip), %xmm2     # 0x110d0
pand %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x47d2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4753
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movslq -0xc(%rbp), %rsi
callq 0xa4a0
movq %rax, %rdi
callq 0xa4c0
movq -0x70(%rbp), %rdi
movq %rax, %xmm0
movaps 0xc8b5(%rip), %xmm1     # 0x110e0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xc8b9(%rip), %xmm1     # 0x110f0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0xc(%rbp), %esi
callq 0x45c0
movsd 0xc7ad(%rip), %xmm1     # 0x11008
mulsd -0x28(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0x2060
movsd %xmm0, -0x18(%rbp)
movsd 0xc792(%rip), %xmm1     # 0x11008
mulsd -0x28(%rbp), %xmm1
movsd 0xc7a5(%rip), %xmm0     # 0x11028
divsd %xmm1, %xmm0
callq 0x2060
movq -0x70(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
addq $0x30, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa270
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x48(%rbp), %xmm0
callq 0x2170
movaps %xmm0, %xmm1
movsd -0x68(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x48(%rbp), %xmm0
callq 0x2170
movsd -0x60(%rbp), %xmm1
movsd -0x58(%rbp), %xmm3
movaps %xmm0, %xmm2
movsd -0x50(%rbp), %xmm0
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x493a
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0xc6c6(%rip), %xmm0     # 0x11008
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
movsd 0xc6bc(%rip), %xmm0     # 0x11010
subsd -0x30(%rbp), %xmm0
movsd 0xc6af(%rip), %xmm2     # 0x11010
subsd -0x30(%rbp), %xmm2
movsd 0xc6c2(%rip), %xmm1     # 0x11030
mulsd -0x20(%rbp), %xmm1
mulsd -0x20(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x2170
movq -0x70(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x80(%rbp), %xmm0
movsd 0xc672(%rip), %xmm2     # 0x11010
subsd -0x30(%rbp), %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
addq $0x30, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa270
movsd -0x78(%rbp), %xmm0
movsd %xmm0, (%rax)
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movslq -0xc(%rbp), %rsi
callq 0xa4a0
movq %rax, %rdi
callq 0xa4c0
movq -0x40(%rbp), %rdi
movq %rax, %xmm0
movaps 0xc6b8(%rip), %xmm1     # 0x110e0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xc6bc(%rip), %xmm1     # 0x110f0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0xc(%rbp), %esi
callq 0x45c0
movsd 0xc5b0(%rip), %xmm1     # 0x11008
mulsd -0x28(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0x2060
movsd %xmm0, -0x18(%rbp)
movsd 0xc595(%rip), %xmm1     # 0x11008
mulsd -0x28(%rbp), %xmm1
movsd 0xc5a8(%rip), %xmm0     # 0x11028
divsd %xmm1, %xmm0
callq 0x2060
movq -0x40(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa270
movq -0x40(%rbp), %rdi
movsd (%rax), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd 0xc55c(%rip), %xmm1     # 0x11010
subsd -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0xc541(%rip), %xmm1     # 0x11010
subsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa270
movsd -0x38(%rbp), %xmm0
movsd %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x13025(%rip), %rdi     # 0x17fd0
leaq 0xc9ab(%rip), %rsi      # 0x1195d
callq 0x21f0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movsbl 0x60(%rax), %esi
callq 0x2240
movq %rax, %rdi
leaq 0xc728(%rip), %rsi      # 0x116f9
callq 0x21f0
movq -0x18(%rbp), %rax
movsbl 0x60(%rax), %eax
cmpl $0x48, %eax
jne 0x50ef
movq 0x12fe2(%rip), %rdi     # 0x17fd0
leaq 0xc27b(%rip), %rsi      # 0x11270
callq 0x21f0
movq %rax, %rdi
xorl %esi, %esi
callq 0x23a0
movq %rax, %rdi
leaq 0xc26a(%rip), %rsi      # 0x11278
callq 0x21f0
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0xa520
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x50ea
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xbc(%rcx), %eax
jne 0x507c
movq 0x12f83(%rip), %rdi     # 0x17fd0
leaq 0xc21c(%rip), %rsi      # 0x11270
callq 0x21f0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0xbc(%rax), %esi
callq 0x23a0
movq %rax, %rdi
leaq 0xc203(%rip), %rsi      # 0x11278
callq 0x21f0
jmp 0x50da
movq 0x12f4d(%rip), %rdi     # 0x17fd0
leaq 0xc1e6(%rip), %rsi      # 0x11270
callq 0x21f0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x23a0
movq %rax, %rdi
leaq 0xc1eb(%rip), %rsi      # 0x1128f
callq 0x21f0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa270
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x2400
movq %rax, %rdi
leaq 0xc624(%rip), %rsi      # 0x116f9
callq 0x21f0
jmp 0x50dc
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x501a
jmp 0x517d
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0xa520
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x517b
movq 0x12eba(%rip), %rdi     # 0x17fd0
leaq 0xc153(%rip), %rsi      # 0x11270
callq 0x21f0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x23a0
movq %rax, %rdi
leaq 0xc158(%rip), %rsi      # 0x1128f
callq 0x21f0
movq -0x18(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa270
movq -0x38(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x2400
movq %rax, %rdi
leaq 0xc591(%rip), %rsi      # 0x116f9
callq 0x21f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x50f6
jmp 0x517d
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0xa520
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x5686
movq 0x129d1(%rip), %rdi     # 0x17fd0
leaq 0xbcca(%rip), %rsi      # 0x112d0
callq 0x21f0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x23a0
movq %rax, %rdi
leaq 0xbc9e(%rip), %rsi      # 0x112be
callq 0x21f0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x80, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa4e0
movq -0x28(%rbp), %rdi
movl (%rax), %esi
callq 0x23a0
movq %rax, %rdi
leaq 0xbc7a(%rip), %rsi      # 0x112cc
callq 0x21f0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0xbc(%rax), %esi
callq 0x23a0
movq %rax, %rdi
leaq 0xbc65(%rip), %rsi      # 0x112d8
callq 0x21f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x55db
movq 0x12943(%rip), %rdi     # 0x17fd0
leaq 0xbc5d(%rip), %rsi      # 0x112f1
callq 0x21f0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x98(%rax), %esi
callq 0x23a0
movq %rax, %rdi
leaq 0xc044(%rip), %rsi      # 0x116f9
callq 0x21f0
addq $0x30, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
addq $0x68, %rdi
callq 0xa520
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x5734
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
movslq -0x10(%rbp), %rsi
callq 0xa4a0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa4e0
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x5727
movb $0x1, -0x11(%rbp)
jmp 0x5729
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x56e2
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0xb8(%rax)
je 0x62b0
movq 0x11d2c(%rip), %rdi     # 0x17fd0
leaq 0xb0a9(%rip), %rsi      # 0x11354
callq 0x21f0
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0xad48(%rip), %xmm0     # 0x11010
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0xa520
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x630c
movq -0x30(%rbp), %rdi
addq $0xa0, %rdi
leaq -0x20(%rbp), %rsi
callq 0xadd0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x62d4
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x11845(%rip), %rdi     # 0x17fd0
leaq 0xb1cb(%rip), %rsi      # 0x1195d
callq 0x21f0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movsbl 0x60(%rax), %esi
callq 0x2240
movq %rax, %rdi
leaq 0xaf48(%rip), %rsi      # 0x116f9
callq 0x21f0
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0xa520
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x68d5
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xbc(%rcx), %eax
jne 0x67fc
movq 0x117e0(%rip), %rdi     # 0x17fd0
leaq 0xab8f(%rip), %rsi      # 0x11386
callq 0x21f0
movq 0x117cd(%rip), %rdi     # 0x17fd0
leaq 0xaac6(%rip), %rsi      # 0x112d0
callq 0x21f0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x23a0
movq %rax, %rdi
leaq 0xab68(%rip), %rsi      # 0x1138c
callq 0x21f0
movq -0x18(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0xa0, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa5c0
movq -0x38(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x2400
movq %rax, %rdi
leaq 0xae38(%rip), %rsi      # 0x11690
callq 0x21f0
movq -0x18(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0xa0, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa5c0
movq -0x30(%rbp), %rdi
movsd 0x8(%rax), %xmm0
callq 0x2400
movq %rax, %rdi
leaq 0xae03(%rip), %rsi      # 0x11690
callq 0x21f0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0xa0, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa5c0
movq -0x28(%rbp), %rdi
movsd 0x10(%rax), %xmm0
callq 0x2400
movq %rax, %rdi
leaq 0xae37(%rip), %rsi      # 0x116f9
callq 0x21f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x67bd
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xae40
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x23a0
movq %rax, %rdi
leaq 0x800f(%rip), %rsi      # 0x116f9
callq 0x21f0
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0xae40
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x97d9
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movslq -0x14(%rbp), %rsi
callq 0xa4a0
movq %rax, %rdi
callq 0xa4c0
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x23a0
movq %rax, %rdi
leaq 0x7f4b(%rip), %rsi      # 0x1168f
callq 0x21f0
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x3c(%rbp)
movslq -0x14(%rbp), %rsi
callq 0xa4a0
movq %rax, %rdi
callq 0xa4c0
movq %rax, %rcx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x97bb
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movslq -0x14(%rbp), %rsi
callq 0xa4a0
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0xa4e0
movq -0x48(%rbp), %rdi
movl (%rax), %esi
callq 0x23a0
movq %rax, %rdi
leaq 0x7ee5(%rip), %rsi      # 0x11690
callq 0x21f0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9750
movq -0x10(%rbp), %rdi
leaq 0x7f33(%rip), %rsi      # 0x116f9
callq 0x21f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x96f6
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x4c(%rbp)
callq 0xae40
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jge 0x9838
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0xa270
movq -0x58(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x2400
movq %rax, %rdi
leaq 0x7ed1(%rip), %rsi      # 0x116f9
callq 0x21f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x97e0
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movsbl 0x60(%rax), %esi
callq 0x2240
movq %rax, %rdi
leaq 0x7ea6(%rip), %rsi      # 0x116f9
callq 0x21f0
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0xbc(%rax), %esi
callq 0x23a0
movq %rax, %rdi
leaq 0x7e84(%rip), %rsi      # 0x116f9
callq 0x21f0
addq $0x60, %rsp
popq %rbp
retq