LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/MCS.cpp
// Function: MCS::MCS_L(Graph const&, int, std::vector<int, std::allocator<int>> const&)
vector<int> MCS_L(const Graph& G, int sv, const vector<int>& rmV) {
	assert(rmV[sv] == 0);
	vector<int> order;
	q[0].push_back(sv);
	int mLb = 0;
	while (mLb >= 0) {
		if (q[mLb].size() == 0) {
			mLb--;
			continue;
		}
		int x = q[mLb].back();
		q[mLb].pop_back();
		if (tr[x]) continue;
		order.push_back(x);
		for (int nx : G.g[x]) {
			if (!rmV[nx] && !tr[nx]) {
				lb[nx]++;
				q[lb[nx]].push_back(nx);
				mLb = max(mLb, lb[nx]);
			}
		}
		tr[x] = 1;
	}
	reverse(order.begin(), order.end());
	for (int x : order) {
		tr[x] = 0;
		lb[x] = 0;
	}
	return order;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rsi, 0x20(%rsp)
movl %edx, 0x14(%rsp)
movslq %edx, %rax
movq (%rcx), %rcx
cmpl $0x0, (%rcx,%rax,4)
jne 0xed4e
movq %rdi, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x1465d0(%rip), %r13    # 0x1551e0
leaq 0x14(%rsp), %rsi
movq %r13, %rdi
movq %r15, 0x18(%rsp)
callq 0x6402
xorl %ebx, %ebx
testl %ebx, %ebx
js 0xed05
movl %ebx, %eax
imulq $0x18, %rax, %rax
movq 0x8(%rax,%r13), %rcx
cmpq (%rax,%r13), %rcx
je 0xece1
movslq -0x4(%rcx), %rdx
addq $-0x4, %rcx
movl %edx, 0xc(%rsp)
movq %rcx, 0x8(%rax,%r13)
leaq 0x35f747(%rip), %rax    # 0x36e3a0
cmpl $0x0, (%rax,%rdx,4)
jne 0xec24
movq %r15, %rdi
leaq 0xc(%rsp), %rsi
callq 0x6402
movslq 0xc(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x38(%rcx), %rcx
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %rbp
movq 0x8(%rcx,%rax), %r15
cmpq %r15, %rbp
je 0xece8
movslq (%rbp), %rax
movl %eax, 0x10(%rsp)
movq (%r14), %rcx
cmpl $0x0, (%rcx,%rax,4)
jne 0xecdb
leaq 0x35f6fc(%rip), %rcx    # 0x36e3a0
cmpl $0x0, (%rcx,%rax,4)
jne 0xecdb
leaq 0x32e9af(%rip), %r12    # 0x33d660
movslq (%r12,%rax,4), %rcx
incq %rcx
movl %ecx, (%r12,%rax,4)
imulq $0x18, %rcx, %rdi
addq %r13, %rdi
leaq 0x10(%rsp), %rsi
callq 0x6402
movslq 0x10(%rsp), %rax
movl (%r12,%rax,4), %eax
cmpl %eax, %ebx
cmovlel %eax, %ebx
addq $0x4, %rbp
jmp 0xec87
decl %ebx
jmp 0xec24
movslq 0xc(%rsp), %rax
leaq 0x35f6ac(%rip), %rcx    # 0x36e3a0
movl $0x1, (%rcx,%rax,4)
movq 0x18(%rsp), %r15
jmp 0xec24
movq (%r15), %rdi
movq 0x8(%r15), %rsi
callq 0x10b51
movq (%r15), %rax
movq 0x8(%r15), %rcx
leaq 0x32e941(%rip), %rsi    # 0x33d660
leaq 0x35f67a(%rip), %rdi    # 0x36e3a0
cmpq %rcx, %rax
je 0xed3c
movslq (%rax), %rdx
andl $0x0, (%rdi,%rdx,4)
andl $0x0, (%rsi,%rdx,4)
addq $0x4, %rax
jmp 0xed26
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1207c(%rip), %rdi     # 0x20dd1
leaq 0x11f83(%rip), %rsi     # 0x20cdf
leaq 0x1207b(%rip), %rcx     # 0x20dde
movl $0xa8, %edx
callq 0x2150
jmp 0xed73
jmp 0xed73
jmp 0xed73
movq %rax, %r14
movq 0x18(%rsp), %rdi
callq 0x38e4
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
testl %edx, %edx
js 0x11562
movq %rdi, %rbx
cmpl %edx, %ecx
jge 0x1154f
leaq 0x4b2b1b(%rip), %rsi    # 0x4c4060
movq %rbx, %rdi
callq 0x35f2
jmp 0x1155d
movl %r8d, %r9d
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x10d50
movq %rbx, %rax
popq %rbx
retq
leaq 0xede5(%rip), %rdi      # 0x2034e
leaq 0xfba8(%rip), %rsi      # 0x21118
leaq 0xfc9d(%rip), %rcx      # 0x21214
pushq $0x42
popq %rdx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
movl %esi, 0x575dbf(%rip)    # 0x587580
movslq %esi, %rax
leaq 0x4e35f5(%rip), %rcx    # 0x4f4dc0
movl $0x1, (%rcx,%rax,4)
movq 0x38(%rdi), %r9
movl $0x1, %r8d
xorl %eax, %eax
leaq 0x575d9b(%rip), %rsi    # 0x587580
leaq 0x4b2894(%rip), %r10    # 0x4c4080
xorl %r11d, %r11d
movl %r8d, %edi
movslq %edi, %rbx
cmpq %rbx, %r11
jge 0x11844
movslq (%rsi,%r11,4), %rbx
incq %r11
imulq $0x18, %rbx, %r14
movq (%r9,%r14), %rbx
movq 0x8(%r9,%r14), %r14
cmpq %r14, %rbx
je 0x117f2
movl (%rbx), %ebp
movslq %ebp, %r15
cmpl $0x0, (%rcx,%r15,4)
jne 0x1183b
cmpl $0x0, (%r10,%r15,4)
jne 0x1183b
cmpl %edx, %ebp
je 0x11841
movl $0x1, (%rcx,%r15,4)
movslq %edi, %r15
incl %edi
movl %ebp, (%rsi,%r15,4)
addq $0x4, %rbx
jmp 0x1180e
movl %r8d, %eax
xorl %edx, %edx
testl %edi, %edi
cmovlel %edx, %edi
shlq $0x2, %rdi
cmpq %rdx, %rdi
je 0x11863
movslq (%rdx,%rsi), %r8
andl $0x0, (%rcx,%r8,4)
addq $0x4, %rdx
jmp 0x1184f
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/minfill.cpp
// Function: MinFill::SolveAtom::nbClique(Graph&)
pair<int, pair<int, int> > nbClique(Graph& G) {
	int minF = (int)1e9;
	for (int x = 0; x < G.n; x++) {
		assert(G.g[x].size() > 2);
		pair<int, int> fo = {-1, -1};
		bool fail = false;
		bool brk = false;
		int cnt = 0;
		for (int i = 0; i < (int)G.g[x].size(); i++) {
			for (int ii = i+1; ii < (int)G.g[x].size(); ii++) {
				if (!G.hasEdge(G.g[x][i], G.g[x][ii])) {
					cnt++;
					if (fo.F != -1) {
						fail = true;
						if (cnt >= minF) {
							brk = true;
							break;
						}
					}
					else {
						fo = {G.g[x][i], G.g[x][ii]};
					}
				}
			}
			if (brk) break;
		}
		if (!fail) {
			assert(fo.F != -1);
			return {-1, fo};
		}
		minF = min(minF, cnt);
	}
	return {minF, {-1, -1}};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl $0x3b9aca00, (%rsp)     # imm = 0x3B9ACA00
xorl %esi, %esi
movslq 0x50(%rbx), %rax
cmpq %rax, %rsi
jge 0x13301
movq 0x38(%rbx), %rcx
imulq $0x18, %rsi, %r13
movq (%rcx,%r13), %rax
movq 0x8(%rcx,%r13), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x9, %rdx
jb 0x13348
movq %rsi, 0x20(%rsp)
xorl %r14d, %r14d
pushq $0x1
popq %r12
xorl %r15d, %r15d
pushq $-0x1
popq %rdx
movl %edx, 0x4(%rsp)
movq %rdx, 0x8(%rsp)
xorl %ebp, %ebp
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x2, %rdx
movslq %edx, %rdx
cmpq %rdx, %r14
jge 0x132e1
leaq 0x1(%r14), %rdx
movq %rdx, 0x28(%rsp)
movq %r12, 0x30(%rsp)
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x2, %rdx
cmpl %edx, %r12d
jge 0x132cf
movl (%rax,%r14,4), %esi
movl (%rax,%r12,4), %edx
movq %rbx, %rdi
callq 0x7f98
testb %al, %al
jne 0x132bd
incl %r15d
cmpl $-0x1, 0x4(%rsp)
je 0x132a4
movb $0x1, %bpl
cmpl (%rsp), %r15d
jl 0x132bd
jmp 0x132e7
movq 0x38(%rbx), %rax
movq (%rax,%r13), %rax
movl (%rax,%r14,4), %ecx
movl %ecx, 0x4(%rsp)
movl (%rax,%r12,4), %eax
movq %rax, 0x8(%rsp)
incq %r12
movq 0x38(%rbx), %rcx
movq (%rcx,%r13), %rax
movq 0x8(%rcx,%r13), %rcx
jmp 0x1326c
movq 0x30(%rsp), %r12
incq %r12
movq 0x28(%rsp), %r14
jmp 0x13248
testb $0x1, %bpl
je 0x13327
movl (%rsp), %eax
cmpl %eax, %r15d
cmovll %r15d, %eax
movl %eax, (%rsp)
movq 0x20(%rsp), %rsi
incq %rsi
jmp 0x131fd
movl (%rsp), %eax
movl %eax, 0x10(%rsp)
pushq $-0x1
popq %rdx
pushq $-0x1
popq %rax
movq %rax, 0x14(%rsp)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%rsp), %eax
cmpl $-0x1, %eax
je 0x13367
orl $-0x1, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq %rdx, %rcx
shlq $0x20, %rcx
movl %eax, %eax
orq %rcx, %rax
jmp 0x1330e
leaq 0xe1c4(%rip), %rdi      # 0x21513
leaq 0xddc2(%rip), %rsi      # 0x21118
leaq 0xe1c8(%rip), %rcx      # 0x21525
movl $0x1e0, %edx            # imm = 0x1E0
callq 0x2150
leaq 0xe1f7(%rip), %rdi      # 0x21565
leaq 0xdda3(%rip), %rsi      # 0x21118
leaq 0xe1a9(%rip), %rcx      # 0x21525
movl $0x1f8, %edx            # imm = 0x1F8
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movl 0x20(%rdi), %eax
cmpl 0x20(%rsi), %eax
jne 0x14c2b
cmpl $0x2, %eax
je 0x14c1c
cmpl $0x1, %eax
jne 0x14c44
movq (%rdi), %rax
cmpq (%rsi), %rax
setl %al
jmp 0x14c29
fldt 0x10(%rdi)
fldt 0x10(%rsi)
fucompi %st(1), %st
fstp %st(0)
seta %al
popq %rcx
retq
leaq 0xcad7(%rip), %rdi      # 0x21709
leaq 0xca8d(%rip), %rsi      # 0x216c6
leaq 0xcad8(%rip), %rcx      # 0x21718
pushq $0x45
jmp 0x14c5b
leaq 0xb525(%rip), %rdi      # 0x20170
leaq 0xca74(%rip), %rsi      # 0x216c6
leaq 0xcabf(%rip), %rcx      # 0x21718
pushq $0x48
popq %rdx
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movl 0x20(%rdi), %eax
cmpl 0x20(%rsi), %eax
jne 0x14cfd
cmpl $0x2, %eax
je 0x14ce6
cmpl $0x1, %eax
jne 0x14d16
movq (%rdi), %rax
cmpq (%rsi), %rax
setle %al
jmp 0x14cfb
fldt 0x10(%rsi)
faddl 0xbae1(%rip)            # 0x207d0
fldt 0x10(%rdi)
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
seta %al
popq %rcx
retq
leaq 0xca05(%rip), %rdi      # 0x21709
leaq 0xc9bb(%rip), %rsi      # 0x216c6
leaq 0xca6a(%rip), %rcx      # 0x2177c
pushq $0x51
jmp 0x14d2d
leaq 0xb453(%rip), %rdi      # 0x20170
leaq 0xc9a2(%rip), %rsi      # 0x216c6
leaq 0xca51(%rip), %rcx      # 0x2177c
pushq $0x54
popq %rdx
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movl 0x20(%rsi), %eax
cmpl 0x20(%rdx), %eax
jne 0x14dda
cmpl $0x2, %eax
je 0x14dc3
cmpl $0x1, %eax
jne 0x14df3
movq (%rdx), %rax
addq (%rsi), %rax
movl $0x1, 0x20(%rdi)
movq %rax, (%rdi)
jmp 0x14dd5
fldt 0x10(%rsi)
fldt 0x10(%rdx)
faddp %st, %st(1)
movl $0x2, 0x20(%rdi)
fstpt 0x10(%rdi)
movq %rdi, %rax
popq %rcx
retq
leaq 0xc928(%rip), %rdi      # 0x21709
leaq 0xc8de(%rip), %rsi      # 0x216c6
leaq 0xc9f3(%rip), %rcx      # 0x217e2
pushq $0x5d
jmp 0x14e0a
leaq 0xb376(%rip), %rdi      # 0x20170
leaq 0xc8c5(%rip), %rsi      # 0x216c6
leaq 0xc9da(%rip), %rcx      # 0x217e2
pushq $0x60
popq %rdx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq %esi, %rax
leaq 0x5d41fe(%rip), %r14    # 0x5e9020
cmpl $0x0, (%r14,%rax,4)
jne 0x14e89
movq %rdi, %rbx
movl $0x1, (%r14,%rax,4)
movq 0x38(%rdi), %rcx
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %r15
movq 0x8(%rcx,%rax), %r12
xorl %ebp, %ebp
cmpq %r12, %r15
je 0x14e7e
movslq (%r15), %rsi
movl (%r14,%rsi,4), %eax
testl %eax, %eax
je 0x14e6e
cmpl $0x2, %eax
jl 0x14e78
movl 0x635c3e(%rip), %ecx    # 0x64aaa0
cmpl %ecx, %eax
jge 0x14e78
movl %ecx, (%r14,%rsi,4)
incl %ebp
jmp 0x14e78
movq %rbx, %rdi
callq 0x14e10
addl %eax, %ebp
addq $0x4, %r15
jmp 0x14e47
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbf8e(%rip), %rdi      # 0x20e1e
leaq 0xc82f(%rip), %rsi      # 0x216c6
leaq 0xc978(%rip), %rcx      # 0x21816
pushq $0x64
popq %rdx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5d4164(%rip), %rax    # 0x5e9020
xorl %ecx, %ecx
movslq 0x50(%r14), %rdx
cmpq %rdx, %rcx
jge 0x14ed3
andl $0x0, (%rax)
incq %rcx
addq $0x4, %rax
jmp 0x14ebe
movl $0x2, 0x635bc3(%rip)    # 0x64aaa0
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x5d4135(%rip), %r12    # 0x5e9020
cmpq %rcx, %rax
je 0x14f08
movslq (%rax), %rdx
cmpl $0x0, (%r12,%rdx,4)
jne 0x14f56
movl $0x2, (%r12,%rdx,4)
addq $0x4, %rax
jmp 0x14eeb
xorl %r15d, %r15d
movslq 0x50(%r14), %r13
cmpq %r13, %r15
jge 0x14f46
cmpl $0x0, (%r12)
jne 0x14f3d
incl 0x635b7f(%rip)          # 0x64aaa0
movq %r14, %rdi
movl %r15d, %esi
callq 0x14e10
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
shrq $0x2, %rcx
cmpl %ecx, %eax
jg 0x14f6f
je 0x14f46
incq %r15
addq $0x4, %r12
jmp 0x14f0b
cmpq %r13, %r15
setl %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xbec1(%rip), %rdi      # 0x20e1e
leaq 0xc762(%rip), %rsi      # 0x216c6
leaq 0xc8cd(%rip), %rcx      # 0x21838
pushq $0x77
jmp 0x14f86
leaq 0xc901(%rip), %rdi      # 0x21877
leaq 0xc749(%rip), %rsi      # 0x216c6
leaq 0xc8b4(%rip), %rcx      # 0x21838
pushq $0x7e
popq %rdx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movslq %esi, %rax
leaq 0x5d4082(%rip), %r14    # 0x5e9020
cmpl $0x0, (%r14,%rax,4)
jne 0x14ffa
movq %rdi, %rbx
movl $0x1, (%r14,%rax,4)
movq 0x38(%rdi), %rcx
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %r15
movq 0x8(%rcx,%rax), %r12
cmpq %r12, %r15
je 0x14fee
movslq (%r15), %rsi
movl (%r14,%rsi,4), %eax
cmpl $0x2, %eax
je 0x14fe0
testl %eax, %eax
jne 0x14fe8
movq %rbx, %rdi
callq 0x14f8c
jmp 0x14fe8
movl $0x3, (%r14,%rsi,4)
addq $0x4, %r15
jmp 0x14fc1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xbe1d(%rip), %rdi      # 0x20e1e
leaq 0xc6be(%rip), %rsi      # 0x216c6
leaq 0xc883(%rip), %rcx      # 0x21892
movl $0x88, %edx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x50(%rdi), %esi
cmpl %edx, %esi
jle 0x1509d
leaq 0x5d3ff2(%rip), %rax    # 0x5e9020
xorl %ecx, %ecx
movslq %esi, %rsi
cmpq %rsi, %rcx
jge 0x15047
andl $0x0, (%rax)
incq %rcx
movl 0x50(%rdi), %esi
addq $0x4, %rax
jmp 0x15030
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x5d3fcb(%rip), %r14    # 0x5e9020
cmpq %rcx, %rax
je 0x1506b
movslq (%rax), %rsi
movl $0x2, (%r14,%rsi,4)
addq $0x4, %rax
jmp 0x15055
movl %edx, %esi
callq 0x14f8c
movq (%rbx), %rdx
movq 0x8(%rbx), %rax
movq %rdx, %rcx
cmpq %rax, %rdx
je 0x1508f
movslq (%rcx), %rsi
leaq 0x4(%rcx), %rdx
cmpl $0x3, (%r14,%rsi,4)
je 0x15079
cmpq %rax, %rcx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xc811(%rip), %rdi      # 0x218b5
leaq 0xc61b(%rip), %rsi      # 0x216c6
leaq 0xc80b(%rip), %rcx      # 0x218bd
movl $0x93, %edx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::isPMCbrute(Graph const&, std::vector<int, std::allocator<int>> const&)
bool isPMCbrute(const Graph& G, const vector<int>& pmc) {
	for (int x : pmc) {
		assert(x >= 0 && x < G.n);
	}
	if (hasFullComponent(G, pmc)) return false;
	for (int x : pmc) {
		for (int i = 0; i < G.n; i++) {
			u[i] = 0;
		}
		for (int y : pmc) {
			if (y != x) {
				u[y] = 2;
			}
		}
		dfs2(G, x);
		for (int y : pmc) {
			if (y != x) {
				if (u[y] != 3) return false;
			}
		}
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movl 0x50(%rdi), %edx
cmpq %rcx, %rax
je 0x15109
movl (%rax), %esi
testl %esi, %esi
js 0x150ea
addq $0x4, %rax
cmpl %edx, %esi
jl 0x150d7
leaq 0xc807(%rip), %rdi      # 0x218f8
leaq 0xc5ce(%rip), %rsi      # 0x216c6
leaq 0xc80b(%rip), %rcx      # 0x2190a
movl $0xa3, %edx
callq 0x2150
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14ea6
testb %al, %al
je 0x15129
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
movq 0x8(%rbx), %r15
leaq 0x5d3ee9(%rip), %r12    # 0x5e9020
movq %r15, %rcx
movq %rax, %r13
cmpq %r15, %r13
je 0x151af
movl (%r13), %ebp
movq %r12, %rdx
xorl %esi, %esi
movslq 0x50(%r14), %rdi
cmpq %rdi, %rsi
jge 0x15173
andl $0x0, (%rdx)
incq %rsi
addq $0x4, %rdx
jmp 0x1514b
movslq (%rax), %rdx
cmpl %ebp, %edx
je 0x1516f
movl $0x2, (%r12,%rdx,4)
addq $0x4, %rax
cmpq %rcx, %rax
jne 0x15160
movq %r14, %rdi
movl %ebp, %esi
callq 0x14f8c
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, %rdx
cmpq %rcx, %rdx
je 0x151a9
movslq (%rdx), %rsi
cmpl %ebp, %esi
je 0x151a3
cmpl $0x3, (%r12,%rsi,4)
jne 0x15118
addq $0x4, %rdx
jmp 0x1518c
addq $0x4, %r13
jmp 0x1513d
movb $0x1, %al
jmp 0x1511a
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
movslq %esi, %rax
leaq 0x5d3e51(%rip), %r12    # 0x5e9020
cmpl $0x0, (%r12,%rax,4)
jne 0x15255
movq %rdx, %rbx
movq %rdi, %r14
movl $0x1, (%r12,%rax,4)
leaq 0x4(%rsp), %r15
movq %rdx, %rdi
movq %r15, %rsi
callq 0x6402
movslq (%r15), %rax
movq 0x38(%r14), %rcx
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %r15
movq 0x8(%rcx,%rax), %r13
xorl %ebp, %ebp
cmpq %r13, %r15
je 0x15244
movslq (%r15), %rsi
movl (%r12,%rsi,4), %eax
testl %eax, %eax
je 0x15231
cmpl $0x2, %eax
jl 0x1523e
movl 0x63587b(%rip), %ecx    # 0x64aaa0
cmpl %ecx, %eax
jge 0x1523e
movl %ecx, (%r12,%rsi,4)
incl %ebp
jmp 0x1523e
movq %r14, %rdi
movq %rbx, %rdx
callq 0x151b6
addl %eax, %ebp
addq $0x4, %r15
jmp 0x1520a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbbc2(%rip), %rdi      # 0x20e1e
leaq 0xc463(%rip), %rsi      # 0x216c6
leaq 0xc6d9(%rip), %rcx      # 0x21943
movl $0xb9, %edx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::getFullComponents(Graph const&, std::vector<int, std::allocator<int>> const&)
vector<vector<int> > getFullComponents(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;
	}
	vector<vector<int> > ret;
	for (int i = 0; i < G.n; i++) {
		if (u[i] == 0) {
			it++;
			vector<int> co;
			int c = dfs3(G, i, co);
			assert(c <= (int)separator.size());
			if (c == (int)separator.size()) {
				sort(co.begin(), co.end());
				ret.push_back(co);
			}
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x5d3d8e(%rip), %rax    # 0x5e9020
xorl %ecx, %ecx
movslq 0x50(%r15), %rdx
cmpq %rdx, %rcx
jge 0x152a9
andl $0x0, (%rax)
incq %rcx
addq $0x4, %rax
jmp 0x15294
movl $0x2, 0x6357ed(%rip)    # 0x64aaa0
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x5d3d5f(%rip), %rbp    # 0x5e9020
cmpq %rcx, %rax
je 0x152e2
movslq (%rax), %rdx
cmpl $0x0, (%rbp,%rdx,4)
jne 0x15370
movl $0x2, (%rbp,%rdx,4)
addq $0x4, %rax
jmp 0x152c1
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %r12d, %r12d
movq %rsp, %r13
movslq 0x50(%r15), %rax
cmpq %rax, %r12
jge 0x1535e
cmpl $0x0, (%rbp)
jne 0x15355
incl 0x635798(%rip)          # 0x64aaa0
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %r15, %rdi
movl %r12d, %esi
movq %r13, %rdx
callq 0x151b6
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x2, %rcx
cmpl %ecx, %eax
jg 0x1538f
jne 0x1534d
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x8dde
movq %rbx, %rdi
movq %r13, %rsi
callq 0x88a4
movq %r13, %rdi
callq 0x38e4
incq %r12
addq $0x4, %rbp
jmp 0x152f3
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbaa7(%rip), %rdi      # 0x20e1e
leaq 0xc348(%rip), %rsi      # 0x216c6
leaq 0xc5ef(%rip), %rcx      # 0x21974
movl $0xcc, %edx
callq 0x2150
leaq 0xc4e1(%rip), %rdi      # 0x21877
leaq 0xc329(%rip), %rsi      # 0x216c6
leaq 0xc5d0(%rip), %rcx      # 0x21974
movl $0xd5, %edx
callq 0x2150
movq %rax, %r14
movq %rsp, %rdi
callq 0x38e4
movq %rbx, %rdi
callq 0x376e
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::getComponents(Graph const&, std::vector<int, std::allocator<int>> const&)
vector<vector<int> > getComponents(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;
	}
	vector<vector<int> > ret;
	for (int i = 0; i < G.n; i++) {
		if (u[i] == 0) {
			it++;
			vector<int> co;
			int c = dfs3(G, i, co);
			assert(c <= (int)separator.size());
			sort(co.begin(), co.end());
			ret.push_back(co);
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x5d3c39(%rip), %rax    # 0x5e9020
xorl %ecx, %ecx
movslq 0x50(%r15), %rdx
cmpq %rdx, %rcx
jge 0x153fe
andl $0x0, (%rax)
incq %rcx
addq $0x4, %rax
jmp 0x153e9
movl $0x2, 0x635698(%rip)    # 0x64aaa0
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x5d3c0a(%rip), %rbp    # 0x5e9020
cmpq %rcx, %rax
je 0x15437
movslq (%rax), %rdx
cmpl $0x0, (%rbp,%rdx,4)
jne 0x154c3
movl $0x2, (%rbp,%rdx,4)
addq $0x4, %rax
jmp 0x15416
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %r12d, %r12d
movq %rsp, %r13
movslq 0x50(%r15), %rax
cmpq %rax, %r12
jge 0x154b1
cmpl $0x0, (%rbp)
jne 0x154a8
incl 0x635643(%rip)          # 0x64aaa0
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %r15, %rdi
movl %r12d, %esi
movq %r13, %rdx
callq 0x151b6
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x2, %rcx
cmpl %ecx, %eax
jg 0x154e2
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x8dde
movq %rbx, %rdi
movq %r13, %rsi
callq 0x88a4
movq %r13, %rdi
callq 0x38e4
incq %r12
addq $0x4, %rbp
jmp 0x15448
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb954(%rip), %rdi      # 0x20e1e
leaq 0xc1f5(%rip), %rsi      # 0x216c6
leaq 0xc4eb(%rip), %rcx      # 0x219c3
movl $0xe4, %edx
callq 0x2150
leaq 0xc38e(%rip), %rdi      # 0x21877
leaq 0xc1d6(%rip), %rsi      # 0x216c6
leaq 0xc4cc(%rip), %rcx      # 0x219c3
movl $0xed, %edx
callq 0x2150
movq %rax, %r14
movq %rsp, %rdi
callq 0x38e4
movq %rbx, %rdi
callq 0x376e
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::mergeCost(PMC::valueT, PMC::valueT, int)
valueT mergeCost(valueT cost1, valueT cost2, int PROBLEM) {
	if (PROBLEM == PROBLEM_TREEWIDTH) return max(cost1, cost2);
	else if (PROBLEM == PROBLEM_MINFILL) return cost1+cost2;
	else if (PROBLEM == PROBLEM_BAYES) return cost1+cost2;
	else if (PROBLEM == PROBLEM_HYPER) return max(cost1, cost2);
	else if (PROBLEM == PROBLEM_DECIDE) return (int64_t)0;
	else if (PROBLEM == PROBLEM_FRACHYPER) return max(cost1, cost2);
	else assert(0);
}

// Assembly:
pushq %rbx
decl %esi
cmpl $0x5, %esi
ja 0x15581
movq %rdi, %rbx
leaq 0x40(%rsp), %rdx
leaq 0x10(%rsp), %rax
leaq 0xc154(%rip), %rcx      # 0x2168c
movslq (%rcx,%rsi,4), %rsi
addq %rcx, %rsi
jmpq *%rsi
movq %rax, %rdi
movq %rdx, %rsi
callq 0x1957c
movaps (%rax), %xmm0
movaps 0x10(%rax), %xmm1
movaps 0x20(%rax), %xmm2
movaps %xmm0, (%rbx)
movaps %xmm1, 0x10(%rbx)
movaps %xmm2, 0x20(%rbx)
jmp 0x1557c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14d9e
jmp 0x1557c
movl $0x1, 0x20(%rbx)
andq $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0xabe8(%rip), %rdi      # 0x20170
leaq 0xc137(%rip), %rsi      # 0x216c6
leaq 0xc478(%rip), %rcx      # 0x21a0e
movl $0xfc, %edx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::dfs4(Graph const&, int, std::vector<int, std::allocator<int>>&)
void dfs4(const Graph& G, int x, vector<int>& nb) {
	assert(u[x] == 0);
	u[x] = 1;
	for (int nx : G.g[x]) {
		if (u[nx] == 0) dfs4(G, nx, nb);
		else if (u[nx] == 2) {
			nb.push_back(nx);
			u[nx] = 3;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq %esi, %rax
leaq 0x5d2f3f(%rip), %r12    # 0x5e9020
cmpl $0x0, (%r12,%rax,4)
jne 0x16160
movq %rdx, %rbx
movq %rdi, %r14
movl $0x1, (%r12,%rax,4)
movq 0x38(%rdi), %rcx
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %r13
movq 0x8(%rcx,%rax), %rbp
leaq 0x4(%rsp), %r15
cmpq %rbp, %r13
je 0x16151
movslq (%r13), %rsi
movl %esi, 0x4(%rsp)
movl (%r12,%rsi,4), %eax
cmpl $0x2, %eax
je 0x16133
testl %eax, %eax
jne 0x1614b
movq %r14, %rdi
movq %rbx, %rdx
callq 0x160cc
jmp 0x1614b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6402
movslq 0x4(%rsp), %rax
movl $0x3, (%r12,%rax,4)
addq $0x4, %r13
jmp 0x1610c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xacb7(%rip), %rdi      # 0x20e1e
leaq 0xb558(%rip), %rsi      # 0x216c6
leaq 0xba8d(%rip), %rcx      # 0x21c02
movl $0x18b, %edx            # imm = 0x18B
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::dfs(int, Graph const&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
void dfs(int x, const Graph& G, vector<int>& used, vector<int>& o) {
	if (used[x]) return;
	used[x]=1;
	o.push_back(x);
	for (int nx : G.g[x]) {
		dfs(nx, G, used, o);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl %edi, 0xc(%rsp)
movslq %edi, %rax
movq (%rdx), %rcx
cmpl $0x0, (%rcx,%rax,4)
je 0x16719
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %r14
movq %rsi, %r15
movl $0x1, (%rcx,%rax,4)
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6402
movslq (%r12), %rax
movq 0x38(%r15), %rcx
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %r12
movq 0x8(%rcx,%rax), %r13
cmpq %r13, %r12
je 0x1670b
movl (%r12), %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x166eb
addq $0x4, %r12
jmp 0x1674b
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::dfsord(Graph const&)
vector<int> dfsord(const Graph& G) {
	vector<int> used(G.n);
	vector<int> o;
	dfs(0, G, used, o);
	return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x50(%rsi), %rsi
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x8852
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
xorl %edi, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x166eb
leaq 0x8(%rsp), %rdi
callq 0x38e4
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x38e4
leaq 0x8(%rsp), %rdi
callq 0x38e4
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::dfs5(Graph const&, int, std::vector<int, std::allocator<int>>&)
int dfs5(const Graph& G, int x, vector<int>& co) {
	assert(u2[x] == 0);
	assert(u[x] != 3);
	u2[x] = 1;
	co.push_back(x);
	int r = 0;
	if (u[x] == 2) r++;
	for (int nx : G.g[x]) {
		if (!u2[nx] && u[nx] != 3) {
			r += dfs5(G, nx, co);
		}
	}
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movslq %esi, %rax
leaq 0x60303f(%rip), %r12    # 0x619d60
cmpl $0x0, (%r12,%rax,4)
jne 0x16db9
leaq 0x5d22ed(%rip), %r13    # 0x5e9020
cmpl $0x3, (%r13,%rax,4)
je 0x16dd8
movq %rdi, %r14
movl $0x1, (%r12,%rax,4)
leaq 0xc(%rsp), %r15
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x6402
movslq (%r15), %rax
xorl %ebp, %ebp
cmpl $0x2, (%r13,%rax,4)
sete %bpl
movq 0x38(%r14), %rcx
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %r15
movq 0x8(%rcx,%rax), %rbx
cmpq %rbx, %r15
je 0x16da8
movslq (%r15), %rsi
cmpl $0x0, (%r12,%rsi,4)
jne 0x16da2
cmpl $0x3, (%r13,%rsi,4)
je 0x16da2
movq %r14, %rdi
movq 0x10(%rsp), %rdx
callq 0x16d00
addl %eax, %ebp
addq $0x4, %r15
jmp 0x16d7c
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xaf6f(%rip), %rdi      # 0x21d2f
leaq 0xa8ff(%rip), %rsi      # 0x216c6
leaq 0xaf6c(%rip), %rcx      # 0x21d3a
movl $0x220, %edx            # imm = 0x220
callq 0x2150
leaq 0xaf8c(%rip), %rdi      # 0x21d6b
leaq 0xa8e0(%rip), %rsi      # 0x216c6
leaq 0xaf4d(%rip), %rcx      # 0x21d3a
movl $0x221, %edx            # imm = 0x221
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::dfs6(Graph const&, int, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
void dfs6(const Graph& G, int x, vector<int>& co, vector<int>& nb) {
	assert(u[x] == 0);
	u[x] = 1;
	co.push_back(x);
	for (int nx : G.g[x]) {
		if (u[nx] == 0) dfs6(G, nx, co, nb);
		if (u[nx] >= 2 && u[nx] < it) {
			nb.push_back(nx);
			u[nx] = it;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
movslq %esi, %rax
leaq 0x5d2210(%rip), %r13    # 0x5e9020
cmpl $0x0, (%r13,%rax,4)
jne 0x16ebb
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movl $0x1, (%r13,%rax,4)
leaq 0x4(%rsp), %r12
movq %rdx, %rdi
movq %r12, %rsi
callq 0x6402
movslq (%r12), %rax
movq 0x38(%r15), %rcx
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %rbp
movq 0x8(%rcx,%rax), %r12
cmpq %r12, %rbp
je 0x16eac
movslq (%rbp), %rsi
movl %esi, (%rsp)
movl (%r13,%rsi,4), %eax
testl %eax, %eax
jne 0x16e7f
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x16df7
movslq (%rsp), %rax
movl (%r13,%rax,4), %eax
cmpl $0x2, %eax
jl 0x16ea6
cmpl 0x633c16(%rip), %eax    # 0x64aaa0
jge 0x16ea6
movq %rbx, %rdi
movq %rsp, %rsi
callq 0x6402
movl 0x633c03(%rip), %eax    # 0x64aaa0
movslq (%rsp), %rcx
movl %eax, (%r13,%rcx,4)
addq $0x4, %rbp
jmp 0x16e53
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9f5c(%rip), %rdi      # 0x20e1e
leaq 0xa7fd(%rip), %rsi      # 0x216c6
leaq 0xaea5(%rip), %rcx      # 0x21d75
movl $0x22f, %edx            # imm = 0x22F
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/setcover.cpp
// Function: SetCover::init(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>)
void init(vector<vector<int> > ss) {
	assert(!hasInit);
	hasInit = true;
	gm = ss.size();
	for (int i = 0; i < gm; i++) {
		Gsets[i] = ss[i];
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x1, 0xb86f51(%rip)    # 0xba1e44
je 0x1af52
movq %rdi, %rbx
movb $0x1, 0xb86f45(%rip)    # 0xba1e44
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movl %eax, 0x62fc1c(%rip)    # 0x64ab30
xorl %r14d, %r14d
leaq 0x8db5a2(%rip), %r15    # 0x8f64c0
xorl %r12d, %r12d
cltq
cmpq %rax, %r12
jge 0x1af46
movq (%rbx), %rsi
addq %r14, %rsi
leaq (%r15,%r14), %rdi
callq 0x193e8
incq %r12
movl 0x62fbf0(%rip), %eax    # 0x64ab30
addq $0x18, %r14
jmp 0x1af21
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x722f(%rip), %rdi      # 0x22188
leaq 0x7231(%rip), %rsi      # 0x22191
leaq 0x7237(%rip), %rcx      # 0x2219e
pushq $0x32
popq %rdx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/setcover.cpp
// Function: SetCover::LPSolver::Pivot(int, int)
void Pivot(int r, int s) {
		ld inv = 1.0 / D[r][s];
		for (int i = 0; i < m + 2; i++) if (i != r)
			for (int j = 0; j < n + 2; j++) if (j != s)
				D[i][j] -= D[r][j] * D[i][s] * inv;
		for (int j = 0; j < n + 2; j++) if (j != s) D[r][j] *= inv;
		for (int i = 0; i < m + 2; i++) if (i != r) D[i][s] *= -inv;
		D[r][s] = inv;
		swap(B[r], N[s]);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq %esi, %rax
movq 0x58(%rdi), %rsi
imulq $0x18, %rax, %r8
movslq %edx, %rcx
movq (%rsi,%r8), %r9
movq %rcx, %rdx
shlq $0x4, %rdx
leaq (%r9,%rdx), %r8
movq %r8, -0x8(%rsp)
fldt (%r9,%rdx)
fld1
fdivp %st, %st(1)
movl 0x20(%rdi), %ebp
movl 0x24(%rdi), %r14d
addl $0x2, %r14d
movl %ecx, %r10d
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
movl %eax, %r11d
cmpl $-0x1, %ebp
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
cmovgel %ebp, %ebx
addl $0x2, %ebx
movq %r14, %r12
shlq $0x4, %r12
shlq $0x4, %r10
cmpq %rbx, %r15
je 0x1cc66
cmpq %r11, %r15
jne 0x1cc31
incq %r15
jmp 0x1cc22
imulq $0x18, %r15, %r13
addq %rsi, %r13
xorl %ebp, %ebp
cmpq %rbp, %r12
je 0x1cc2c
cmpq %rbp, %r10
je 0x1cc60
fldt (%r9,%rbp)
movq (%r13), %r8
fldt (%r8,%rdx)
fmulp %st, %st(1)
fldt (%r8,%rbp)
fxch %st(1)
fmul %st(2), %st
fsubrp %st, %st(1)
fstpt (%r8,%rbp)
addq $0x10, %rbp
jmp 0x1cc3a
movl %r14d, %r14d
shlq $0x4, %r14
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x1cc8a
cmpq %r15, %r10
je 0x1cc84
fldt (%r9,%r15)
fmul %st(1), %st
fstpt (%r9,%r15)
addq $0x10, %r15
jmp 0x1cc70
fld %st(0)
fchs
imulq $0x18, %rbx, %r9
imulq $0x18, %r11, %r10
xorl %r11d, %r11d
cmpq %r11, %r9
je 0x1ccb7
cmpq %r11, %r10
je 0x1ccb1
movq (%rsi,%r11), %r8
fldt (%r8,%rdx)
fmul %st(1), %st
fstpt (%r8,%rdx)
addq $0x18, %r11
jmp 0x1cc99
fstp %st(0)
movq -0x8(%rsp), %rdx
fstpt (%rdx)
movq 0x28(%rdi), %rdx
movq 0x40(%rdi), %rsi
movl (%rsi,%rax,4), %edi
movl (%rdx,%rcx,4), %r8d
movl %r8d, (%rsi,%rax,4)
movl %edi, (%rdx,%rcx,4)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/setcover.cpp
// Function: SetCover::LPSolver::Simplex(int)
bool Simplex(int phase) {
		int x = phase == 1 ? m + 1 : m;
		while (true) {
			int s = -1;
			for (int j = 0; j <= n; j++) {
				if (phase == 2 && N[j] == -1) continue;
				if (s==-1||D[x][j]<D[x][s]||(D[x][j]==D[x][s]&&N[j]<N[s])) s=j;
			}
			if (D[x][s] > -eps) return true;
			int r = -1;
			for (int i = 0; i < m; i++) {
				if (D[i][s] < eps) continue;
				if (r == -1 || D[i][n + 1] / D[i][s] < D[r][n + 1] / D[r][s] ||
					((D[i][n + 1]/D[i][s])==(D[r][n+1]/D[r][s])&&B[i]<B[r]))r=i;
			}
			if (r == -1) return false;
			Pivot(r, s);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %eax, %eax
cmpl $0x1, %esi
sete %al
movslq 0x20(%rdi), %rcx
addq %rcx, %rax
imulq $0x18, %rax, %r15
pushq $-0x1
popq %rbp
movslq 0x24(%r14), %rsi
movq 0x28(%r14), %rdi
movq 0x58(%r14), %rax
leaq (%rax,%r15), %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movl %ebp, %edx
movslq %edx, %rcx
cmpq %rsi, %r10
jg 0x1cd87
cmpl $0x2, %ebx
jne 0x1cd34
cmpl $-0x1, (%rdi,%r10,4)
je 0x1cd76
cmpl $-0x1, %edx
fldz
fldz
je 0x1cd6f
fstp %st(1)
fstp %st(0)
movq (%r8), %r11
fldt (%r11,%r9)
movq %rcx, %r13
shlq $0x4, %r13
fldt (%r11,%r13)
fucomi %st(1), %st
ja 0x1cd6f
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x1cd76
jp 0x1cd76
movl (%rdi,%r10,4), %r11d
cmpl (%rdi,%rcx,4), %r11d
fldz
fldz
jge 0x1cd7a
fstp %st(1)
fstp %st(0)
movl %r10d, %edx
fldz
fldz
fstp %st(1)
fstp %st(0)
incq %r10
addq $0x10, %r9
jmp 0x1cd20
movq (%r8), %rdi
shlq $0x4, %rcx
fldt (%rdi,%rcx)
fldt (%r14)
fld %st(0)
fchs
fxch %st(2)
fucomi %st(2), %st
ja 0x1ce59
movl 0x20(%r14), %edi
incl %esi
movslq %esi, %r8
movq 0x40(%r14), %r9
testl %edi, %edi
movl $0x0, %esi
cmovlel %esi, %edi
shlq $0x4, %r8
movq %rax, %r10
xorl %r11d, %r11d
movl %ebp, %esi
cmpq %r11, %rdi
je 0x1ce3b
movq (%r10), %r13
fldt (%r13,%rcx)
fxch %st(2)
fucomi %st(2), %st
jbe 0x1cddc
fstp %st(2)
jmp 0x1ce2a
cmpl $-0x1, %esi
fldz
fxch %st(1)
fxch %st(3)
fxch %st(1)
je 0x1ce23
fstp %st(0)
fldt (%r13,%r8)
fdivp %st, %st(1)
movslq %esi, %r13
imulq $0x18, %r13, %r12
movq (%rax,%r12), %r12
fldt (%r12,%r8)
fldt (%r12,%rcx)
fdivrp %st, %st(1)
fucomi %st(1), %st
ja 0x1ce23
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x1ce2a
jp 0x1ce2a
movl (%r9,%r11,4), %r12d
cmpl (%r9,%r13,4), %r12d
fldz
fldz
jge 0x1ce2e
fstp %st(1)
fstp %st(0)
movl %r11d, %esi
fldz
fldz
fstp %st(1)
fstp %st(0)
incq %r11
addq $0x18, %r10
jmp 0x1cdc5
fstp %st(1)
cmpl $-0x1, %esi
fldz
fxch %st(1)
je 0x1ce59
fstp %st(0)
fstp %st(1)
fstp %st(0)
movq %r14, %rdi
callq 0x1cbba
jmp 0x1cd08
fstp %st(1)
fucompi %st(1), %st
fstp %st(0)
seta %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/treewidth.cpp
// Function: TreeWidth::SolveAtom::greedyDegree2(Graph&)
vector<pair<int, int> > greedyDegree2(Graph& G) {
	queue<int> d2;
	for (int i = 0; i < G.n; i++) {
		assert(G.g[i].size() > 1);
		if (G.g[i].size() == 2) {
			d2.push(i);
		}
	}
	vector<pair<int, int> > sol;
	while (!d2.empty()) {
		int x = d2.front();
		d2.pop();
		if (G.g[x].size() != 2) continue;
		int n1 = G.g[x][0];
		int n2 = G.g[x][1];
		if (!G.hasEdge(n1, n2)) {
			sol.push_back({n1, n2});
			G.addEdge(n1, n2);
		}
	}
	return sol;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x141f4
xorl %eax, %eax
movq %rsp, %r12
movl %eax, (%rsp)
cmpl 0x50(%r14), %eax
jge 0x1eabb
movslq %eax, %rcx
movq 0x38(%r14), %rdx
imulq $0x18, %rcx, %rsi
movq 0x8(%rdx,%rsi), %rcx
subq (%rdx,%rsi), %rcx
cmpq $0x4, %rcx
jbe 0x1eb54
cmpq $0x8, %rcx
jne 0x1eab7
movq %r15, %rdi
movq %r12, %rsi
callq 0x148c6
movl (%rsp), %eax
incl %eax
jmp 0x1ea7c
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movq 0x18(%rsp), %rax
cmpq %rax, 0x38(%rsp)
je 0x1eb38
movslq (%rax), %r13
movq %r15, %rdi
callq 0x14afa
movq 0x38(%r14), %rcx
imulq $0x18, %r13, %rdx
movq (%rcx,%rdx), %rax
movq 0x8(%rcx,%rdx), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x1eace
movl (%rax), %ebp
movl 0x4(%rax), %r13d
movq %r14, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x7f98
testb %al, %al
jne 0x1eace
movl %ebp, (%rsp)
movl %r13d, 0x4(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x92ce
movq %r14, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x7a8e
jmp 0x1eace
leaq 0x8(%rsp), %rdi
callq 0x14210
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2928(%rip), %rdi      # 0x21483
leaq 0x37ee(%rip), %rsi      # 0x22350
leaq 0x3856(%rip), %rcx      # 0x223bf
pushq $0x35
popq %rdx
callq 0x2150
jmp 0x1eb78
movq %rax, %r14
jmp 0x1eb83
movq %rax, %r14
movq %rbx, %rdi
callq 0x3bfe
leaq 0x8(%rsp), %rdi
callq 0x14210
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/treewidth.cpp
// Function: TreeWidth::SolveAtom::nbClique(Graph&)
pair<int, int> nbClique(Graph& G) {
	for (int x = 0; x < G.n; x++) {
		assert(G.g[x].size() > 2);
		pair<int, int> fo = {-1, -1};
		bool fail = false;
		for (int i = 0; i < (int)G.g[x].size(); i++) {
			for (int ii = i+1; ii < (int)G.g[x].size(); ii++) {
				if (!G.hasEdge(G.g[x][i], G.g[x][ii])) {
					if (fo.F != -1) {
						fail = true;
						break;
					}
					else {
						fo = {G.g[x][i], G.g[x][ii]};
					}
				}
			}
			if (fail) break;
		}
		if (!fail) {
			assert(fo.F != -1);
			return fo;
		}
	}
	return {-1, -1};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
xorl %edx, %edx
movslq 0x50(%r14), %rax
cmpq %rax, %rdx
jge 0x1ec7d
movq 0x38(%r14), %rcx
movq %rdx, (%rsp)
imulq $0x18, %rdx, %r13
movq (%rcx,%r13), %rax
movq 0x8(%rcx,%r13), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x9, %rdx
jb 0x1ec8f
xorl %r15d, %r15d
pushq $0x1
popq %rbx
pushq $-0x1
popq %rdx
movl %edx, %ebp
movl %edx, %r12d
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x2, %rdx
movslq %edx, %rdx
cmpq %rdx, %r15
jge 0x1ec6d
leaq 0x1(%r15), %rdx
movq %rdx, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x2, %rdx
cmpl %edx, %ebx
jge 0x1ec52
movl (%rax,%r15,4), %esi
movl (%rax,%rbx,4), %edx
movq %r14, %rdi
callq 0x7f98
testb %al, %al
je 0x1ec33
movq 0x38(%r14), %rcx
movq (%rcx,%r13), %rax
jmp 0x1ec48
cmpl $-0x1, %ebp
jne 0x1ec61
movq 0x38(%r14), %rcx
movq (%rcx,%r13), %rax
movl (%rax,%r15,4), %ebp
movl (%rax,%rbx,4), %r12d
incq %rbx
movq 0x8(%rcx,%r13), %rcx
jmp 0x1ec08
movq 0x10(%rsp), %rbx
incq %rbx
movq 0x8(%rsp), %r15
jmp 0x1ebe8
movq (%rsp), %rdx
incq %rdx
jmp 0x1eba8
cmpl $-0x1, %ebp
je 0x1ecac
shlq $0x20, %r12
movl %ebp, %eax
orq %r12, %rax
jmp 0x1ec80
pushq $-0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x287d(%rip), %rdi      # 0x21513
leaq 0x36b3(%rip), %rsi      # 0x22350
leaq 0x375f(%rip), %rcx      # 0x22403
pushq $0x4a
popq %rdx
callq 0x2150
leaq 0x28b2(%rip), %rdi      # 0x21565
leaq 0x3696(%rip), %rsi      # 0x22350
leaq 0x3742(%rip), %rcx      # 0x22403
pushq $0x5c
jmp 0x1eca6
// File: /workspace/github_cpp_makefile_star2_O2/Jumperr-labs[P]at25sf081/AT25SF081.cpp
// Function: AT25SF081::AT25SF081()
AT25SF081::AT25SF081() :
        should_stop_(false),
        status_register1_(0),
        status_register2_(0) {
    int cs_pin_number = GetPinNumber("cs");
    int sck_pin_number = GetPinNumber("sck");
    int si_pin_number = GetPinNumber("si");
    int so_pin_number = GetPinNumber("so");
    wp_pin_number_ = GetPinNumber("wp");
    hold_pin_number_ = GetPinNumber("hold");

    SpiSlaveConfig spi_config = {
            .mosi_pin_number = si_pin_number,
            .miso_pin_number = so_pin_number,
            .ss_pin_number = cs_pin_number,
            .sclk_pin_number = sck_pin_number,
            .supported_spi_modes = SPI_MODE_0 | SPI_MODE_3,
            .max_frequency = MAX_FREQUENCY,
            .bit_order = MSB_FIRST
    };

    spi_slave_ = CreateSpiSlave(spi_config);
    MemReset();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r13
movq 0x57b8(%rip), %rax      # 0xaf98
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movl $0x100013, %edx         # imm = 0x100013
xorl %esi, %esi
callq 0x51a0
leaq 0x2835(%rip), %rsi      # 0x8033
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5570
leaq 0x10(%rsp), %rdi
callq 0x5150
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x5140
leaq 0x280c(%rip), %rsi      # 0x8036
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5570
leaq 0x10(%rsp), %rdi
callq 0x5150
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
callq 0x5140
leaq 0x27e4(%rip), %rsi      # 0x803a
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5570
leaq 0x10(%rsp), %rdi
callq 0x5150
movl %eax, %r15d
leaq 0x10(%rsp), %rdi
callq 0x5140
leaq 0x27ba(%rip), %rsi      # 0x803d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5570
leaq 0x10(%rsp), %rdi
callq 0x5150
movl %eax, %r12d
leaq 0x10(%rsp), %rdi
callq 0x5140
leaq 0x2790(%rip), %rsi      # 0x8040
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5570
leaq 0x10(%rsp), %rdi
callq 0x5150
movl %eax, 0x100010(%r13)
leaq 0x10(%rsp), %rdi
callq 0x5140
leaq 0x2762(%rip), %rsi      # 0x8043
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5570
movl %ebp, %r14d
leaq 0x10(%rsp), %rdi
callq 0x5150
leaq 0x10(%r13), %rcx
movq %rcx, 0x30(%rsp)
movl %eax, 0x100014(%r13)
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
callq 0x5140
movl %r15d, (%rbp)
movl %r12d, 0x4(%rbp)
movl %r14d, 0x8(%rbp)
movl %ebx, 0xc(%rbp)
movabsq $0x632ea0000000009, %rax # imm = 0x632EA0000000009
movq %rax, 0x10(%rbp)
andl $0x0, 0x18(%rbp)
leaq 0x10(%rsp), %rdi
callq 0x5500
movq %rax, 0x8(%r13)
movl $0x100000, %edx         # imm = 0x100000
movq 0x30(%rsp), %rdi
movl $0xff, %esi
callq 0x51a0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5980
jmp 0x598f
jmp 0x5980
jmp 0x598f
jmp 0x5980
jmp 0x598f
jmp 0x5980
jmp 0x598f
jmp 0x5980
jmp 0x598f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5140
jmp 0x5992
movq %rax, %rbx
movq %rbx, %rdi
callq 0x55c0
// File: /workspace/github_cpp_makefile_star2_O2/Jumperr-labs[P]at25sf081/AT25SF081.cpp
// Function: AT25SF081::ReadArray(bool)
void AT25SF081::ReadArray(bool with_dummy_byte) {
    int address = ReadAddress();
    if (address < 0) return;

    if (with_dummy_byte) {
        if (ReadDummyBytes(1) != 1 || !spi_slave_->IsSsActive()) return;
    }

    bool done = false;
    while (!done) {
        size_t length = spi_slave_->Transmit(nullptr, &memory_[address], MEMORY_SIZE - address);
        if (length == 0) {
            return;
        }
        address = (address + 1) % (int) MEMORY_SIZE;
        done = !spi_slave_->IsSsActive();
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
callq 0x5420
testl %eax, %eax
js 0x5c69
movl %eax, %ebp
testb %r14b, %r14b
je 0x5c2d
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x5260
cmpq $0x1, %rax
jne 0x5c69
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
je 0x5c69
leaq 0x10(%rbx), %r14
xorl %eax, %eax
testb $0x1, %al
jne 0x5c69
movq 0x8(%rbx), %rdi
movl %ebp, %edx
addq %r14, %rdx
movl $0x100000, %ecx         # imm = 0x100000
subl %ebp, %ecx
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
testq %rax, %rax
je 0x5c69
incl %ebp
andl $0xfffff, %ebp          # imm = 0xFFFFF
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
xorb $0x1, %al
jmp 0x5c33
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Jumperr-labs[P]at25sf081/AT25SF081.cpp
// Function: AT25SF081::ReadDeviceId()
void AT25SF081::ReadDeviceId() {
    static uint8_t response[2] = {MANUFACTURER_ID, DEVICE_CODE};
    int i = 0;
    ReadDummyBytes(3);
    while (spi_slave_->IsSsActive()) {
        spi_slave_->Transmit(nullptr, &response[i], 1);
        i = (i + 1) % 2;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x3
popq %rsi
callq 0x5260
xorl %r15d, %r15d
leaq 0x53de(%rip), %r12      # 0xb31b
pushq $0x1
popq %r14
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
je 0x5f6c
movq 0x8(%rbx), %rdi
movl %r15d, %edx
notl %r15d
addq %r12, %rdx
movq (%rdi), %rax
xorl %esi, %esi
movq %r14, %rcx
callq *(%rax)
andl $0x1, %r15d
jmp 0x5f41
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Jumperr-labs[P]at25sf081/AT25SF081.cpp
// Function: AT25SF081::ReadAddress()
int AT25SF081::ReadAddress() {
    uint8_t data[3];
    if (spi_slave_->Transmit(data, nullptr, 3) != 3 || !spi_slave_->IsSsActive()) {
        return -1;
    }

    return ((data[0] << 16) | (data[1] << 8) | data[2]) % (int) MEMORY_SIZE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
leaq 0x5(%rsp), %rsi
pushq $0x3
popq %rcx
xorl %edx, %edx
callq *(%rax)
pushq $-0x1
popq %rbx
cmpq $0x3, %rax
jne 0x5fcd
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
je 0x5fcd
movzbl 0x5(%rsp), %ebx
movzbl 0x6(%rsp), %eax
shll $0x8, %eax
movzbl 0x7(%rsp), %ecx
andl $0xf, %ebx
shll $0x10, %ebx
orl %eax, %ebx
orl %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop