LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::popEdge(int, int)
void Graph::popEdge(int a, int b) {
	if (DENSE) {
		mat[a][b] = 0;
		mat[b][a] = 0;
	}
	g[a].pop_back();
	g[b].pop_back();
	m--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x30(%rax)
je 0x15d60
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x17560
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x17880
movq -0x18(%rbp), %rdi
movb $0x0, (%rax)
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0x17560
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x17880
movb $0x0, (%rax)
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
callq 0x178c0
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movslq -0x10(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
callq 0x178c0
movq -0x18(%rbp), %rax
movl 0x54(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x54(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::remEdge(int, int)
void Graph::remEdge(int a, int b) {
	if (DENSE) {
		mat[a][b] = 0;
		mat[b][a] = 0;
	}
	for (size_t i = 0; i < g[a].size(); i++) {
		if (g[a][i] == b) {
			swap(g[a][i], g[a].back());
			g[a].pop_back();
			break;
		}
	}
	for (size_t i = 0; i < g[b].size(); i++) {
		if (g[b][i] == a) {
			swap(g[b][i], g[b].back());
			g[b].pop_back();
			break;
		}
	}
	m--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x30(%rax)
je 0x15e90
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x17560
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x17880
movq -0x28(%rbp), %rdi
movb $0x0, (%rax)
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0x17560
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x17880
movb $0x0, (%rax)
movq $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
callq 0x59a0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x15f61
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x178f0
movl (%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x15f4e
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x178f0
movq -0x28(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
callq 0x17940
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x17910
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
callq 0x178c0
jmp 0x15f61
jmp 0x15f50
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x15e98
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x38, %rdi
movslq -0x10(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
callq 0x59a0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x16032
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movslq -0x10(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x178f0
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x1601f
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movslq -0x10(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x178f0
movq -0x28(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x38, %rdi
movslq -0x10(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
callq 0x17940
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x17910
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movslq -0x10(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
callq 0x178c0
jmp 0x16032
jmp 0x16021
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x15f69
movq -0x28(%rbp), %rax
movl 0x54(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x54(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::remIncident(int)
void Graph::remIncident(int x) {
	for (int nx : g[x]) {
		for (size_t i = 0; i < g[nx].size(); i++) {
			if (g[nx][i] == x) {
				swap(g[nx][i], g[nx].back());
				g[nx].pop_back();
				break;
			}
		}
		if (DENSE) {
			mat[x][nx] = 0;
			mat[nx][x] = 0;
		}
		m--;
	}
	g[x].clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0x178a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe060
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe090
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xe0c0
testb $0x1, %al
jne 0x160a8
jmp 0x161ec
leaq -0x20(%rbp), %rdi
callq 0xe100
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x38, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
callq 0x59a0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x16187
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x178f0
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x16174
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x178f0
movq -0x40(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x38, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
callq 0x17940
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x17910
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
callq 0x178c0
jmp 0x16187
jmp 0x16176
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x160be
movq -0x40(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0x161d1
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x17560
movq %rax, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x17880
movq -0x40(%rbp), %rdi
movb $0x0, (%rax)
addq $0x18, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x17560
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x17880
movb $0x0, (%rax)
movq -0x40(%rbp), %rax
movl 0x54(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x54(%rax)
leaq -0x20(%rbp), %rdi
callq 0xe120
jmp 0x16092
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
callq 0x17980
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::remIncident(int, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&)
void Graph::remIncident(int x, vector<pair<int, int> >& remd) {
	for (int nx : g[x]) {
		remd.push_back({x, nx});
		for (size_t i = 0; i < g[nx].size(); i++) {
			if (g[nx][i] == x) {
				swap(g[nx][i], g[nx].back());
				g[nx].pop_back();
				break;
			}
		}
		if (DENSE) {
			mat[x][nx] = 0;
			mat[nx][x] = 0;
		}
		m--;
	}
	g[x].clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0x178a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe060
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe090
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xe0c0
testb $0x1, %al
jne 0x1626c
jmp 0x163d6
leaq -0x28(%rbp), %rdi
callq 0xe100
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x3c(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0xdfc0
movq -0x58(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x179a0
movq $0x0, -0x48(%rbp)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x38, %rdi
movslq -0x34(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
callq 0x59a0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x16371
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
movslq -0x34(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
movq -0x48(%rbp), %rsi
callq 0x178f0
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x1635e
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
movslq -0x34(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
movq -0x48(%rbp), %rsi
callq 0x178f0
movq -0x50(%rbp), %rdi
movq %rax, -0x68(%rbp)
addq $0x38, %rdi
movslq -0x34(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
callq 0x17940
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x17910
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
movslq -0x34(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
callq 0x178c0
jmp 0x16371
jmp 0x16360
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x162a8
movq -0x50(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0x163bb
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x17560
movq %rax, %rdi
movslq -0x34(%rbp), %rsi
callq 0x17880
movq -0x50(%rbp), %rdi
movb $0x0, (%rax)
addq $0x18, %rdi
movslq -0x34(%rbp), %rsi
callq 0x17560
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x17880
movb $0x0, (%rax)
movq -0x50(%rbp), %rax
movl 0x54(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x54(%rax)
leaq -0x28(%rbp), %rdi
callq 0xe120
jmp 0x16256
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
callq 0x17980
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::hasEdge(int, int) const
bool Graph::hasEdge(int a, int b) const {
	if (DENSE) return mat[a][b] == 1;
	if (g[a].size() < g[b].size()) {
		for (int nx : g[a]) {
			if (nx == b) return true;
		}
		return false;
	}
	else {
		for (int nx : g[b]) {
			if (nx == a) return true;
		}
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
testb $0x1, 0x30(%rax)
je 0x16450
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0x179d0
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x179f0
movsbl (%rax), %eax
cmpl $0x1, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x16575
movq -0x60(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0xbba0
movq %rax, %rdi
callq 0x59a0
movq -0x60(%rbp), %rdi
movq %rax, -0x68(%rbp)
addq $0x38, %rdi
movslq -0x18(%rbp), %rsi
callq 0xbba0
movq %rax, %rdi
callq 0x59a0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x16506
movq -0x60(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0xbba0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6680
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x66b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x164d4
jmp 0x16500
leaq -0x28(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x164f3
movb $0x1, -0x1(%rbp)
jmp 0x16575
jmp 0x164f5
leaq -0x28(%rbp), %rdi
callq 0xbc80
jmp 0x164c1
movb $0x0, -0x1(%rbp)
jmp 0x16575
movq -0x60(%rbp), %rdi
addq $0x38, %rdi
movslq -0x18(%rbp), %rsi
callq 0xbba0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x6680
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x66b0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x16548
jmp 0x16571
leaq -0x48(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x16564
movb $0x1, -0x1(%rbp)
jmp 0x16575
jmp 0x16566
leaq -0x48(%rbp), %rdi
callq 0xbc80
jmp 0x16535
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
// File: Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::print(std::ostream&) const
void Graph::print(ostream& out) const {
	out<<"n "<<n<<endl;
	int mm = 0;
	for (int i = 0; i < n; i++) {
		mm += (int)g[i].size();
	}
	assert(mm%2 == 0);
	assert(mm/2 == m);
	out<<"m "<<m<<endl;
	for (int i = 0; i < n; i++) {
		for (int nx : g[i]) {
			if (i<nx) out<<i<<" "<<nx<<endl;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x43152(%rip), %rsi     # 0x596f5
callq 0x32b0
movq %rax, %rdi
movq -0x48(%rbp), %rax
movl 0x50(%rax), %esi
callq 0x3470
movq %rax, %rdi
movq 0x639f7(%rip), %rsi     # 0x79fb8
callq 0x3300
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x48(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x50(%rcx), %eax
jge 0x1660a
movq -0x48(%rbp), %rdi
addq $0x38, %rdi
movslq -0x18(%rbp), %rsi
callq 0xbba0
movq %rax, %rdi
callq 0x59a0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x165d4
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x1661c
jmp 0x1663b
leaq 0x430d5(%rip), %rdi     # 0x596f8
leaq 0x430d8(%rip), %rsi     # 0x59702
movl $0xb1, %edx
leaq 0x430d6(%rip), %rcx     # 0x5970c
callq 0x31a0
movq -0x48(%rbp), %rcx
movl -0x14(%rbp), %eax
movl $0x2, %esi
cltd
idivl %esi
cmpl 0x54(%rcx), %eax
jne 0x16651
jmp 0x16670
leaq 0x430d7(%rip), %rdi     # 0x5972f
leaq 0x430a3(%rip), %rsi     # 0x59702
movl $0xb2, %edx
leaq 0x430a1(%rip), %rcx     # 0x5970c
callq 0x31a0
movq -0x10(%rbp), %rdi
leaq 0x430be(%rip), %rsi     # 0x59739
callq 0x32b0
movq %rax, %rdi
movq -0x48(%rbp), %rax
movl 0x54(%rax), %esi
callq 0x3470
movq %rax, %rdi
movq 0x6391f(%rip), %rsi     # 0x79fb8
callq 0x3300
movl $0x0, -0x1c(%rbp)
movq -0x48(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x50(%rcx), %eax
jge 0x1675f
movq -0x48(%rbp), %rdi
addq $0x38, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xbba0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6680
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x66b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x166f7
jmp 0x1674f
leaq -0x30(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x16742
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3470
movq %rax, %rdi
leaq 0x445ba(%rip), %rsi     # 0x5acdd
callq 0x32b0
movq %rax, %rdi
movl -0x3c(%rbp), %esi
callq 0x3470
movq %rax, %rdi
movq 0x6387b(%rip), %rsi     # 0x79fb8
callq 0x3300
jmp 0x16744
leaq -0x30(%rbp), %rdi
callq 0xbc80
jmp 0x166e4
jmp 0x16751
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x166a5
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::hash() const
uint64_t Graph::hash() const {
	uint64_t ha = 0;
	vector<pair<int, int> > es;
	for (int i = 0; i < n; i++) {
		for (int nx : g[i]) {
			if (nx > i) {
				es.push_back({i, nx});
			}
		}
	}
	sort(es.begin(), es.end());
	for (auto e : es) {
		ha *= 1000003ll;
		ha += (uint64_t)e.F;
		ha *= 10007ll;
		ha += (uint64_t)e.S;
	}
	return ha;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xbd50
movl $0x0, -0x2c(%rbp)
movq -0xa0(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x50(%rcx), %eax
jge 0x1686b
movq -0xa0(%rbp), %rdi
addq $0x38, %rdi
movslq -0x2c(%rbp), %rsi
callq 0xbba0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x6680
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x66b0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x167fa
jmp 0x1685b
leaq -0x40(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jle 0x1684e
leaq -0x54(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0x4c(%rbp), %rdx
callq 0xdfc0
jmp 0x16823
leaq -0x28(%rbp), %rdi
leaq -0x54(%rbp), %rsi
callq 0x179a0
jmp 0x16832
jmp 0x1684e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5470
jmp 0x1695d
jmp 0x16850
leaq -0x40(%rbp), %rdi
callq 0xbc80
jmp 0x167e7
jmp 0x1685d
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x167a2
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xc0b0
movq -0xa8(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0xc040
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x17a10
jmp 0x1689e
leaq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
callq 0xc0b0
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
callq 0xc040
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x11310
testb $0x1, %al
jne 0x168df
jmp 0x16939
leaq -0x88(%rbp), %rdi
callq 0x11350
movq (%rax), %rax
movq %rax, -0x98(%rbp)
imulq $0xf4243, -0x10(%rbp), %rax # imm = 0xF4243
movq %rax, -0x10(%rbp)
movslq -0x98(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
imulq $0x2717, -0x10(%rbp), %rax # imm = 0x2717
movq %rax, -0x10(%rbp)
movslq -0x94(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x11370
jmp 0x168c6
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5470
movq -0xb0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::dfs1(int, std::vector<int, std::allocator<int>>&) const
void Graph::dfs1(int x, vector<int>& u) const {
	if (u[x]) return;
	u[x] = 1;
	for (int nx : g[x]) {
		dfs1(nx, u);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x178f0
cmpl $0x0, (%rax)
je 0x16c6f
jmp 0x16ced
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x178f0
movq -0x40(%rbp), %rdi
movl $0x1, (%rax)
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0xbba0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6680
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x66b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x16cc4
jmp 0x16ced
leaq -0x28(%rbp), %rdi
callq 0xbc00
movq -0x40(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x16c40
leaq -0x28(%rbp), %rdi
callq 0xbc80
jmp 0x16cb1
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::isConnected() const
bool Graph::isConnected() const {
	vector<int> u(n);
	dfs1(0, u);
	for (int i = 0; i < n; i++) {
		if (!u[i]) return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movslq 0x50(%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x111b0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x17ab0
jmp 0x16d3c
leaq -0x29(%rbp), %rdi
callq 0x6620
movq -0x60(%rbp), %rdi
xorl %esi, %esi
leaq -0x28(%rbp), %rdx
callq 0x16c40
jmp 0x16d56
movl $0x0, -0x40(%rbp)
movq -0x60(%rbp), %rcx
movl -0x40(%rbp), %eax
cmpl 0x50(%rcx), %eax
jge 0x16dc3
movslq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x178f0
cmpl $0x0, (%rax)
jne 0x16db6
movb $0x0, -0x1(%rbp)
movl $0x1, -0x44(%rbp)
jmp 0x16dce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x6620
jmp 0x16de2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6d30
jmp 0x16de2
jmp 0x16db8
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x16d5d
movb $0x1, -0x1(%rbp)
movl $0x1, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6d30
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3480
nopl (%rax,%rax)
// File: Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::isConnectedOrIsolated() const
bool Graph::isConnectedOrIsolated() const {
	vector<int> u(n);
	int cc = 0;
	for (int i = 0; i < n; i++) {
		if (u[i] == 0 && g[i].size() > 0) {
			cc++;
			dfs1(i, u);
		}
	}
	return cc <= 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movslq 0x50(%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x111b0
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x17ab0
jmp 0x16e2c
leaq -0x21(%rbp), %rdi
callq 0x6620
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x58(%rbp), %rcx
movl -0x3c(%rbp), %eax
cmpl 0x50(%rcx), %eax
jge 0x16ede
movslq -0x3c(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x178f0
cmpl $0x0, (%rax)
jne 0x16ece
movq -0x58(%rbp), %rdi
addq $0x38, %rdi
movslq -0x3c(%rbp), %rsi
callq 0xbba0
movq %rax, %rdi
callq 0x59a0
cmpq $0x0, %rax
jbe 0x16ece
movq -0x58(%rbp), %rdi
movl -0x38(%rbp), %eax
incl %eax
movl %eax, -0x38(%rbp)
movl -0x3c(%rbp), %esi
leaq -0x20(%rbp), %rdx
callq 0x16c40
jmp 0x16e9e
jmp 0x16ece
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x6620
jmp 0x16efc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6d30
jmp 0x16efc
jmp 0x16ed0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x16e43
cmpl $0x1, -0x38(%rbp)
setle %al
movb %al, -0x59(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6d30
movb -0x59(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::hasCycle() const
bool Graph::hasCycle() const {
	vector<int> u(n);
	int cc = 0;
	for (int i = 0; i < n; i++) {
		if (u[i] == 0 && g[i].size() > 0) {
			cc++;
			dfs1(i, u);
		}
	}
	return m > n - cc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movslq 0x50(%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x111b0
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x17ab0
jmp 0x16f4c
leaq -0x21(%rbp), %rdi
callq 0x6620
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x58(%rbp), %rcx
movl -0x3c(%rbp), %eax
cmpl 0x50(%rcx), %eax
jge 0x16ffe
movslq -0x3c(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x178f0
cmpl $0x0, (%rax)
jne 0x16fee
movq -0x58(%rbp), %rdi
addq $0x38, %rdi
movslq -0x3c(%rbp), %rsi
callq 0xbba0
movq %rax, %rdi
callq 0x59a0
cmpq $0x0, %rax
jbe 0x16fee
movq -0x58(%rbp), %rdi
movl -0x38(%rbp), %eax
incl %eax
movl %eax, -0x38(%rbp)
movl -0x3c(%rbp), %esi
leaq -0x20(%rbp), %rdx
callq 0x16c40
jmp 0x16fbe
jmp 0x16fee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x6620
jmp 0x17027
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6d30
jmp 0x17027
jmp 0x16ff0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x16f63
movq -0x58(%rbp), %rcx
movl 0x54(%rcx), %eax
movl 0x50(%rcx), %ecx
subl -0x38(%rbp), %ecx
cmpl %ecx, %eax
setg %al
movb %al, -0x59(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6d30
movb -0x59(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3480
// File: Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::mapInto(int) const
int Graph::mapInto(int v) const {
	int id = lower_bound(vMap.begin(), vMap.end(), v) - vMap.begin();
	assert(id < (int)vMap.size());
	assert(vMap[id] == v);
	return id;
}

// 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)
callq 0x6680
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x66b0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0xc(%rbp), %rdx
callq 0x17b60
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x6680
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17b20
movq -0x40(%rbp), %rdi
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x59a0
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x170aa
jmp 0x170c9
leaq 0x4268b(%rip), %rdi     # 0x5973c
leaq 0x4264a(%rip), %rsi     # 0x59702
movl $0x10c, %edx            # imm = 0x10C
leaq 0x4268e(%rip), %rcx     # 0x59752
callq 0x31a0
movq -0x40(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x17a50
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x170df
jmp 0x170fe
leaq 0x4268a(%rip), %rdi     # 0x59770
leaq 0x42615(%rip), %rsi     # 0x59702
movl $0x10d, %edx            # imm = 0x10D
leaq 0x42659(%rip), %rcx     # 0x59752
callq 0x31a0
movl -0x10(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Laakeri[P]Triangulator/src/IO.cpp
// Function: IO::nTokens(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
int IO::nTokens(string s) const {
	stringstream ss;
	ss<<s;
	int r=0;
	while (ss>>s) {
		r++;
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rsi, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31f0
movq -0x1b0(%rbp), %rsi
leaq -0x188(%rbp), %rdi
callq 0x3290
jmp 0x2500b
movl $0x0, -0x1a8(%rbp)
movq -0x1b0(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0x33b0
movq %rax, -0x1b8(%rbp)
jmp 0x25031
movq -0x1b8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x33a0
movb %al, -0x1b9(%rbp)
jmp 0x2504f
movb -0x1b9(%rbp), %al
testb $0x1, %al
jne 0x2505b
jmp 0x2508c
movl -0x1a8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a8(%rbp)
jmp 0x25015
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3220
jmp 0x250b3
movl -0x1a8(%rbp), %eax
movl %eax, -0x1c0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3220
movl -0x1c0(%rbp), %eax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x3480
nop
// File: Laakeri[P]Triangulator/src/MCS.cpp
// Function: MCS::findCC(int, Graph const&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&)
void findCC(int x, const Graph& G, vector<pair<int, int> >& v) {
	if (rc[x]) return;
	rc[x] = 1;
	for (int nx : G.g[x]) {
		if (ca[nx] || !rc[nx]) {
			v.push_back({x, nx});
		}
	}
	for (int nx : G.g[x]) {
		if (!ca[nx] && !rc[nx]) {
			findCC(nx, G, v);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x2fcb62(%rip), %rax    # 0x325cb0
cmpl $0x0, (%rax,%rcx,4)
je 0x29159
jmp 0x2929f
movslq -0x4(%rbp), %rcx
leaq 0x2fcb4c(%rip), %rax    # 0x325cb0
movl $0x1, (%rax,%rcx,4)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x4(%rbp), %rsi
callq 0xbba0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6680
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x66b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x291ad
jmp 0x29210
leaq -0x28(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rcx
leaq 0x32d82a(%rip), %rax    # 0x3569f0
cmpl $0x0, (%rax,%rcx,4)
jne 0x291dd
movslq -0x34(%rbp), %rcx
leaq 0x2fcad9(%rip), %rax    # 0x325cb0
cmpl $0x0, (%rax,%rcx,4)
jne 0x29203
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x3c(%rbp), %rdi
leaq -0x4(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0xdfc0
movq -0x68(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x179a0
jmp 0x29205
leaq -0x28(%rbp), %rdi
callq 0xbc80
jmp 0x2919a
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x4(%rbp), %rsi
callq 0xbba0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x6680
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x66b0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x29252
jmp 0x2929f
leaq -0x50(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
movslq -0x5c(%rbp), %rcx
leaq 0x32d785(%rip), %rax    # 0x3569f0
cmpl $0x0, (%rax,%rcx,4)
jne 0x29292
movslq -0x5c(%rbp), %rcx
leaq 0x2fca34(%rip), %rax    # 0x325cb0
cmpl $0x0, (%rax,%rcx,4)
jne 0x29292
movl -0x5c(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x29130
jmp 0x29294
leaq -0x50(%rbp), %rdi
callq 0xbc80
jmp 0x2923f
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]Triangulator/src/minfill.cpp
// Function: MinFill::BackTrack::solve(Graph, int, int, int)
vector<pair<int, int> > solve(Graph G, int lowerBound, int upperBound, int depth) {
	assert(lowerBound >= 0);
	if (upperBound < lowerBound) return FAILSOLUTION;
	auto sol = searchNaive(G, lowerBound, upperBound, 0, depth);
	return sol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x30aa1
jmp 0x30ac0
leaq 0x2887a(%rip), %rdi     # 0x59322
leaq 0x29639(%rip), %rsi     # 0x5a0e8
movl $0x42, %edx
leaq 0x29729(%rip), %rcx     # 0x5a1e4
callq 0x31a0
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x30ada
movq -0x30(%rbp), %rdi
leaq 0x4dd65d(%rip), %rsi    # 0x50e130
callq 0x56a0
jmp 0x30b0d
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
movb $0x0, -0x1d(%rbp)
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r9d
xorl %r8d, %r8d
callq 0x2fc10
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x30b0b
movq -0x30(%rbp), %rdi
callq 0x5470
jmp 0x30b0d
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Laakeri[P]Triangulator/src/minfill.cpp
// Function: MinFill::SolveAtom::findPath(Graph const&, int, int)
int findPath(const Graph& G, int x, int y) {
	int bfsBack = 0;
	bfs[bfsBack++] = x;
	d[x] = 1;
	int i2 = 0;
	bool fo = false;
	while (i2 < bfsBack) {
		int t = bfs[i2++];
		for (int nt : G.g[t]) {
			if (d[nt]) continue;
			if (del1[nt]) continue;
			if (nt == y) {
				fo = true;
				break;
			}
			d[nt] = 1;
			bfs[bfsBack++] = nt;
		}
		if (fo) break;
	}
	for (int i = 0; i < bfsBack; i++) {
		d[bfs[i]] = 0;
	}
	return fo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %edx
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0x5a06cf(%rip), %rax    # 0x5d1650
movl %edx, (%rax,%rcx,4)
movslq -0xc(%rbp), %rcx
leaq 0x50df01(%rip), %rax    # 0x53ee90
movl $0x1, (%rax,%rcx,4)
movl $0x0, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x31094
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
movslq %eax, %rcx
leaq 0x5a068e(%rip), %rax    # 0x5d1650
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movslq -0x20(%rbp), %rsi
callq 0xbba0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6680
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x66b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x3100a
jmp 0x31087
leaq -0x30(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0x50de6d(%rip), %rax    # 0x53ee90
cmpl $0x0, (%rax,%rcx,4)
je 0x3102b
jmp 0x31079
movslq -0x3c(%rbp), %rcx
leaq 0x4dd11a(%rip), %rax    # 0x50e150
cmpl $0x0, (%rax,%rcx,4)
je 0x3103e
jmp 0x31079
movl -0x3c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jne 0x3104c
movb $0x1, -0x19(%rbp)
jmp 0x31087
movslq -0x3c(%rbp), %rcx
leaq 0x50de39(%rip), %rax    # 0x53ee90
movl $0x1, (%rax,%rcx,4)
movl -0x3c(%rbp), %edx
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0x5a05da(%rip), %rax    # 0x5d1650
movl %edx, (%rax,%rcx,4)
leaq -0x30(%rbp), %rdi
callq 0xbc80
jmp 0x30ff7
testb $0x1, -0x19(%rbp)
je 0x3108f
jmp 0x31094
jmp 0x30fa1
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x310cb
movslq -0x40(%rbp), %rcx
leaq 0x5a05a2(%rip), %rax    # 0x5d1650
movslq (%rax,%rcx,4), %rcx
leaq 0x50ddd7(%rip), %rax    # 0x53ee90
movl $0x0, (%rax,%rcx,4)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x3109b
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::valueT::operator<(PMC::valueT const&) const
bool valueT::operator<(const valueT& o) const {
	assert(TYPE == o.TYPE);
	if (TYPE == TYPE_INT) return valInt < o.valInt;
	else if (TYPE == TYPE_DOUBLE) return valDouble < o.valDouble;
	else assert(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x20(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x3a226
jmp 0x3a245
leaq 0x2048c(%rip), %rdi     # 0x5a6b9
leaq 0x20442(%rip), %rsi     # 0x5a676
movl $0x45, %edx
leaq 0x20488(%rip), %rcx     # 0x5a6c8
callq 0x31a0
movq -0x20(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x3a267
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3a2ac
movq -0x20(%rbp), %rax
cmpl $0x2, 0x20(%rax)
jne 0x3a28d
movq -0x20(%rbp), %rax
fldt 0x10(%rax)
movq -0x18(%rbp), %rax
fldt 0x10(%rax)
fucompi %st(1), %st
fstp %st(0)
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3a2ac
leaq 0x1eedc(%rip), %rdi     # 0x59170
leaq 0x203db(%rip), %rsi     # 0x5a676
movl $0x48, %edx
leaq 0x20421(%rip), %rcx     # 0x5a6c8
callq 0x31a0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::valueT::operator<=(PMC::valueT const&) const
bool valueT::operator<=(const valueT& o) const {
	assert(TYPE == o.TYPE);
	if (TYPE == TYPE_INT) return valInt <= o.valInt;
	else if (TYPE == TYPE_DOUBLE) return valDouble < o.valDouble + eps;
	else assert(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x20(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x3a3a6
jmp 0x3a3c5
leaq 0x2030c(%rip), %rdi     # 0x5a6b9
leaq 0x202c2(%rip), %rsi     # 0x5a676
movl $0x51, %edx
leaq 0x2036c(%rip), %rcx     # 0x5a72c
callq 0x31a0
movq -0x20(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x3a3e7
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
setle %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3a434
movq -0x20(%rbp), %rax
cmpl $0x2, 0x20(%rax)
jne 0x3a415
movq -0x20(%rbp), %rax
fldt 0x10(%rax)
movq -0x18(%rbp), %rax
fldt 0x10(%rax)
fldl 0x1f39b(%rip)           # 0x597a0
faddp %st, %st(1)
fucompi %st(1), %st
fstp %st(0)
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3a434
leaq 0x1ed54(%rip), %rdi     # 0x59170
leaq 0x20253(%rip), %rsi     # 0x5a676
movl $0x54, %edx
leaq 0x202fd(%rip), %rcx     # 0x5a72c
callq 0x31a0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::valueT::operator+(PMC::valueT const&) const
valueT valueT::operator+(const valueT& o) const {
	assert(TYPE == o.TYPE);
	if (TYPE == TYPE_INT) return valueT(valInt + o.valInt);
	else if (TYPE == TYPE_DOUBLE) return valueT(valDouble + o.valDouble);
	else assert(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x20(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x3a53e
jmp 0x3a55d
leaq 0x20174(%rip), %rdi     # 0x5a6b9
leaq 0x2012a(%rip), %rsi     # 0x5a676
movl $0x5d, %edx
leaq 0x2023a(%rip), %rcx     # 0x5a792
callq 0x31a0
movq -0x18(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x3a580
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
addq (%rax), %rsi
callq 0x3a0f0
jmp 0x3a5c9
movq -0x18(%rbp), %rax
cmpl $0x2, 0x20(%rax)
jne 0x3a5aa
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
fldt 0x10(%rax)
movq -0x10(%rbp), %rax
fldt 0x10(%rax)
faddp %st, %st(1)
movq %rsp, %rax
fstpt (%rax)
callq 0x3a110
jmp 0x3a5c9
leaq 0x1ebbf(%rip), %rdi     # 0x59170
leaq 0x200be(%rip), %rsi     # 0x5a676
movl $0x60, %edx
leaq 0x201ce(%rip), %rcx     # 0x5a792
callq 0x31a0
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::dfs1(Graph const&, int)
int dfs1(const Graph& G, int x) {
	assert(u[x] == 0);
	u[x] = 1;
	int r = 0;
	for (int nx : G.g[x]) {
		if (u[nx] == 0) r += dfs1(G, nx);
		else if (u[nx] > 1 && u[nx] < it) {
			u[nx] = it;
			r++;
		}
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x5f8af6(%rip), %rax    # 0x6330f0
cmpl $0x0, (%rax,%rcx,4)
jne 0x3a602
jmp 0x3a621
leaq 0x1f7e5(%rip), %rdi     # 0x59dee
leaq 0x20066(%rip), %rsi     # 0x5a676
movl $0x64, %edx
leaq 0x201aa(%rip), %rcx     # 0x5a7c6
callq 0x31a0
movslq -0xc(%rbp), %rcx
leaq 0x5f8ac4(%rip), %rax    # 0x6330f0
movl $0x1, (%rax,%rcx,4)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0xbba0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6680
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x66b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x3a67f
jmp 0x3a708
leaq -0x20(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rcx
leaq 0x5f8a58(%rip), %rax    # 0x6330f0
cmpl $0x0, (%rax,%rcx,4)
jne 0x3a6b2
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x3a5e0
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x3a6f8
movslq -0x2c(%rbp), %rcx
leaq 0x5f8a33(%rip), %rax    # 0x6330f0
cmpl $0x1, (%rax,%rcx,4)
jle 0x3a6f6
movslq -0x2c(%rbp), %rcx
leaq 0x5f8a22(%rip), %rax    # 0x6330f0
movl (%rax,%rcx,4), %eax
cmpl 0x65a499(%rip), %eax    # 0x694b70
jge 0x3a6f6
movl 0x65a491(%rip), %edx    # 0x694b70
movslq -0x2c(%rbp), %rcx
leaq 0x5f8a06(%rip), %rax    # 0x6330f0
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3a6f8
jmp 0x3a6fa
leaq -0x20(%rbp), %rdi
callq 0xbc80
jmp 0x3a669
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::hasFullComponent(Graph const&, std::vector<int, std::allocator<int>> const&)
bool hasFullComponent(const Graph& G, const vector<int>& separator) {
	for (int i = 0; i < G.n; i++) {
		u[i] = 0;
	}
	it = 2;
	for (int x : separator) {
		assert(u[x] == 0);
		u[x] = it;
	}
	for (int i = 0; i < G.n; i++) {
		if (u[i] == 0) {
			it++;
			int c = dfs1(G, i);
			assert(c <= (int)separator.size());
			if (c == (int)separator.size()) {
				return true;
			}
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jge 0x3a760
movslq -0x1c(%rbp), %rcx
leaq 0x5f89a2(%rip), %rax    # 0x6330f0
movl $0x0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3a737
movl $0x2, 0x65a406(%rip)    # 0x694b70
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6680
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x66b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x3a79f
jmp 0x3a7fe
leaq -0x30(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0x5f8938(%rip), %rax    # 0x6330f0
cmpl $0x0, (%rax,%rcx,4)
jne 0x3a7c0
jmp 0x3a7df
leaq 0x1f627(%rip), %rdi     # 0x59dee
leaq 0x1fea8(%rip), %rsi     # 0x5a676
movl $0x77, %edx
leaq 0x2000e(%rip), %rcx     # 0x5a7e8
callq 0x31a0
movl 0x65a38b(%rip), %edx    # 0x694b70
movslq -0x3c(%rbp), %rcx
leaq 0x5f8900(%rip), %rax    # 0x6330f0
movl %edx, (%rax,%rcx,4)
leaq -0x30(%rbp), %rdi
callq 0xbc80
jmp 0x3a78c
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jge 0x3a8af
movslq -0x40(%rbp), %rcx
leaq 0x5f88d0(%rip), %rax    # 0x6330f0
cmpl $0x0, (%rax,%rcx,4)
jne 0x3a89f
movl 0x65a344(%rip), %eax    # 0x694b70
addl $0x1, %eax
movl %eax, 0x65a33b(%rip)    # 0x694b70
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0x3a5e0
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x59a0
movq %rax, %rcx
movl -0x48(%rbp), %eax
cmpl %ecx, %eax
jg 0x3a85f
jmp 0x3a87e
leaq 0x1ffc1(%rip), %rdi     # 0x5a827
leaq 0x1fe09(%rip), %rsi     # 0x5a676
movl $0x7e, %edx
leaq 0x1ff6f(%rip), %rcx     # 0x5a7e8
callq 0x31a0
movl -0x44(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x59a0
movq %rax, %rcx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jne 0x3a89d
movb $0x1, -0x1(%rbp)
jmp 0x3a8b3
jmp 0x3a89f
jmp 0x3a8a1
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x3a805
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::dfs2(Graph const&, int)
void dfs2(const Graph& G, int x) {
	assert(u[x] == 0);
	u[x] = 1;
	for (int nx : G.g[x]) {
		if (u[nx] == 0) dfs2(G, nx);
		else if (u[nx] == 2) {
			u[nx] = 3;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x5f8816(%rip), %rax    # 0x6330f0
cmpl $0x0, (%rax,%rcx,4)
jne 0x3a8e2
jmp 0x3a901
leaq 0x1f505(%rip), %rdi     # 0x59dee
leaq 0x1fd86(%rip), %rsi     # 0x5a676
movl $0x88, %edx
leaq 0x1ff46(%rip), %rcx     # 0x5a842
callq 0x31a0
movslq -0xc(%rbp), %rcx
leaq 0x5f87e4(%rip), %rax    # 0x6330f0
movl $0x1, (%rax,%rcx,4)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0xbba0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6680
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x66b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x3a955
jmp 0x3a9b4
leaq -0x20(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rcx
leaq 0x5f8782(%rip), %rax    # 0x6330f0
cmpl $0x0, (%rax,%rcx,4)
jne 0x3a982
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x3a8c0
jmp 0x3a9a7
movslq -0x2c(%rbp), %rcx
leaq 0x5f8763(%rip), %rax    # 0x6330f0
cmpl $0x2, (%rax,%rcx,4)
jne 0x3a9a5
movslq -0x2c(%rbp), %rcx
leaq 0x5f8752(%rip), %rax    # 0x6330f0
movl $0x3, (%rax,%rcx,4)
jmp 0x3a9a7
jmp 0x3a9a9
leaq -0x20(%rbp), %rdi
callq 0xbc80
jmp 0x3a942
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::extend2(Graph const&, std::vector<int, std::allocator<int>> const&, int)
bool extend2(const Graph& G, const vector<int>& pmc, int a) {
	assert(a < G.n);
	for (int i = 0; i < G.n; i++) {
		u[i] = 0;
	}
	for (int x : pmc) {
		u[x] = 2;
	}
	dfs2(G, a);
	for (int x : pmc) {
		if (u[x] != 3) return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jge 0x3a9e1
jmp 0x3aa00
leaq 0x1fe7d(%rip), %rdi     # 0x5a865
leaq 0x1fc87(%rip), %rsi     # 0x5a676
movl $0x93, %edx
leaq 0x1fe72(%rip), %rcx     # 0x5a86d
callq 0x31a0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jge 0x3aa30
movslq -0x20(%rbp), %rcx
leaq 0x5f86d2(%rip), %rax    # 0x6330f0
movl $0x0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3aa07
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6680
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x66b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x3aa65
jmp 0x3aa90
leaq -0x30(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0x5f8672(%rip), %rax    # 0x6330f0
movl $0x2, (%rax,%rcx,4)
leaq -0x30(%rbp), %rdi
callq 0xbc80
jmp 0x3aa52
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3a8c0
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x6680
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x66b0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x3aad1
jmp 0x3ab03
leaq -0x50(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
movslq -0x5c(%rbp), %rcx
leaq 0x5f8606(%rip), %rax    # 0x6330f0
cmpl $0x3, (%rax,%rcx,4)
je 0x3aaf6
movb $0x0, -0x1(%rbp)
jmp 0x3ab07
jmp 0x3aaf8
leaq -0x50(%rbp), %rdi
callq 0xbc80
jmp 0x3aabe
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::dfs3(Graph const&, int, std::vector<int, std::allocator<int>>&)
int dfs3(const Graph& G, int x, vector<int>& co) {
	assert(u[x] == 0);
	u[x] = 1;
	co.push_back(x);
	int r = 0;
	for (int nx : G.g[x]) {
		if (u[nx] == 0) r += dfs3(G, nx, co);
		else if (u[nx] > 1 && u[nx] < it) {
			u[nx] = it;
			r++;
		}
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x5f8342(%rip), %rax    # 0x6330f0
cmpl $0x0, (%rax,%rcx,4)
jne 0x3adb6
jmp 0x3add5
leaq 0x1f031(%rip), %rdi     # 0x59dee
leaq 0x1f8b2(%rip), %rsi     # 0x5a676
movl $0xb9, %edx
leaq 0x1fb23(%rip), %rcx     # 0x5a8f3
callq 0x31a0
movslq -0xc(%rbp), %rcx
leaq 0x5f8310(%rip), %rax    # 0x6330f0
movl $0x1, (%rax,%rcx,4)
movq -0x18(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0xdff0
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0xbba0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6680
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x66b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x3ae40
jmp 0x3aecd
leaq -0x30(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0x5f8297(%rip), %rax    # 0x6330f0
cmpl $0x0, (%rax,%rcx,4)
jne 0x3ae77
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x3ad90
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x3aebd
movslq -0x3c(%rbp), %rcx
leaq 0x5f826e(%rip), %rax    # 0x6330f0
cmpl $0x1, (%rax,%rcx,4)
jle 0x3aebb
movslq -0x3c(%rbp), %rcx
leaq 0x5f825d(%rip), %rax    # 0x6330f0
movl (%rax,%rcx,4), %eax
cmpl 0x659cd4(%rip), %eax    # 0x694b70
jge 0x3aebb
movl 0x659ccc(%rip), %edx    # 0x694b70
movslq -0x3c(%rbp), %rcx
leaq 0x5f8241(%rip), %rax    # 0x6330f0
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3aebd
jmp 0x3aebf
leaq -0x30(%rbp), %rdi
callq 0xbc80
jmp 0x3ae2a
movl -0x1c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)