LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movl %esi, 0x575683(%rip)    # 0x58c570
movslq %esi, %rax
leaq 0x4e2eb9(%rip), %rcx    # 0x4f9db0
movl $0x1, (%rcx,%rax,4)
movq 0x38(%rdi), %rax
movl $0x1, %edi
xorl %r8d, %r8d
leaq 0x57565f(%rip), %rsi    # 0x58c570
leaq 0x4b2158(%rip), %r9     # 0x4c9070
movslq (%rsi,%r8,4), %r10
leaq (%r10,%r10,2), %r11
movq (%rax,%r11,8), %r10
movq 0x8(%rax,%r11,8), %r11
cmpq %r11, %r10
je 0x16f5d
movl (%r10), %ebx
movslq %ebx, %r14
cmpl $0x0, (%rcx,%r14,4)
jne 0x16f57
cmpl $0x0, (%r9,%r14,4)
jne 0x16f57
cmpl %edx, %ebx
je 0x16f6c
movl $0x1, (%rcx,%r14,4)
movslq %edi, %r14
incl %edi
movl %ebx, (%rsi,%r14,4)
addq $0x4, %r10
jmp 0x16f29
incq %r8
movslq %edi, %r10
cmpq %r10, %r8
jl 0x16f18
xorl %eax, %eax
jmp 0x16f71
movl $0x1, %eax
testl %edi, %edi
jle 0x16f92
movl %edi, %edx
shlq $0x2, %rdx
xorl %edi, %edi
movslq (%rdi,%rsi), %r8
movl $0x0, (%rcx,%r8,4)
addq $0x4, %rdi
cmpq %rdi, %rdx
jne 0x16f7d
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b4a9
cmpl $0x2, %eax
je 0x1b49a
cmpl $0x1, %eax
jne 0x1b4c8
movq (%rdi), %rax
cmpq (%rsi), %rax
setl %al
jmp 0x1b4a7
fldt 0x10(%rdi)
fldt 0x10(%rsi)
fucompi %st(1), %st
fstp %st(0)
seta %al
popq %rcx
retq
leaq 0xf259(%rip), %rdi      # 0x2a709
leaq 0xf20f(%rip), %rsi      # 0x2a6c6
leaq 0xf25a(%rip), %rcx      # 0x2a718
movl $0x45, %edx
callq 0x2140
leaq 0xdca1(%rip), %rdi      # 0x29170
leaq 0xf1f0(%rip), %rsi      # 0x2a6c6
leaq 0xf23b(%rip), %rcx      # 0x2a718
movl $0x48, %edx
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b58b
cmpl $0x2, %eax
je 0x1b574
cmpl $0x1, %eax
jne 0x1b5aa
movq (%rdi), %rax
cmpq (%rsi), %rax
setle %al
jmp 0x1b589
fldt 0x10(%rsi)
faddl 0xe253(%rip)            # 0x297d0
fldt 0x10(%rdi)
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
seta %al
popq %rcx
retq
leaq 0xf177(%rip), %rdi      # 0x2a709
leaq 0xf12d(%rip), %rsi      # 0x2a6c6
leaq 0xf1dc(%rip), %rcx      # 0x2a77c
movl $0x51, %edx
callq 0x2140
leaq 0xdbbf(%rip), %rdi      # 0x29170
leaq 0xf10e(%rip), %rsi      # 0x2a6c6
leaq 0xf1bd(%rip), %rcx      # 0x2a77c
movl $0x54, %edx
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b678
cmpl $0x2, %eax
je 0x1b661
cmpl $0x1, %eax
jne 0x1b697
movq (%rdx), %rax
addq (%rsi), %rax
movl $0x1, 0x20(%rdi)
movq %rax, (%rdi)
jmp 0x1b673
fldt 0x10(%rsi)
fldt 0x10(%rdx)
faddp %st, %st(1)
movl $0x2, 0x20(%rdi)
fstpt 0x10(%rdi)
movq %rdi, %rax
popq %rcx
retq
leaq 0xf08a(%rip), %rdi      # 0x2a709
leaq 0xf040(%rip), %rsi      # 0x2a6c6
leaq 0xf155(%rip), %rcx      # 0x2a7e2
movl $0x5d, %edx
callq 0x2140
leaq 0xdad2(%rip), %rdi      # 0x29170
leaq 0xf021(%rip), %rsi      # 0x2a6c6
leaq 0xf136(%rip), %rcx      # 0x2a7e2
movl $0x60, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5d2948(%rip), %r14    # 0x5ee010
cmpl $0x0, (%r14,%rax,4)
jne 0x1b72f
movq %rdi, %rbx
movl $0x1, (%r14,%rax,4)
movq 0x38(%rdi), %rcx
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %r15
movq 0x8(%rcx,%rax,8), %r12
xorl %ebp, %ebp
cmpq %r12, %r15
je 0x1b724
movslq (%r15), %rsi
movl (%r14,%rsi,4), %eax
testl %eax, %eax
je 0x1b714
cmpl $0x2, %eax
jl 0x1b71e
movl 0x634388(%rip), %ecx    # 0x64fa90
cmpl %ecx, %eax
jge 0x1b71e
movl %ecx, (%r14,%rsi,4)
incl %ebp
jmp 0x1b71e
movq %rbx, %rdi
callq 0x1b6b6
addl %eax, %ebp
addq $0x4, %r15
jmp 0x1b6ed
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe6e8(%rip), %rdi      # 0x29e1e
leaq 0xef89(%rip), %rsi      # 0x2a6c6
leaq 0xf0d2(%rip), %rcx      # 0x2a816
movl $0x64, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x50(%rdi), %eax
testl %eax, %eax
jle 0x1b782
leaq 0x5d28a6(%rip), %rcx    # 0x5ee010
xorl %edx, %edx
movl $0x0, (%rcx)
incq %rdx
movslq 0x50(%r14), %rax
addq $0x4, %rcx
cmpq %rax, %rdx
jl 0x1b76c
movl $0x2, 0x634304(%rip)    # 0x64fa90
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
cmpq %rdx, %rcx
je 0x1b7bc
leaq 0x5d2871(%rip), %rax    # 0x5ee010
movslq (%rcx), %rsi
cmpl $0x0, (%rax,%rsi,4)
jne 0x1b818
movl $0x2, (%rax,%rsi,4)
addq $0x4, %rcx
cmpq %rdx, %rcx
jne 0x1b79f
movl 0x50(%r14), %eax
testl %eax, %eax
jle 0x1b806
leaq 0x5d2849(%rip), %r12    # 0x5ee010
xorl %r15d, %r15d
cmpl $0x0, (%r12)
jne 0x1b7f7
incl 0x6342b9(%rip)          # 0x64fa90
movq %r14, %rdi
movl %r15d, %esi
callq 0x1b6b6
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
shrq $0x2, %rcx
cmpl %ecx, %eax
jg 0x1b837
je 0x1b814
movl 0x50(%r14), %eax
incq %r15
movslq %eax, %rcx
addq $0x4, %r12
cmpq %rcx, %r15
jl 0x1b7ca
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movb $0x1, %al
jmp 0x1b808
leaq 0xe5ff(%rip), %rdi      # 0x29e1e
leaq 0xeea0(%rip), %rsi      # 0x2a6c6
leaq 0xf00b(%rip), %rcx      # 0x2a838
movl $0x77, %edx
callq 0x2140
leaq 0xf039(%rip), %rdi      # 0x2a877
leaq 0xee81(%rip), %rsi      # 0x2a6c6
leaq 0xefec(%rip), %rcx      # 0x2a838
movl $0x7e, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5d27a8(%rip), %r14    # 0x5ee010
cmpl $0x0, (%r14,%rax,4)
jne 0x1b8c4
movq %rdi, %rbx
movl $0x1, (%r14,%rax,4)
movq 0x38(%rdi), %rcx
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %r15
movq 0x8(%rcx,%rax,8), %r12
cmpq %r12, %r15
je 0x1b8b8
movslq (%r15), %rsi
movl (%r14,%rsi,4), %eax
cmpl $0x2, %eax
je 0x1b8aa
testl %eax, %eax
jne 0x1b8b2
movq %rbx, %rdi
callq 0x1b856
jmp 0x1b8b2
movl $0x3, (%r14,%rsi,4)
addq $0x4, %r15
jmp 0x1b88b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xe553(%rip), %rdi      # 0x29e1e
leaq 0xedf4(%rip), %rsi      # 0x2a6c6
leaq 0xefb9(%rip), %rcx      # 0x2a892
movl $0x88, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movl 0x50(%rdi), %eax
cmpl %edx, %eax
jle 0x1b979
movq %rsi, %rbx
testl %eax, %eax
jle 0x1b915
leaq 0x5d2713(%rip), %rax    # 0x5ee010
xorl %ecx, %ecx
movl $0x0, (%rax)
incq %rcx
movslq 0x50(%rdi), %rsi
addq $0x4, %rax
cmpq %rsi, %rcx
jl 0x1b8ff
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x1b93c
leaq 0x5d26e8(%rip), %rsi    # 0x5ee010
movslq (%rax), %r8
movl $0x2, (%rsi,%r8,4)
addq $0x4, %rax
cmpq %rcx, %rax
jne 0x1b928
movl %edx, %esi
callq 0x1b856
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
cmpq %rcx, %rdx
je 0x1b975
addq $0x4, %rdx
leaq 0x5d26b6(%rip), %rsi    # 0x5ee010
movslq -0x4(%rdx), %rax
cmpl $0x3, (%rsi,%rax,4)
sete %al
jne 0x1b977
leaq 0x4(%rdx), %rdi
cmpq %rcx, %rdx
movq %rdi, %rdx
jne 0x1b95a
jmp 0x1b977
movb $0x1, %al
popq %rbx
retq
leaq 0xef35(%rip), %rdi      # 0x2a8b5
leaq 0xed3f(%rip), %rsi      # 0x2a6c6
leaq 0xef2f(%rip), %rcx      # 0x2a8bd
movl $0x93, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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
cmpq %rcx, %rax
je 0x1b9d4
movl 0x50(%r14), %edx
movl (%rax), %esi
testl %esi, %esi
js 0x1ba9c
cmpl %edx, %esi
jge 0x1ba9c
addq $0x4, %rax
cmpq %rcx, %rax
jne 0x1b9b9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b74e
testb %al, %al
je 0x1b9f4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %r8
movq 0x8(%rbx), %r12
movb $0x1, %al
cmpq %r12, %r8
je 0x1b9e5
leaq 0x5d2607(%rip), %r13    # 0x5ee010
movq %r12, %rcx
movq %r8, %rbp
movl (%rbp), %r15d
cmpl $0x0, 0x50(%r14)
jle 0x1ba4c
movq %r13, %rdx
xorl %esi, %esi
movl $0x0, (%rdx)
incq %rsi
movslq 0x50(%r14), %rdi
addq $0x4, %rdx
cmpq %rdi, %rsi
jl 0x1ba1f
jmp 0x1ba4c
movslq (%r8), %rdx
cmpl %r15d, %edx
je 0x1ba48
movl $0x2, (%r13,%rdx,4)
addq $0x4, %r8
cmpq %rcx, %r8
jne 0x1ba37
movq %r14, %rdi
movl %r15d, %esi
callq 0x1b856
movq (%rbx), %r8
movq 0x8(%rbx), %rcx
movq %r8, %rdx
cmpq %rcx, %r8
je 0x1ba88
movslq (%rdx), %rsi
cmpl %r15d, %esi
je 0x1ba7f
cmpl $0x3, (%r13,%rsi,4)
jne 0x1b9e3
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0x1ba6b
addq $0x4, %rbp
cmpq %r12, %rbp
jne 0x1ba0f
movb $0x1, %al
jmp 0x1b9e5
leaq 0xee55(%rip), %rdi      # 0x2a8f8
leaq 0xec1c(%rip), %rsi      # 0x2a6c6
leaq 0xee59(%rip), %rcx      # 0x2a90a
movl $0xa3, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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, %rcx
leaq 0x5d253c(%rip), %r12    # 0x5ee010
cmpl $0x0, (%r12,%rcx,4)
jne 0x1bb77
movq %rdx, %rbx
movq %rdi, %r14
movl $0x1, (%r12,%rcx,4)
movq 0x8(%rdx), %rax
cmpq 0x10(%rdx), %rax
je 0x1bb03
movl %esi, (%rax)
addq $0x4, %rax
movq %rax, 0x8(%rbx)
jmp 0x1bb19
leaq 0x4(%rsp), %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x92c4
movslq (%r15), %rcx
movq 0x38(%r14), %rax
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %r15
movq 0x8(%rax,%rcx,8), %r13
xorl %ebp, %ebp
cmpq %r13, %r15
je 0x1bb66
movslq (%r15), %rsi
movl (%r12,%rsi,4), %eax
testl %eax, %eax
je 0x1bb53
cmpl $0x2, %eax
jl 0x1bb60
movl 0x633f49(%rip), %ecx    # 0x64fa90
cmpl %ecx, %eax
jge 0x1bb60
movl %ecx, (%r12,%rsi,4)
incl %ebp
jmp 0x1bb60
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1babb
addl %eax, %ebp
addq $0x4, %r15
jmp 0x1bb2c
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe2a0(%rip), %rdi      # 0x29e1e
leaq 0xeb41(%rip), %rsi      # 0x2a6c6
leaq 0xedb7(%rip), %rcx      # 0x2a943
movl $0xb9, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movl 0x50(%rsi), %eax
testl %eax, %eax
jle 0x1bbd5
leaq 0x5d2453(%rip), %rcx    # 0x5ee010
xorl %edx, %edx
movl $0x0, (%rcx)
incq %rdx
movslq 0x50(%r15), %rax
addq $0x4, %rcx
cmpq %rax, %rdx
jl 0x1bbbf
movl $0x2, 0x633eb1(%rip)    # 0x64fa90
movq (%r14), %rcx
movq 0x8(%r14), %rdx
cmpq %rdx, %rcx
je 0x1bc13
leaq 0x5d241e(%rip), %rax    # 0x5ee010
movslq (%rcx), %rsi
cmpl $0x0, (%rax,%rsi,4)
jne 0x1bd0c
movl $0x2, (%rax,%rsi,4)
addq $0x4, %rcx
cmpq %rdx, %rcx
jne 0x1bbf2
movl 0x50(%r15), %eax
xorps %xmm0, %xmm0
movq 0x8(%rsp), %rcx
movups %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
testl %eax, %eax
jle 0x1bcf8
leaq 0x5d23db(%rip), %r13    # 0x5ee010
xorl %r12d, %r12d
cmpl $0x0, (%r13)
jne 0x1bce5
incl 0x633e47(%rip)          # 0x64fa90
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq %r15, %rdi
movl %r12d, %esi
leaq 0x10(%rsp), %rdx
callq 0x1babb
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x2, %rcx
cmpl %ecx, %eax
jg 0x1bd2b
jne 0x1bcca
movq 0x10(%rsp), %rbp
movq 0x18(%rsp), %rbx
cmpq %rbx, %rbp
je 0x1bcbb
movq %rbx, %rax
subq %rbp, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xaf7f
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xb062
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xaaa4
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bce1
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2210
movl 0x50(%r15), %eax
incq %r12
movslq %eax, %rcx
addq $0x4, %r13
cmpq %rcx, %r12
jl 0x1bc38
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe10b(%rip), %rdi      # 0x29e1e
leaq 0xe9ac(%rip), %rsi      # 0x2a6c6
leaq 0xec53(%rip), %rcx      # 0x2a974
movl $0xcc, %edx
callq 0x2140
leaq 0xeb45(%rip), %rdi      # 0x2a877
leaq 0xe98d(%rip), %rsi      # 0x2a6c6
leaq 0xec34(%rip), %rcx      # 0x2a974
movl $0xd5, %edx
callq 0x2140
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bd64
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2210
movq 0x8(%rsp), %rdi
callq 0x41aa
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movl 0x50(%rsi), %eax
testl %eax, %eax
jle 0x1bdb5
leaq 0x5d2273(%rip), %rcx    # 0x5ee010
xorl %edx, %edx
movl $0x0, (%rcx)
incq %rdx
movslq 0x50(%r15), %rax
addq $0x4, %rcx
cmpq %rax, %rdx
jl 0x1bd9f
movl $0x2, 0x633cd1(%rip)    # 0x64fa90
movq (%r14), %rcx
movq 0x8(%r14), %rdx
cmpq %rdx, %rcx
je 0x1bdf3
leaq 0x5d223e(%rip), %rax    # 0x5ee010
movslq (%rcx), %rsi
cmpl $0x0, (%rax,%rsi,4)
jne 0x1beea
movl $0x2, (%rax,%rsi,4)
addq $0x4, %rcx
cmpq %rdx, %rcx
jne 0x1bdd2
movl 0x50(%r15), %eax
xorps %xmm0, %xmm0
movq 0x8(%rsp), %rcx
movups %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
testl %eax, %eax
jle 0x1bed6
leaq 0x5d21fb(%rip), %r13    # 0x5ee010
xorl %r12d, %r12d
cmpl $0x0, (%r13)
jne 0x1bec3
incl 0x633c67(%rip)          # 0x64fa90
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq %r15, %rdi
movl %r12d, %esi
leaq 0x10(%rsp), %rdx
callq 0x1babb
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x2, %rcx
cmpl %ecx, %eax
jg 0x1bf09
movq 0x10(%rsp), %rbp
movq 0x18(%rsp), %rbx
cmpq %rbx, %rbp
je 0x1be99
movq %rbx, %rax
subq %rbp, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xaf7f
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xb062
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xaaa4
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bebf
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2210
movl 0x50(%r15), %eax
incq %r12
movslq %eax, %rcx
addq $0x4, %r13
cmpq %rcx, %r12
jl 0x1be18
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdf2d(%rip), %rdi      # 0x29e1e
leaq 0xe7ce(%rip), %rsi      # 0x2a6c6
leaq 0xeac4(%rip), %rcx      # 0x2a9c3
movl $0xe4, %edx
callq 0x2140
leaq 0xe967(%rip), %rdi      # 0x2a877
leaq 0xe7af(%rip), %rsi      # 0x2a6c6
leaq 0xeaa5(%rip), %rcx      # 0x2a9c3
movl $0xed, %edx
callq 0x2140
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bf42
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2210
movq 0x8(%rsp), %rdi
callq 0x41aa
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
decl %esi
cmpl $0x5, %esi
ja 0x1bfd0
movq %rdi, %rbx
leaq 0x50(%rsp), %r15
leaq 0x20(%rsp), %r14
leaq 0xe718(%rip), %rax      # 0x2a68c
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b47c
testb %al, %al
cmovneq %r15, %r14
movaps (%r14), %xmm0
movaps 0x10(%r14), %xmm1
movaps 0x20(%r14), %xmm2
movaps %xmm0, (%rbx)
movaps %xmm1, 0x10(%rbx)
movaps %xmm2, 0x20(%rbx)
jmp 0x1bfc7
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1b63c
jmp 0x1bfc7
movl $0x1, 0x20(%rbx)
movq $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xd199(%rip), %rdi      # 0x29170
leaq 0xe6e8(%rip), %rsi      # 0x2a6c6
leaq 0xea29(%rip), %rcx      # 0x2aa0e
movl $0xfc, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5d0fda(%rip), %r12    # 0x5ee010
cmpl $0x0, (%r12,%rax,4)
jne 0x1d0d5
movq %rdi, %r14
movl $0x1, (%r12,%rax,4)
movq 0x38(%rdi), %rcx
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %r13
movq 0x8(%rcx,%rax,8), %rbp
cmpq %rbp, %r13
je 0x1d0c6
movq %rdx, %rbx
leaq 0x4(%rsp), %r15
movslq (%r13), %rsi
movl %esi, 0x4(%rsp)
movl (%r12,%rsi,4), %eax
cmpl $0x2, %eax
je 0x1d08c
testl %eax, %eax
jne 0x1d0bd
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d021
jmp 0x1d0bd
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x1d0a2
movl %esi, (%rax)
addq $0x4, %rax
movq %rax, 0x8(%rbx)
jmp 0x1d0b0
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x92c4
movslq 0x4(%rsp), %rax
movl $0x3, (%r12,%rax,4)
addq $0x4, %r13
cmpq %rbp, %r13
jne 0x1d06a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcd42(%rip), %rdi      # 0x29e1e
leaq 0xd5e3(%rip), %rsi      # 0x2a6c6
leaq 0xdb18(%rip), %rcx      # 0x2ac02
movl $0x18b, %edx            # imm = 0x18B
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d853
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)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1d876
movl %edi, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1d88a
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x92c4
movslq (%r12), %rax
movq 0x38(%r15), %rcx
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %r12
movq 0x8(%rcx,%rax,8), %r13
cmpq %r13, %r12
je 0x1d845
movl (%r12), %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1d825
addq $0x4, %r12
jmp 0x1d89b
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaa18
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
xorl %edi, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1d825
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1d912
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2210
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1d936
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2210
leaq 0x8(%rsp), %rdi
callq 0x2643
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movl %esi, 0x4(%rsp)
movslq %esi, %rcx
leaq 0x600bcc(%rip), %r12    # 0x61ed50
cmpl $0x0, (%r12,%rcx,4)
jne 0x1e23c
movq %rdx, %rbx
leaq 0x5cfe77(%rip), %rdx    # 0x5ee010
cmpl $0x3, (%rdx,%rcx,4)
je 0x1e25b
movq %rdi, %r14
movl $0x1, (%r12,%rcx,4)
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x1e1c4
movl %esi, (%rax)
addq $0x4, %rax
movq %rax, 0x8(%rbx)
jmp 0x1e1e1
leaq 0x4(%rsp), %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x92c4
leaq 0x5cfe32(%rip), %rdx    # 0x5ee010
movslq (%r15), %rcx
xorl %ebp, %ebp
cmpl $0x2, (%rdx,%rcx,4)
sete %bpl
movq 0x38(%r14), %rax
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %r15
movq 0x8(%rax,%rcx,8), %r13
cmpq %r13, %r15
je 0x1e22b
movslq (%r15), %rsi
cmpl $0x0, (%r12,%rsi,4)
jne 0x1e225
cmpl $0x3, (%rdx,%rsi,4)
je 0x1e225
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1e16b
leaq 0x5cfded(%rip), %rdx    # 0x5ee010
addl %eax, %ebp
addq $0x4, %r15
jmp 0x1e1fc
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcaec(%rip), %rdi      # 0x2ad2f
leaq 0xc47c(%rip), %rsi      # 0x2a6c6
leaq 0xcae9(%rip), %rcx      # 0x2ad3a
movl $0x220, %edx            # imm = 0x220
callq 0x2140
leaq 0xcb09(%rip), %rdi      # 0x2ad6b
leaq 0xc45d(%rip), %rsi      # 0x2a6c6
leaq 0xcaca(%rip), %rcx      # 0x2ad3a
movl $0x221, %edx            # imm = 0x221
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rcx, %rbx
movl %esi, 0x4(%rsp)
movslq %esi, %rcx
leaq 0x5cfd7a(%rip), %r13    # 0x5ee010
cmpl $0x0, (%r13,%rcx,4)
jne 0x1e370
movq %rdx, %r14
movq %rdi, %r15
movl $0x1, (%r13,%rcx,4)
movq 0x8(%rdx), %rax
cmpq 0x10(%rdx), %rax
je 0x1e2c7
movl %esi, (%rax)
addq $0x4, %rax
movq %rax, 0x8(%r14)
jmp 0x1e2de
leaq 0x4(%rsp), %r12
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x92c4
movslq (%r12), %rcx
movq 0x38(%r15), %rax
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %rbp
movq 0x8(%rax,%rcx,8), %r12
cmpq %r12, %rbp
je 0x1e361
movslq (%rbp), %rsi
movl %esi, (%rsp)
movl (%r13,%rsi,4), %eax
testl %eax, %eax
jne 0x1e31b
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1e27a
movslq (%rsp), %rsi
movl (%r13,%rsi,4), %eax
cmpl $0x2, %eax
jl 0x1e35b
cmpl 0x63176a(%rip), %eax    # 0x64fa90
jge 0x1e35b
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x1e33e
movl %esi, (%rax)
addq $0x4, %rax
movq %rax, 0x8(%rbx)
jmp 0x1e34c
movq %rbx, %rdi
movq %rax, %rsi
movq %rsp, %rdx
callq 0x92c4
movl 0x63173e(%rip), %eax    # 0x64fa90
movslq (%rsp), %rcx
movl %eax, (%r13,%rcx,4)
addq $0x4, %rbp
jmp 0x1e2ef
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbaa7(%rip), %rdi      # 0x29e1e
leaq 0xc348(%rip), %rsi      # 0x2a6c6
leaq 0xc9f0(%rip), %rcx      # 0x2ad75
movl $0x22f, %edx            # imm = 0x22F
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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, 0xb84339(%rip)    # 0xba6e34
je 0x22b5d
movq %rdi, %rbx
movb $0x1, 0xb8432d(%rip)    # 0xba6e34
movq 0x8(%rdi), %rax
subq (%rdi), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
movl %eax, 0x62d002(%rip)    # 0x64fb20
testl %eax, %eax
jle 0x22b51
xorl %r14d, %r14d
leaq 0x8d8984(%rip), %r15    # 0x8fb4b0
xorl %r12d, %r12d
movq (%rbx), %rsi
addq %r14, %rsi
leaq (%r15,%r14), %rdi
callq 0x212f0
incq %r12
movslq 0x62cfd8(%rip), %rax    # 0x64fb20
addq $0x18, %r14
cmpq %rax, %r12
jl 0x22b2f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8624(%rip), %rdi      # 0x2b188
leaq 0x8626(%rip), %rsi      # 0x2b191
leaq 0x862c(%rip), %rcx      # 0x2b19e
movl $0x32, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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, %rcx
movq 0x58(%rdi), %rsi
leaq (%rcx,%rcx,2), %rax
movslq %edx, %r9
movq (%rsi,%rax,8), %rdx
movq %r9, %r8
shlq $0x4, %r8
fldt (%rdx,%r8)
fld1
fdivp %st, %st(1)
movl 0x20(%rdi), %r11d
movl 0x24(%rdi), %ebx
leal 0x2(%r11), %eax
movl %eax, -0x14(%rsp)
movq %r9, -0x10(%rsp)
movl %r9d, %r14d
movq %rcx, -0x8(%rsp)
movl %ecx, %r10d
cmpl $-0x1, %r11d
jl 0x24f51
leal 0x2(%rbx), %r15d
movl -0x14(%rsp), %eax
cmpl $0x2, %eax
movl $0x1, %r12d
cmovgel %eax, %r12d
movq %r14, %r13
shlq $0x4, %r13
shlq $0x4, %r15
xorl %ebp, %ebp
cmpl $-0x1, %ebx
setl %al
cmpq %r10, %rbp
sete %r9b
orb %al, %r9b
jne 0x24f49
leaq (,%rbp,2), %rax
addq %rbp, %rax
leaq (%rsi,%rax,8), %r9
xorl %eax, %eax
cmpq %rax, %r13
je 0x24f40
fldt (%rdx,%rax)
movq (%r9), %rcx
fldt (%rcx,%r8)
fmulp %st, %st(1)
fldt (%rcx,%rax)
fxch %st(1)
fmul %st(2), %st
fsubrp %st, %st(1)
fstpt (%rcx,%rax)
addq $0x10, %rax
cmpq %rax, %r15
jne 0x24f23
incq %rbp
cmpq %r12, %rbp
jne 0x24f00
cmpl $-0x1, %ebx
jl 0x24f79
addl $0x2, %ebx
shlq $0x4, %r14
shlq $0x4, %rbx
xorl %eax, %eax
cmpq %rax, %r14
je 0x24f70
fldt (%rdx,%rax)
fmul %st(1), %st
fstpt (%rdx,%rax)
addq $0x10, %rax
cmpq %rax, %rbx
jne 0x24f63
addq %r8, %rdx
cmpl $-0x1, %r11d
fldz
jl 0x24fc7
fstp %st(0)
fld %st(0)
fchs
movl -0x14(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
shlq $0x3, %r10
leaq (%r10,%r10,2), %r9
shlq $0x3, %rax
leaq (%rax,%rax,2), %r10
xorl %eax, %eax
cmpq %rax, %r9
je 0x24fbe
movq (%rsi,%rax), %rcx
fldt (%rcx,%r8)
fmul %st(1), %st
fstpt (%rcx,%r8)
addq $0x18, %rax
cmpq %rax, %r10
jne 0x24fab
fstp %st(0)
fstpt (%rdx)
movq 0x28(%rdi), %rax
movq 0x40(%rdi), %rcx
movq -0x8(%rsp), %rdi
movl (%rcx,%rdi,4), %edx
movq -0x10(%rsp), %r8
movl (%rax,%r8,4), %esi
movl %esi, (%rcx,%rdi,4)
movl %edx, (%rax,%r8,4)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq (%rax,%rax,2), %r15
movl 0x24(%r14), %ecx
movq 0x58(%r14), %rax
testl %ecx, %ecx
js 0x250ab
movq 0x28(%r14), %rsi
leaq (%rax,%r15,8), %rdi
leaq 0x4(,%rcx,4), %r8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpl $0x2, %ebx
jne 0x25050
cmpl $-0x1, (%rsi,%r9)
je 0x25095
cmpl $-0x1, %edx
fldz
fldz
je 0x2508e
fstp %st(1)
fstp %st(0)
movq (%rdi), %r12
fldt (%r12,%r9,4)
movslq %edx, %r11
movq %r11, %r13
shlq $0x4, %r13
fldt (%r12,%r13)
fucomi %st(1), %st
ja 0x2508e
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x25095
jp 0x25095
movl (%rsi,%r9), %ebp
cmpl (%rsi,%r11,4), %ebp
fldz
fldz
jge 0x25099
fstp %st(1)
fstp %st(0)
movl %r10d, %edx
fldz
fldz
fstp %st(1)
fstp %st(0)
incl %r10d
addq $0x4, %r9
cmpq %r9, %r8
jne 0x25044
jmp 0x250b0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movslq %edx, %rdi
movq (%rax,%r15,8), %rsi
shlq $0x4, %rdi
fldt (%rsi,%rdi)
fldt (%r14)
fld %st(0)
fchs
fxch %st(2)
fucomi %st(2), %st
ja 0x25186
movslq 0x20(%r14), %r8
testq %r8, %r8
jle 0x25186
incl %ecx
movslq %ecx, %rcx
movq 0x40(%r14), %r9
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
shlq $0x4, %rcx
movq %rax, %r10
xorl %r11d, %r11d
movq (%r10), %r12
fldt (%r12,%rdi)
fxch %st(2)
fucomi %st(2), %st
jbe 0x25105
fstp %st(2)
jmp 0x25154
cmpl $-0x1, %esi
fldz
fxch %st(1)
fxch %st(3)
fxch %st(1)
je 0x2514d
fstp %st(0)
fldt (%r12,%rcx)
fdivp %st, %st(1)
movslq %esi, %r12
leaq (%r12,%r12,2), %r13
movq (%rax,%r13,8), %r13
fldt (%r13,%rcx)
fldt (%r13,%rdi)
fdivrp %st, %st(1)
fucomi %st(1), %st
ja 0x2514d
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x25154
jp 0x25154
movl (%r9,%r11,4), %ebp
cmpl (%r9,%r12,4), %ebp
fldz
fldz
jge 0x25158
fstp %st(1)
fstp %st(0)
movl %r11d, %esi
fldz
fldz
fstp %st(1)
fstp %st(0)
incq %r11
addq $0x18, %r10
cmpq %r11, %r8
jne 0x250f4
fstp %st(1)
cmpl $-0x1, %esi
fldz
fxch %st(1)
je 0x25186
fstp %st(0)
fstp %st(1)
fstp %st(0)
movq %r14, %rdi
callq 0x24e8e
jmp 0x25019
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
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x1b03c
movl $0x0, 0x8(%rsp)
cmpl $0x0, 0x50(%r14)
jle 0x26f28
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movslq %r13d, %rax
movq 0x38(%r14), %rcx
leaq (%rax,%rax,2), %rdx
movq 0x8(%rcx,%rdx,8), %rax
subq (%rcx,%rdx,8), %rax
cmpq $0x4, %rax
jbe 0x27017
cmpq $0x8, %rax
jne 0x26f15
movq 0x40(%rsp), %rax
movq 0x50(%rsp), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x26f0a
movl %r13d, (%rax)
addq $0x4, %rax
movq %rax, 0x40(%rsp)
jmp 0x26f15
movq %r15, %rdi
movq %r12, %rsi
callq 0x1b1b2
movl 0x8(%rsp), %r13d
incl %r13d
movl %r13d, 0x8(%rsp)
cmpl 0x50(%r14), %r13d
jl 0x26ec5
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x20(%rsp), %rax
cmpq %rax, 0x40(%rsp)
je 0x26ffb
leaq 0x8(%rsp), %r15
movslq (%rax), %r12
movq 0x30(%rsp), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x26f62
addq $0x4, %rax
jmp 0x26f94
movq 0x28(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x2210
movq 0x38(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x20(%rsp)
movq 0x38(%r14), %rcx
leaq (%r12,%r12,2), %rdx
movq (%rcx,%rdx,8), %rax
movq 0x8(%rcx,%rdx,8), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x26feb
movl (%rax), %ebp
movl 0x4(%rax), %r12d
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x9ea6
testb %al, %al
jne 0x26feb
movl %ebp, 0x8(%rsp)
movl %r12d, 0xc(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb2ae
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x9836
movq 0x20(%rsp), %rax
cmpq %rax, 0x40(%rsp)
jne 0x26f4b
leaq 0x10(%rsp), %rdi
callq 0x1abca
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3465(%rip), %rdi      # 0x2a483
leaq 0x432b(%rip), %rsi      # 0x2b350
leaq 0x4393(%rip), %rcx      # 0x2b3bf
movl $0x35, %edx
callq 0x2140
movq %rax, %r14
jmp 0x27054
jmp 0x2703d
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x27054
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2210
leaq 0x10(%rsp), %rdi
callq 0x1abca
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/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 $-0x1, %rax
cmpl $0x0, 0x50(%rdi)
jle 0x2717f
movq %rdi, %r14
xorl %esi, %esi
movq 0x38(%r14), %rcx
leaq (%rsi,%rsi,2), %r12
movq (%rcx,%r12,8), %rax
movq 0x8(%rcx,%r12,8), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x9, %rdx
jb 0x271ad
movq %rsi, 0x8(%rsp)
shrq $0x2, %rdx
testl %edx, %edx
jle 0x2718e
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rdx, (%rsp)
movl $0x1, %r13d
xorl %esi, %esi
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %rsi, %r15
incq %rsi
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x2, %rdx
movslq %edx, %rdx
cmpq %rdx, %rsi
jge 0x27145
movq %rsi, 0x10(%rsp)
movq %r13, %rbp
movl (%rax,%r15,4), %esi
movl (%rax,%rbp,4), %edx
movq %r14, %rdi
callq 0x9ea6
testb %al, %al
je 0x2710f
movq 0x38(%r14), %rcx
movq (%rcx,%r12,8), %rax
jmp 0x27127
cmpl $-0x1, %ebx
jne 0x2714f
movq 0x38(%r14), %rcx
movq (%rcx,%r12,8), %rax
movl (%rax,%r15,4), %ebx
movl (%rax,%rbp,4), %edx
movq %rdx, (%rsp)
incq %rbp
movq 0x8(%rcx,%r12,8), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x2, %rdx
cmpl %edx, %ebp
jl 0x270f2
movslq %edx, %rdx
movq 0x10(%rsp), %rsi
incq %r13
cmpq %rdx, %rsi
jl 0x270d2
jmp 0x2716d
movq 0x8(%rsp), %rsi
incq %rsi
movslq 0x50(%r14), %rax
cmpq %rax, %rsi
jl 0x2708a
movq $-0x1, %rax
jmp 0x2717f
cmpl $-0x1, %ebx
je 0x2718e
movq (%rsp), %rcx
shlq $0x20, %rcx
movl %ebx, %eax
orq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x33d0(%rip), %rdi      # 0x2a565
leaq 0x41b4(%rip), %rsi      # 0x2b350
leaq 0x4260(%rip), %rcx      # 0x2b403
movl $0x5c, %edx
callq 0x2140
leaq 0x335f(%rip), %rdi      # 0x2a513
leaq 0x4195(%rip), %rsi      # 0x2b350
leaq 0x4241(%rip), %rcx      # 0x2b403
movl $0x4a, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x42f0
testl %eax, %eax
js 0x4ba3
movl %eax, %ebp
testb %r14b, %r14b
je 0x4b6d
movq %rsp, %r14
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %rsp, %rsi
movl $0x1, %ecx
xorl %edx, %edx
callq *(%rax)
movq %r14, %rsp
cmpq $0x1, %rax
jne 0x4ba3
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
je 0x4ba3
leaq 0x10(%rbx), %r14
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 0x4ba3
incl %ebp
andl $0xfffff, %ebp          # imm = 0xFFFFF
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
jne 0x4b71
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %r15
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
xorl %r14d, %r14d
movq %rsp, %rsi
movl $0x3, %ecx
xorl %edx, %edx
callq *(%rax)
movq %r15, %rsp
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
je 0x4f0a
leaq 0x535c(%rip), %r15      # 0xa23b
movq 0x8(%rbx), %rdi
movl %r14d, %edx
notl %r14d
addq %r15, %rdx
movq (%rdi), %rax
movl $0x1, %ecx
xorl %esi, %esi
callq *(%rax)
andl $0x1, %r14d
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
jne 0x4edf
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x3, %ecx
xorl %edx, %edx
callq *(%rax)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq $0x3, %rax
jne 0x4f6d
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
je 0x4f6d
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
// File: /workspace/github_cpp_makefile_star2_O3/Jumperr-labs[P]at25sf081/modeling-framework/src/ModelingFramework.cpp
// Function: AddTimedCallback(unsigned long, std::function<void ()> const&, bool)
int AddTimedCallback(uint64_t ns, const callback_t &callback, bool run_once) {
    assert(jemu_interface_);
    int id = jemu_interface_->AddTimedCallback(ns, &TimedCallback, run_once);
    timers_callbacks_map_[id] = callback;
    return id;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rsi
movq 0x49e6(%rip), %rax      # 0x9f88
movq (%rax), %rdi
testq %rdi, %rdi
je 0x55e7
movq (%rdi), %rax
movzbl %dl, %ecx
movq 0x49f1(%rip), %rdx      # 0x9fa8
callq *0x20(%rax)
leaq 0x4(%rsp), %r14
movl %eax, (%r14)
movq 0x4a0f(%rip), %rdi      # 0x9fd8
movq %r14, %rsi
callq 0x4160
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4050
movl (%r14), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1c8b(%rip), %rdi      # 0x7279
leaq 0x1c94(%rip), %rsi      # 0x7289
leaq 0x1f02(%rip), %rcx      # 0x74fe
movl $0x55, %edx
callq 0x4170
// File: /workspace/github_cpp_makefile_star2_O3/Jumperr-labs[P]at25sf081/modeling-framework/src/ModelingFramework.cpp
// Function: SetMultiplePinsLevel(std::vector<WireChange, std::allocator<WireChange>> const&)
void SetMultiplePinsLevel(const pin_level_changes_t& pin_changes) {
    assert(jemu_interface_);

    if (pin_changes.empty()) 
        return;

    std::unique_ptr<WireChange> arr(new WireChange[pin_changes.size()]);
    std::copy(pin_changes.begin(),pin_changes.end(), arr.get() );
    jemu_interface_->SetMultiplePinsLevel(arr.get(), pin_changes.size());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x48fb(%rip), %rax      # 0x9f88
movq (%rax), %rbx
testq %rbx, %rbx
je 0x5736
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x572c
subq %r14, %r15
movq %r15, %rax
sarq $0x2, %rax
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r12
movl $0xc, %ecx
movq %r12, %rax
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0x4030
movq %rax, %r13
addq %r15, %rax
xorl %ecx, %ecx
movq %r13, %rdx
movl %ecx, (%rdx)
movb $0x0, 0x4(%rdx)
movl %ecx, 0x8(%rdx)
addq $0xc, %rdx
cmpq %rax, %rdx
jne 0x56e7
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x43a0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq *0x60(%rax)
movl $0xc, %esi
movq %r13, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4240
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1b3c(%rip), %rdi      # 0x7279
leaq 0x1b45(%rip), %rsi      # 0x7289
leaq 0x1e32(%rip), %rcx      # 0x757d
movl $0x66, %edx
callq 0x4170
movq %rax, %rbx
movl $0xc, %esi
movq %r13, %rdi
callq 0x4240
movq %rbx, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O3/Jumperr-labs[P]at25sf081/modeling-framework/src/ModelingFramework.cpp
// Function: SetPinChangeLevelEventCallback(unsigned int, std::function<void (std::vector<WireLogicLevelEvent, std::allocator<WireLogicLevelEvent>>&)> const&)
int SetPinChangeLevelEventCallback(uint32_t pin_id, const pin_change_level_callback_t& callback) {
    assert(jemu_interface_);
    static int id = 0;
    auto pin_change_level_callback = new PinChangeLevelEventCallback(callback);
    jemu_interface_->SetPinChangeLevelEventCallback(pin_id, pin_change_level_callback);
    return id++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x47c7(%rip), %r12      # 0x9f88
cmpq $0x0, (%r12)
je 0x5860
movq %rsi, %r15
movl %edi, %ebx
movl $0x28, %edi
callq 0x4230
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x4150
movq 0x47be(%rip), %rax      # 0x9fb0
addq $0x10, %rax
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq $0x0, 0x18(%r14)
movq 0x20(%rsp), %rax
movq %rax, 0x20(%r14)
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x5836
movq %r14, %rcx
addq $0x8, %rcx
leaq 0x18(%rsp), %rdx
movups -0x10(%rdx), %xmm1
movups %xmm1, (%rcx)
movq %rax, 0x18(%r14)
movups %xmm0, (%rdx)
movq (%r12), %rdi
movq (%rdi), %rax
movl %ebx, %esi
movq %r14, %rdx
callq *0x70(%rax)
movl 0x4a4d(%rip), %eax      # 0xa298
leal 0x1(%rax), %ecx
movl %ecx, 0x4a44(%rip)      # 0xa298
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1a12(%rip), %rdi      # 0x7279
leaq 0x1a1b(%rip), %rsi      # 0x7289
leaq 0x1d75(%rip), %rcx      # 0x75ea
movl $0x83, %edx
callq 0x4170
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x4240
movq %rbx, %rdi
callq 0x4410
nop