LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/./BIG.cpp
// Function: maxPreprocessor::Preprocessor::BIGdfs2(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, int, std::vector<int, std::allocator<int>>&)
void Preprocessor::BIGdfs2(vector<vector<int> >& g, int x, vector<int>& ns) {
	stack<pair<int, int>, vector<pair<int, int> >  > dfs;
	dfs.push({x, 0});
	while (!dfs.empty()) {
		int v = dfs.top().F;
		int ci = dfs.top().S;
		dfs.pop();
		if (ci == 0 && BIGu2[v] == 1) continue;
		BIGu2[v] = 1;
		if (ci >= (int)g[v].size()) {
			ns.push_back(v);
		}
		else {
			dfs.push({v, ci + 1});
			dfs.push({g[v][ci], 0});
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rsi
movl %edx, (%rsi)
movl $0x0, 0x4(%rsi)
callq 0x22d46
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x13b73
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq -0x8(%rax), %rdx
movslq -0x8(%rax), %rcx
movl %ecx, 0x4(%rsp)
movslq -0x4(%rax), %rbp
movq %rdx, 0x18(%rsp)
movq 0x3c8(%r15), %rax
testq %rbp, %rbp
jne 0x13ad7
cmpl $0x1, (%rax,%rcx,4)
je 0x13b60
movl $0x1, (%rax,%rcx,4)
movslq 0x4(%rsp), %rax
movq (%r14), %rcx
leaq (%rax,%rax,2), %rdx
movq 0x8(%rcx,%rdx,8), %rsi
subq (%rcx,%rdx,8), %rsi
shrq $0x2, %rsi
cmpl %esi, %ebp
jge 0x13b3d
leal 0x1(%rbp), %ecx
movl %eax, 0x8(%rsp)
movl %ecx, 0xc(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x22d46
movslq 0x4(%rsp), %rax
movq (%r14), %rcx
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %rax
movl (%rax,%rbp,4), %eax
movl %eax, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x22d46
jmp 0x13b60
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x13b53
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x13b60
movq %rbx, %rdi
leaq 0x4(%rsp), %rdx
callq 0x98f8
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
cmpq %rax, %rdi
jne 0x13aac
testq %rdi, %rdi
je 0x13b85
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13b9a
jmp 0x13b9a
jmp 0x13b9a
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13bb4
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/./BIG.cpp
// Function: maxPreprocessor::Preprocessor::BIGdfs3(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, int, std::vector<int, std::allocator<int>>&)
void Preprocessor::BIGdfs3(vector<vector<int> >& rg, int x, vector<int>& scc) {
	stack<pair<int, int>, vector<pair<int, int> > > dfs;
	dfs.push({x, 0});
	while (!dfs.empty()) {
		int v = dfs.top().F;
		int ci = dfs.top().S;
		dfs.pop();
		if (ci == 0 && BIGu2[v] == 2) continue;
		BIGu2[v] = 2;
		if (ci == 0) scc.push_back(v);
		if (ci < (int)rg[v].size()) {
			dfs.push({v, ci + 1});
			dfs.push({rg[v][ci], 0});
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rsi
movl %edx, (%rsi)
movl $0x0, 0x4(%rsi)
callq 0x22d46
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x13cf2
leaq 0x10(%rsp), %r13
leaq 0x8(%rsp), %rbp
leaq -0x8(%rax), %rdx
movslq -0x8(%rax), %rcx
movl %ecx, 0x4(%rsp)
movslq -0x4(%rax), %r12
movq %rdx, 0x18(%rsp)
movq 0x3c8(%r15), %rax
testq %r12, %r12
je 0x13ca1
movl $0x2, (%rax,%rcx,4)
movslq 0x4(%rsp), %rax
movq (%r14), %rcx
leaq (%rax,%rax,2), %rdx
movq 0x8(%rcx,%rdx,8), %rsi
subq (%rcx,%rdx,8), %rsi
shrq $0x2, %rsi
cmpl %esi, %r12d
jge 0x13ca7
leal 0x1(%r12), %ecx
movl %eax, 0x8(%rsp)
movl %ecx, 0xc(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x22d46
movslq 0x4(%rsp), %rax
movq (%r14), %rcx
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %rax
movl (%rax,%r12,4), %eax
movl %eax, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x22d46
jmp 0x13ca7
cmpl $0x2, (%rax,%rcx,4)
jne 0x13cbc
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
cmpq %rax, %rdi
jne 0x13c16
jmp 0x13cf2
movl $0x2, (%rax,%rcx,4)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x13ce0
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x13c3e
movq %rbx, %rdi
leaq 0x4(%rsp), %rdx
callq 0x98f8
jmp 0x13c3e
testq %rdi, %rdi
je 0x13d04
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13d19
jmp 0x13d19
jmp 0x13d19
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13d33
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x34a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/./BIG.cpp
// Function: maxPreprocessor::Preprocessor::doBIG2(bool)
void Preprocessor::doBIG2(bool doTC) {
	BIGIt++;
	rLog.startTechnique(Log::Technique::EE);
	if ((int)BIGu.size() < 2*pi.vars) BIGu.resize(2*pi.vars);
	if ((int)BIGu2.size() < 2*pi.vars) BIGu2.resize(2*pi.vars);
	if ((int)BIGid.size() < 2*pi.vars) BIGid.resize(2*pi.vars);
	for (int lit = 0; lit < 2*pi.vars; lit++) {
		if (BIGu[lit] == BIGIt || pi.isLabel[litVariable(lit)]) continue;
		if (tryBIG(lit, doTC)) {
			print("fail BIG ", litToDimacs(lit));
			abort();
		}
	}
	rLog.stopTechnique(Log::Technique::EE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
incl 0x3ac(%rdi)
leaq 0x218(%rdi), %r14
movq %r14, %rdi
movl $0x9, %esi
callq 0x28b9e
movq 0x3b8(%rbx), %rcx
subq 0x3b0(%rbx), %rcx
shrq $0x2, %rcx
movslq 0x60(%rbx), %rax
movq %rax, %rsi
addq %rax, %rsi
cmpl %ecx, %esi
jle 0x15e5a
leaq 0x3b0(%rbx), %rdi
callq 0x8cac
movl 0x60(%rbx), %eax
leal (%rax,%rax), %esi
movq 0x3d0(%rbx), %rcx
subq 0x3c8(%rbx), %rcx
shrq $0x2, %rcx
cmpl %ecx, %esi
jle 0x15e85
leaq 0x3c8(%rbx), %rdi
movslq %esi, %rsi
callq 0x8cac
movl 0x60(%rbx), %eax
leal (%rax,%rax), %esi
movq 0x3e8(%rbx), %rcx
subq 0x3e0(%rbx), %rcx
shrq $0x2, %rcx
cmpl %ecx, %esi
jle 0x15ead
leaq 0x3e0(%rbx), %rdi
movslq %esi, %rsi
callq 0x8cac
movl 0x60(%rbx), %eax
testl %eax, %eax
jle 0x15efc
xorl %r15d, %r15d
movzbl %bpl, %ebp
movq 0x3b0(%rbx), %rcx
movl (%rcx,%r15,4), %ecx
cmpl 0x3ac(%rbx), %ecx
je 0x15eee
movl %r15d, %ecx
shrl %ecx
movq 0x48(%rbx), %rdx
cmpl $0x0, (%rdx,%rcx,4)
jne 0x15eee
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x1430e
testl %eax, %eax
jne 0x15f13
movl 0x60(%rbx), %eax
incq %r15
leal (%rax,%rax), %ecx
movslq %ecx, %rcx
cmpq %rcx, %r15
jl 0x15eb8
movq %r14, %rdi
movl $0x9, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x28be0
movl %r15d, %edi
callq 0x277eb
leaq 0x22e55(%rip), %rsi     # 0x38d77
movq %rbx, %rdi
movl %eax, %edx
callq 0x1eb3c
callq 0x3180
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/./BVA.cpp
// Function: maxPreprocessor::Preprocessor::canBVA(int, int, int)
int Preprocessor::canBVA(int c, int d, int lit) {
	if (pi.clauses[d].lit.size() != pi.clauses[c].lit.size()) return -1;
	int hc = -1;
	int hd = -1;
	unsigned i1 = 0;
	unsigned i2 = 0;
	while (i1 < pi.clauses[c].lit.size() || i2 < pi.clauses[d].lit.size()) {
		if (i1 < pi.clauses[c].lit.size() && i2 < pi.clauses[d].lit.size() && pi.clauses[c].lit[i1] == pi.clauses[d].lit[i2]) {
			i1++;
			i2++;
		}
		else if (i1 < pi.clauses[c].lit.size() && (i2 == pi.clauses[d].lit.size() || pi.clauses[d].lit[i2] > pi.clauses[c].lit[i1])) {
			if (hc != -1) {
				return -1;
			}
			hc = pi.clauses[c].lit[i1];
			if (hc != lit) {
				return -1;
			}
			i1++;
		}
		else if (i2 < pi.clauses[d].lit.size() && (i1 == pi.clauses[c].lit.size() || pi.clauses[c].lit[i1] > pi.clauses[d].lit[i2])) {
			if (hd != -1) {
				return -1;
			}
			hd = pi.clauses[d].lit[i2];
			i2++;
		}
	}
	return hd;
}

// Assembly:
pushq %rbp
pushq %rbx
movslq %edx, %rax
movq (%rdi), %r8
leaq (%rax,%rax,4), %rax
movq (%r8,%rax,8), %rdx
movq 0x8(%r8,%rax,8), %rdi
subq %rdx, %rdi
movslq %esi, %rax
leaq (%rax,%rax,4), %rax
movq (%r8,%rax,8), %rsi
movq 0x8(%r8,%rax,8), %r8
subq %rsi, %r8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r8, %rdi
jne 0x16197
sarq $0x2, %rdi
xorl %r8d, %r8d
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
xorl %r10d, %r10d
movl %r8d, %ebx
movl %r10d, %eax
cmpq %rbx, %rdi
jbe 0x1614e
cmpq %rax, %rdi
jbe 0x1613f
movl (%rsi,%rbx,4), %ebp
cmpl (%rdx,%rax,4), %ebp
je 0x1618c
cmpq %rax, %rdi
je 0x16174
movl (%rdx,%rax,4), %ebp
cmpl (%rsi,%rbx,4), %ebp
jle 0x16153
jmp 0x16174
cmpq %rax, %rdi
jbe 0x16194
cmpq %rax, %rdi
jbe 0x1612d
cmpq %rbx, %rdi
je 0x16165
movl (%rsi,%rbx,4), %ebp
cmpl (%rdx,%rax,4), %ebp
jle 0x1612d
cmpl $-0x1, %r9d
jne 0x1619a
movl (%rdx,%rax,4), %r9d
incl %r10d
jmp 0x16127
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $-0x1, %r11d
jne 0x16197
cmpl %ecx, (%rsi,%rbx,4)
jne 0x16197
incl %r8d
movl %ecx, %r11d
jmp 0x16127
incl %r8d
incl %r10d
jmp 0x16127
movl %r9d, %eax
popq %rbx
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x16197
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/./BVA.cpp
// Function: maxPreprocessor::Preprocessor::doBVA2()
void Preprocessor::doBVA2() {
	rLog.startTechnique(Log::Technique::BVA);
	unordered_map<uint64_t, int> hashes;
	for (int lit = 0; lit < 2*pi.vars; lit++) {
		if (tryBVA(lit, hashes)) {
			if (pi.litClauses[lit].size() < 2) continue;
			print("fail BVA ", litToDimacs(lit));
			abort();
		}
	}
	rLog.stopTechnique(Log::Technique::BVA);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x218(%rdi), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x28b9e
leaq 0x38(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
cmpl $0x0, 0x60(%rbx)
jle 0x1778b
movl $0x8, %r13d
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq 0x161a2
testl %eax, %eax
je 0x17778
movq 0x18(%rbx), %rax
movq (%rax,%r13), %rcx
subq -0x8(%rax,%r13), %rcx
cmpq $0x5, %rcx
jae 0x177b0
incq %r15
movslq 0x60(%rbx), %rax
addq %rax, %rax
addq $0x18, %r13
cmpq %rax, %r15
jl 0x17753
movq %r14, %rdi
movl $0xa, %esi
callq 0x28be0
leaq 0x8(%rsp), %rdi
callq 0x91ac
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %r15d, %edi
callq 0x277eb
leaq 0x21794(%rip), %rsi     # 0x38f53
movq %rbx, %rdi
movl %eax, %edx
callq 0x1eb3c
callq 0x3180
jmp 0x177d2
jmp 0x177d2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x91ac
movq %rbx, %rdi
callq 0x34a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/./GSLE.cpp
// Function: maxPreprocessor::Preprocessor::GSLEBT(int, unsigned long, std::vector<int, std::allocator<int>>&, std::vector<unsigned long, std::allocator<unsigned long>>&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, bool&, unsigned long&)
void Preprocessor::GSLEBT(int i, uint64_t w, vector<int>& sel, vector<uint64_t>& weights, vector<vector<int> >& hs, bool& found, uint64_t& itLim) {
	if (i == (int)hs.size()) {
		found = true;
		return;
	}
	if (itLim == 0) {
		return;
	}
	itLim--;
	bool f = false;
	for (int l : hs[i]) {
		if (sel[l]) {
			f = true;
			break;
		}
	}
	if (f) {
		GSLEBT(i + 1, w, sel, weights, hs, found, itLim);
	}
	else {
		for (int l : hs[i]) {
			if (weights[l] > w) continue;
			sel[l] = 1;
			GSLEBT(i + 1, w - weights[l], sel, weights, hs, found, itLim);
			sel[l] = 0;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, %r15
movq %rdi, 0x18(%rsp)
movq (%r9), %rax
movq %r9, 0x20(%rsp)
movq 0x8(%r9), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
cmpl %esi, %ecx
jne 0x1782d
movq 0x60(%rsp), %rax
movb $0x1, (%rax)
jmp 0x17910
movq %rdx, %r14
movq 0x68(%rsp), %rdx
movq (%rdx), %rdx
movq (%r15), %rdi
movslq %esi, %rsi
movq %rsi, 0x8(%rsp)
subq $0x1, %rdx
jb 0x17910
movq 0x68(%rsp), %rsi
movq %rdx, (%rsi)
movq 0x8(%rsp), %rsi
leaq (%rsi,%rsi,2), %rsi
movq (%rax,%rsi,8), %r13
movq 0x8(%rax,%rsi,8), %rbx
movq %r13, %rsi
cmpq %rbx, %r13
je 0x17910
movslq (%rsi), %r8
cmpl $0x0, (%rdi,%r8,4)
jne 0x17888
addq $0x4, %rsi
cmpq %rbx, %rsi
jne 0x17873
jmp 0x1789c
movq 0x8(%rsp), %r8
incq %r8
movq %r8, 0x8(%rsp)
cmpl %ecx, %r8d
jne 0x17843
jmp 0x17820
cmpq %rbx, %r13
je 0x17910
movq 0x8(%rsp), %rax
incl %eax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rbp
movslq (%r13), %r12
movq %r14, %rdx
subq (%rax,%r12,8), %rdx
jb 0x17907
movq (%r15), %rax
movl $0x1, (%rax,%r12,4)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rcx
movq %rbp, %r8
movq 0x20(%rsp), %r9
pushq 0x68(%rsp)
pushq 0x68(%rsp)
callq 0x177e8
addq $0x10, %rsp
movq (%r15), %rax
movl $0x0, (%rax,%r12,4)
movq (%rbp), %rax
addq $0x4, %r13
cmpq %rbx, %r13
jne 0x178ba
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/./GSLE.cpp
// Function: maxPreprocessor::Preprocessor::GSLEtryBackTrack(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, std::vector<unsigned long, std::allocator<unsigned long>>&, unsigned long, unsigned long)
bool Preprocessor::GSLEtryBackTrack(vector<vector<int> >& hs, vector<uint64_t>& weights, uint64_t w, uint64_t itLim) {
	if (hs.size() == 0) return true;
	bool found = false;
	vector<int> sel(weights.size());
	found = false;
	int tries = 10; // magic constant
	for (int l : hs[0]) {
		if (weights[l] > w) continue;
		uint64_t lm = itLim;
		sel[l] = 1;
		GSLEBT(1, w - weights[l], sel, weights, hs, found, lm);
		sel[l] = 0;
		if (found) break;
		tries--;
		if (tries < 0) break;
	}
	return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x17a15
movq %rdx, %r15
movq %rsi, %r14
movq %rcx, 0x8(%rsp)
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
sarq $0x3, %rsi
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x8c20
movb $0x0, 0x7(%rsp)
movq (%r14), %rax
movq (%rax), %rbx
movq 0x8(%rax), %r13
cmpq %r13, %rbx
je 0x17a1a
movq %r14, 0x18(%rsp)
movl $0xa, %r12d
xorl %ebp, %ebp
movq 0x8(%rsp), %rcx
movslq (%rbx), %r14
movq (%r15), %rax
movq %rcx, %rdx
subq (%rax,%r14,8), %rdx
jb 0x17a0a
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movl $0x1, (%rax,%r14,4)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x30(%rsp), %rcx
movq %r15, %r8
movq 0x18(%rsp), %r9
leaq 0x10(%rsp), %rax
pushq %rax
leaq 0xf(%rsp), %rax
pushq %rax
callq 0x177e8
addq $0x10, %rsp
movq 0x30(%rsp), %rax
movl $0x0, (%rax,%r14,4)
movb 0x7(%rsp), %bpl
testb %bpl, %bpl
jne 0x17a1c
testl %r12d, %r12d
jle 0x17a1c
decl %r12d
movq 0x8(%rsp), %rcx
addq $0x4, %rbx
cmpq %r13, %rbx
jne 0x17994
jmp 0x17a1c
movb $0x1, %bpl
jmp 0x17a33
xorl %ebp, %ebp
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x17a33
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
andb $0x1, %bpl
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/./LS.cpp
// Function: maxPreprocessor::Preprocessor::doLS()
int Preprocessor::doLS() {
	while (doBCE());
	rLog.startTechnique(Log::Technique::LS);
	if (!rLog.requestTime(Log::Technique::LS)) {
		rLog.stopTechnique(Log::Technique::LS);
		return 0;
	}
	int added = 0;
	vector<int> checkVar = pi.tl.getTouchedVariables("LS");
	for (int var : checkVar) {
		if (pi.isLabel[var] == VAR_UNDEFINED) continue;
		if (pi.isVarRemoved(var)) continue;
		if (!rLog.requestTime(Log::Technique::LS)) break;
		added += tryLS(var);
	}
	log(added, " clauses labeled by LS");
	rLog.stopTechnique(Log::Technique::LS);
	return added;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movq %r14, %rdi
callq 0x114ce
testl %eax, %eax
jne 0x196b1
leaq 0x218(%r14), %rbx
movq %rbx, %rdi
movl $0xe, %esi
callq 0x28b9e
movq %rbx, %rdi
movl $0xe, %esi
callq 0x29718
testb %al, %al
je 0x19783
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1f9cc(%rip), %rsi     # 0x390c3
leaq 0x1f9c7(%rip), %rdx     # 0x390c5
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x9466
leaq 0x68(%r14), %rsi
movq %rsp, %rdi
movq %r15, %rdx
callq 0x2f8c0
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x19731
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x32b0
movq (%rsp), %r12
movq 0x8(%rsp), %r13
xorl %ebp, %ebp
cmpq %r13, %r12
je 0x19794
movslq (%r12), %r15
movq 0x48(%r14), %rax
cmpl $0x0, (%rax,%r15,4)
je 0x1977d
movq %r14, %rdi
movl %r15d, %esi
callq 0x278a0
testb %al, %al
jne 0x1977d
movq %rbx, %rdi
movl $0xe, %esi
callq 0x29718
testb %al, %al
je 0x19794
movq %r14, %rdi
movl %r15d, %esi
callq 0x19334
addl %eax, %ebp
addq $0x4, %r12
jmp 0x1973c
movq %rbx, %rdi
movl $0xe, %esi
callq 0x28be0
xorl %ebp, %ebp
jmp 0x197c8
leaq 0x1f914(%rip), %rdx     # 0x390af
movq %r14, %rdi
movl %ebp, %esi
callq 0x1e844
movq %rbx, %rdi
movl $0xe, %esi
callq 0x28be0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x197c8
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x1980b
movq 0x28(%rsp), %rsi
incq %rsi
jmp 0x19806
jmp 0x197f2
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1980b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x34a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/preprocessor.cpp
// Function: maxPreprocessor::Preprocessor::validTechniques(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool Preprocessor::validTechniques(string techniques) const {
	int sb = 0;
	string vt = "buvsrilceagpht";
	for (int i = 0; i < (int)techniques.size(); i++) {
		if(techniques[i] == '[') {
			sb++;
		}
		else if(techniques[i] == ']') {
			sb--;
			if (sb < 0) return false;
			if (techniques[i - 1] == '[') return false;
		}
		else {
			bool f = false;
			for (char c : vt) {
				if (techniques[i] == c) {
					f = true;
					break;
				}
			}
			if (!f) return false;
		}
	}
	if (sb != 0) return false;
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1f350(%rip), %rsi     # 0x391f0
leaq 0x1f357(%rip), %rdx     # 0x391fe
movq %rsp, %r14
movq %r14, %rdi
callq 0x9466
movq 0x8(%rbx), %rax
movq (%r14), %rdi
testl %eax, %eax
jle 0x19f18
movq (%rbx), %rcx
movq 0x8(%rsp), %rdx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %esi, %esi
xorl %r8d, %r8d
movzbl (%rcx,%rsi), %r9d
cmpl $0x5d, %r9d
je 0x19ee5
cmpl $0x5b, %r9d
jne 0x19efe
incl %r8d
jmp 0x19ef4
testl %r8d, %r8d
jle 0x19f14
cmpb $0x5b, -0x1(%rcx,%rsi)
je 0x19f14
decl %r8d
incq %rsi
cmpq %rax, %rsi
jne 0x19ecf
jmp 0x19f38
testq %rdx, %rdx
je 0x19f14
xorl %r10d, %r10d
cmpb (%rdi,%r10), %r9b
je 0x19ef4
incq %r10
cmpq %r10, %rdx
jne 0x19f06
xorl %ebx, %ebx
jmp 0x19f1a
movb $0x1, %bl
cmpq %r15, %rdi
je 0x19f2c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
testl %r8d, %r8d
sete %bl
jmp 0x19f1a
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/preprocessor.cpp
// Function: maxPreprocessor::Preprocessor::validPreTechniques(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool Preprocessor::validPreTechniques(string techniques) const {
	int sb = 0;
	string vt = "bus";
	for (int i = 0; i < (int)techniques.size(); i++) {
		if(techniques[i] == '[') {
			sb++;
		}
		else if(techniques[i] == ']') {
			sb--;
			if (sb < 0) return false;
			if (techniques[i - 1] == '[') return false;
		}
		else {
			bool f = false;
			for (char c : vt) {
				if (techniques[i] == c) {
					f = true;
					break;
				}
			}
			if (!f) return false;
		}
	}
	if (sb != 0) return false;
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1f2a3(%rip), %rsi     # 0x391ff
leaq 0x1f29f(%rip), %rdx     # 0x39202
movq %rsp, %r14
movq %r14, %rdi
callq 0x9466
movq 0x8(%rbx), %rax
movq (%r14), %rdi
testl %eax, %eax
jle 0x19fd4
movq (%rbx), %rcx
movq 0x8(%rsp), %rdx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %esi, %esi
xorl %r8d, %r8d
movzbl (%rcx,%rsi), %r9d
cmpl $0x5d, %r9d
je 0x19fa1
cmpl $0x5b, %r9d
jne 0x19fba
incl %r8d
jmp 0x19fb0
testl %r8d, %r8d
jle 0x19fd0
cmpb $0x5b, -0x1(%rcx,%rsi)
je 0x19fd0
decl %r8d
incq %rsi
cmpq %rax, %rsi
jne 0x19f8b
jmp 0x19ff4
testq %rdx, %rdx
je 0x19fd0
xorl %r10d, %r10d
cmpb (%rdi,%r10), %r9b
je 0x19fb0
incq %r10
cmpq %r10, %rdx
jne 0x19fc2
xorl %ebx, %ebx
jmp 0x19fd6
movb $0x1, %bl
cmpq %r15, %rdi
je 0x19fe8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
testl %r8d, %r8d
sete %bl
jmp 0x19fd6
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/inputreader.cpp
// Function: maxPreprocessor::InputReader::readWeightedClause(std::istream&)
int InputReader::readWeightedClause(istream& input) {
	uint64_t weight;
	vector<int> clause;
	input>>weight;
	if (!input.good()) {
		return 1;
	}
	if (weight > top) weight = top;
	int lit;
	while (input>>lit) {
		if (lit == 0) break;
		clause.push_back(lit);
	}
	if (input.fail()) {
		return 1;
	}
	if (weight == 0) return 0;
	clauses.push_back(clause);
	weights.push_back(weight);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x3160
movq (%r14), %rax
movq -0x18(%rax), %rax
movl $0x1, %ebp
cmpl $0x0, 0x20(%r14,%rax)
jne 0x23ea4
movq 0x30(%rbx), %rax
cmpq %rax, (%rsp)
jbe 0x23e28
movq %rax, (%rsp)
leaq 0xc(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x3190
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x23e79
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0x23e79
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x23e6c
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x23e32
movq %r12, %rdi
movq %r15, %rdx
callq 0x98f8
jmp 0x23e32
movq (%r14), %rax
movq -0x18(%rax), %rax
movl $0x1, %ebp
testb $0x5, 0x20(%r14,%rax)
je 0x23eb3
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x23ea4
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
cmpq $0x0, (%rsp)
je 0x23e8d
leaq 0x40(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1f07e
movq 0x60(%rbx), %rsi
cmpq 0x68(%rbx), %rsi
je 0x23ee5
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x60(%rbx)
jmp 0x23e8d
addq $0x58, %rbx
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x23bec
jmp 0x23e8d
jmp 0x23ef8
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x23f12
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/inputreader.cpp
// Function: maxPreprocessor::InputReader::readClause(std::istream&, unsigned long)
int InputReader::readClause(istream& input, uint64_t defaultWeight) {
	vector<int> clause;
	int lit;
	while (input>>lit) {
		if (lit == 0) break;
		clause.push_back(lit);
	}
	if (input.fail()) {
		return 1;
	}
	clauses.push_back(clause);
	weights.push_back(defaultWeight);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, 0x30(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r12
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
leaq 0xc(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x3190
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x23f98
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0x23f98
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x23f8b
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x23f51
movq %r12, %rdi
movq %r13, %rdx
callq 0x98f8
jmp 0x23f51
movq (%r15), %rax
movq -0x18(%rax), %rax
movl $0x1, %ebp
testb $0x5, 0x20(%r15,%rax)
jne 0x23fe6
leaq 0x40(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1f07e
movq 0x60(%rbx), %rsi
cmpq 0x68(%rbx), %rsi
je 0x23fd3
movq %r14, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x60(%rbx)
xorl %ebp, %ebp
jmp 0x23fe6
addq $0x58, %rbx
xorl %ebp, %ebp
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x23bec
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x23ffd
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x24010
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2402a
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/trace.cpp
// Function: maxPreprocessor::Trace::BVE(int, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
void Trace::BVE(int var, const vector<vector<int> >& nClauses) {
	operations.push_back(2);
	data.push_back(vector<int>());
	data.back().push_back(var);
	for (auto& c : nClauses) {
		for (int lit : c) {
			if (litVariable(lit) != var) data.back().push_back(lit);
		}
		data.back().push_back(-1);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl $0x2, 0x10(%rsp)
movq 0x10(%rdi), %rsi
cmpq 0x18(%rdi), %rsi
je 0x26940
movl $0x2, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%rbx)
jmp 0x2694e
leaq 0x8(%rbx), %rdi
leaq 0x10(%rsp), %rdx
callq 0x1ffb8
leaq 0x20(%rbx), %rdi
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x2259a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x26981
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq 0x28(%rbx), %rdi
movq -0x10(%rdi), %rsi
cmpq -0x8(%rdi), %rsi
je 0x2699b
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x10(%rdi)
jmp 0x269a9
addq $-0x18, %rdi
leaq 0xc(%rsp), %rdx
callq 0x98f8
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x26a47
leaq 0x10(%rsp), %r14
movq (%r15), %r13
movq 0x8(%r15), %rbp
cmpq %rbp, %r13
je 0x26a08
movl (%r13), %eax
movl %eax, 0x10(%rsp)
movl %eax, %ecx
sarl %ecx
cmpl 0xc(%rsp), %ecx
je 0x26a02
movq 0x28(%rbx), %rdi
movq -0x10(%rdi), %rsi
cmpq -0x8(%rdi), %rsi
je 0x269f6
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x10(%rdi)
jmp 0x26a02
addq $-0x18, %rdi
movq %r14, %rdx
callq 0x98f8
addq $0x4, %r13
jmp 0x269c5
movq 0x28(%rbx), %rdi
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
movq -0x10(%rdi), %rsi
cmpq -0x8(%rdi), %rsi
je 0x26a2e
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
addq $0x4, %rsi
movq %rsi, -0x10(%rdi)
jmp 0x26a3a
addq $-0x18, %rdi
movq %r14, %rdx
callq 0x1ffb8
addq $0x18, %r15
cmpq %r12, %r15
jne 0x269be
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x26a70
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/trace.cpp
// Function: maxPreprocessor::Trace::BCE(int, std::vector<int, std::allocator<int>> const&)
void Trace::BCE(int lit, const vector<int>& clause) {
	operations.push_back(3);
	data.push_back(vector<int>());
	data.back().push_back(lit);
	for (int l : clause) {
		if (l != lit) {
			data.back().push_back(l);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl $0x3, 0x10(%rsp)
movq 0x10(%rdi), %rsi
cmpq 0x18(%rdi), %rsi
je 0x26ab2
movl $0x3, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%rbx)
jmp 0x26ac0
leaq 0x8(%rbx), %rdi
leaq 0x10(%rsp), %rdx
callq 0x1ffb8
leaq 0x20(%rbx), %rdi
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x2259a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x26af3
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq 0x28(%rbx), %rdi
movq -0x10(%rdi), %rsi
cmpq -0x8(%rdi), %rsi
je 0x26b0d
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x10(%rdi)
jmp 0x26b1b
addq $-0x18, %rdi
leaq 0xc(%rsp), %rdx
callq 0x98f8
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x26b68
leaq 0x10(%rsp), %r14
movl (%r15), %eax
movl %eax, 0x10(%rsp)
cmpl 0xc(%rsp), %eax
je 0x26b5f
movq 0x28(%rbx), %rdi
movq -0x10(%rdi), %rsi
cmpq -0x8(%rdi), %rsi
je 0x26b53
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x10(%rdi)
jmp 0x26b5f
addq $-0x18, %rdi
movq %r14, %rdx
callq 0x98f8
addq $0x4, %r15
cmpq %r12, %r15
jne 0x26b2c
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x26b8f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x34a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/trace.cpp
// Function: maxPreprocessor::Trace::BCR(int, int, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
void Trace::BCR(int lbl1, int lbl2, const vector<vector<int> >& nClauses) {
	operations.push_back(4);
	data.push_back(vector<int>());
	data.back().push_back(lbl1);
	data.back().push_back(lbl2);
	for (auto& c : nClauses) {
		for (int lit : c) {
			assert(litVariable(lit) != litVariable(lbl2));
			if (litVariable(lit) != litVariable(lbl1)) data.back().push_back(lit);
		}
		data.back().push_back(-1);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl $0x4, 0x10(%rsp)
movq 0x10(%rdi), %rsi
cmpq 0x18(%rdi), %rsi
je 0x26bdb
movl $0x4, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%rbx)
jmp 0x26be9
leaq 0x8(%rbx), %rdi
leaq 0x10(%rsp), %rdx
callq 0x1ffb8
leaq 0x20(%rbx), %rdi
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x2259a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x26c1c
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq 0x28(%rbx), %rdi
movq -0x10(%rdi), %rsi
cmpq -0x8(%rdi), %rsi
je 0x26c37
movl %r15d, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x10(%rdi)
jmp 0x26c45
addq $-0x18, %rdi
leaq 0xc(%rsp), %rdx
callq 0x98f8
movq 0x28(%rbx), %rdi
movq -0x10(%rdi), %rsi
cmpq -0x8(%rdi), %rsi
je 0x26c5f
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x10(%rdi)
jmp 0x26c6d
addq $-0x18, %rdi
leaq 0x8(%rsp), %rdx
callq 0x98f8
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x26d1d
leaq 0x10(%rsp), %r14
movq (%r15), %r13
movq 0x8(%r15), %rbp
cmpq %rbp, %r13
je 0x26cde
movl (%r13), %eax
movl %eax, 0x10(%rsp)
movl %eax, %ecx
sarl %ecx
movl 0x8(%rsp), %edx
sarl %edx
cmpl %edx, %ecx
je 0x26d2c
movl 0xc(%rsp), %edx
sarl %edx
cmpl %edx, %ecx
je 0x26cd8
movq 0x28(%rbx), %rdi
movq -0x10(%rdi), %rsi
cmpq -0x8(%rdi), %rsi
je 0x26ccc
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x10(%rdi)
jmp 0x26cd8
addq $-0x18, %rdi
movq %r14, %rdx
callq 0x98f8
addq $0x4, %r13
jmp 0x26c89
movq 0x28(%rbx), %rdi
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
movq -0x10(%rdi), %rsi
cmpq -0x8(%rdi), %rsi
je 0x26d04
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
addq $0x4, %rsi
movq %rsi, -0x10(%rdi)
jmp 0x26d10
addq $-0x18, %rdi
movq %r14, %rdx
callq 0x1ffb8
addq $0x18, %r15
cmpq %r12, %r15
jne 0x26c82
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1285d(%rip), %rdi     # 0x39590
leaq 0x1287c(%rip), %rsi     # 0x395b6
leaq 0x1287f(%rip), %rcx     # 0x395c0
movl $0x34, %edx
callq 0x31b0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x26d65
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x34a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/trace.cpp
// Function: maxPreprocessor::Trace::LS(int, int, std::vector<int, std::allocator<int>> const&)
void Trace::LS(int lbl, int lit, const vector<int>& clause) {
	operations.push_back(6);
	data.push_back(vector<int>());
	data.back().push_back(lbl);
	data.back().push_back(lit);
	for (int l : clause) {
		if (l != lit) {
			data.back().push_back(l);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl $0x6, 0x10(%rsp)
movq 0x10(%rdi), %rsi
cmpq 0x18(%rdi), %rsi
je 0x26e63
movl $0x6, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%rbx)
jmp 0x26e71
leaq 0x8(%rbx), %rdi
leaq 0x10(%rsp), %rdx
callq 0x1ffb8
leaq 0x20(%rbx), %rdi
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x2259a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x26ea4
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq 0x28(%rbx), %rdi
movq -0x10(%rdi), %rsi
cmpq -0x8(%rdi), %rsi
je 0x26ebf
movl %r15d, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x10(%rdi)
jmp 0x26ecd
addq $-0x18, %rdi
leaq 0xc(%rsp), %rdx
callq 0x98f8
movq 0x28(%rbx), %rdi
movq -0x10(%rdi), %rsi
cmpq -0x8(%rdi), %rsi
je 0x26ee7
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x10(%rdi)
jmp 0x26ef5
addq $-0x18, %rdi
leaq 0x8(%rsp), %rdx
callq 0x98f8
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x26f42
leaq 0x10(%rsp), %r14
movl (%r15), %eax
movl %eax, 0x10(%rsp)
cmpl 0x8(%rsp), %eax
je 0x26f39
movq 0x28(%rbx), %rdi
movq -0x10(%rdi), %rsi
cmpq -0x8(%rdi), %rsi
je 0x26f2d
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x10(%rdi)
jmp 0x26f39
addq $-0x18, %rdi
movq %r14, %rdx
callq 0x98f8
addq $0x4, %r15
cmpq %r12, %r15
jne 0x26f06
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x26f69
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x34a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/trace.cpp
// Function: maxPreprocessor::Trace::printSolution(std::ostream&, std::vector<int, std::allocator<int>> const&, unsigned long, int, int)
void Trace::printSolution(ostream& output, const vector<int>& trueLits, uint64_t weight, int vars, int originalVars) {
	auto solution = getSolution(trueLits, weight, vars, originalVars);
	output << "v ";
	for (int lit : solution.F) {
		output << lit << " ";
	}
	output << '\n';
	output << "s OPTIMUM FOUND\n";
	output << "o " << solution.S << '\n';
	
	output.flush();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
callq 0x2703c
leaq 0x11fa9(%rip), %rsi     # 0x39683
movl $0x2, %edx
movq %rbx, %rdi
callq 0x3310
movq 0x8(%rsp), %r15
movq 0x10(%rsp), %r12
cmpq %r12, %r15
je 0x27721
leaq 0x11b77(%rip), %r14     # 0x39274
movl (%r15), %esi
movq %rbx, %rdi
callq 0x3490
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3310
addq $0x4, %r15
cmpq %r12, %r15
jne 0x276fd
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3310
leaq 0x11f49(%rip), %rsi     # 0x39686
movl $0x10, %edx
movq %rbx, %rdi
callq 0x3310
leaq 0xf910(%rip), %rsi      # 0x37061
movl $0x2, %edx
movq %rbx, %rdi
callq 0x3310
movq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x31d0
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x3310
movq %rbx, %rdi
callq 0x31e0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2779f
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x277ad
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x277c7
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x34a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/utility.cpp
// Function: maxPreprocessor::litFromDimacs(int)
int litFromDimacs(int lit) {
	if (lit < 0) {
		return (-lit)*2-1;
	}
	else if(lit > 0) {
		return lit*2-2;
	}
	else {
		return -1;
	}
}

// Assembly:
movl %edi, %eax
testl %edi, %edi
js 0x277e0
je 0x277e5
leal -0x2(,%rax,2), %eax
retq
addl %eax, %eax
notl %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/probleminstance.cpp
// Function: maxPreprocessor::ProblemInstance::isSimpleSoftClause(int) const
bool ProblemInstance::isSimpleSoftClause(int clause) const {
	if (!clauses[clause].isHard()) return false;
	int label = -1;
	for (int l : clauses[clause].lit) {
		if (isLabel[litVariable(l)]) {
			if (label != -1) return false;
			if (litClauses[l].size() != 1) return false;
			label = l;
		}
	}
	if (label == -1) return false;
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %rax
leaq (%rax,%rax,4), %r14
leaq (,%r14,8), %rdi
addq (%rbx), %rdi
callq 0x2883e
testb %al, %al
je 0x27896
movq (%rbx), %rcx
movq (%rcx,%r14,8), %rax
movq 0x8(%rcx,%r14,8), %rcx
cmpq %rcx, %rax
je 0x27896
movq 0x18(%rbx), %rdx
movq 0x48(%rbx), %rsi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl (%rax), %r8d
movl %r8d, %r9d
sarl %r9d
movslq %r9d, %r9
cmpl $0x0, (%rsi,%r9,4)
je 0x27885
cmpl $-0x1, %edi
jne 0x27896
movslq %r8d, %rdi
leaq (%rdi,%rdi,2), %rdi
movq 0x8(%rdx,%rdi,8), %r9
subq (%rdx,%rdi,8), %r9
movl %r8d, %edi
cmpq $0x4, %r9
jne 0x27896
addq $0x4, %rax
cmpq %rcx, %rax
jne 0x27854
cmpl $-0x1, %edi
setne %al
jmp 0x27898
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/probleminstance.cpp
// Function: maxPreprocessor::ProblemInstance::labelWeight(int) const
uint64_t ProblemInstance::labelWeight(int lbl) const {
	if (isLabel[lbl] == VAR_TRUE) {
		assert(litClauses[posLit(lbl)].size() == 1);
		return clauses[litClauses[posLit(lbl)][0]].weight;
	}
	else if(isLabel[lbl] == VAR_FALSE) {
		assert(litClauses[negLit(lbl)].size() == 1);
		return clauses[litClauses[negLit(lbl)][0]].weight;
	}
	else {
		assert(0);
	}
}

// Assembly:
pushq %rax
movslq %esi, %rax
movq 0x48(%rdi), %rcx
movl (%rcx,%rax,4), %eax
cmpl $0x2, %eax
je 0x27931
cmpl $0x1, %eax
jne 0x27965
addl %esi, %esi
movslq %esi, %rax
movq 0x18(%rdi), %rcx
leaq (%rax,%rax,2), %rdx
movq (%rcx,%rdx,8), %rax
movq 0x8(%rcx,%rdx,8), %rcx
subq %rax, %rcx
cmpq $0x4, %rcx
je 0x27954
leaq 0x11d7e(%rip), %rdi     # 0x39697
leaq 0x11d9b(%rip), %rsi     # 0x396bb
leaq 0x11da8(%rip), %rcx     # 0x396cf
movl $0x28, %edx
callq 0x31b0
leal 0x1(,%rsi,2), %eax
cltq
movq 0x18(%rdi), %rcx
leaq (%rax,%rax,2), %rdx
movq (%rcx,%rdx,8), %rax
movq 0x8(%rcx,%rdx,8), %rcx
subq %rax, %rcx
cmpq $0x4, %rcx
jne 0x27984
movslq (%rax), %rax
movq (%rdi), %rcx
leaq (%rax,%rax,4), %rax
movq 0x18(%rcx,%rax,8), %rax
popq %rcx
retq
leaq 0x123f5(%rip), %rdi     # 0x39d61
leaq 0x11d48(%rip), %rsi     # 0x396bb
leaq 0x11d55(%rip), %rcx     # 0x396cf
movl $0x30, %edx
callq 0x31b0
leaq 0x11d86(%rip), %rdi     # 0x39711
leaq 0x11d29(%rip), %rsi     # 0x396bb
leaq 0x11d36(%rip), %rcx     # 0x396cf
movl $0x2c, %edx
callq 0x31b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/probleminstance.cpp
// Function: maxPreprocessor::ProblemInstance::removeClauseFromLitClause(int, int)
void ProblemInstance::removeClauseFromLitClause(int clause, int lit) {
	for (unsigned i = 0; i < litClauses[lit].size(); i++) {
		if (litClauses[lit][i] == clause) {
			litClauses[lit][i] = litClauses[lit][litClauses[lit].size() - 1];
			litClauses[lit].pop_back();
			break;
		}
	}
}

// Assembly:
movslq %edx, %rax
movq 0x18(%rdi), %r8
leaq (%rax,%rax,2), %r9
movq (%r8,%r9,8), %rcx
movq 0x8(%r8,%r9,8), %rax
movq %rax, %rdx
subq %rcx, %rdx
movq %rax, %rdi
subq %rcx, %rdi
je 0x27e98
sarq $0x2, %rdx
leaq (%r8,%r9,8), %r8
movl $0x1, %r9d
xorl %r10d, %r10d
cmpl %esi, (%rcx,%r10,4)
je 0x27e99
movl %r9d, %r10d
incl %r9d
cmpq %r10, %rdx
ja 0x27e87
retq
movl -0x4(%rcx,%rdi), %edx
movl %edx, (%rcx,%r10,4)
addq $-0x4, %rax
movq %rax, 0x8(%r8)
retq
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/probleminstance.cpp
// Function: maxPreprocessor::ProblemInstance::removeClause(int)
void ProblemInstance::removeClause(int clause) {
	assert(removedClauses[clause] == false);
	
	tl.touchClause(clause);
	
	removedClauses[clause] = true;
	removeClauseFromLitClauses(clause);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq %esi, %rbx
movq 0x30(%rdi), %rax
cmpl $0x0, (%rax,%rbx,4)
jne 0x27f63
movq %rdi, %r14
addq $0x68, %rdi
movl %ebx, %esi
callq 0x2e8f0
movq 0x30(%r14), %rax
movl $0x1, (%rax,%rbx,4)
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x27eaa
leaq 0x11861(%rip), %rdi     # 0x397cb
leaq 0x1174a(%rip), %rsi     # 0x396bb
leaq 0x11873(%rip), %rcx     # 0x397eb
movl $0x74, %edx
callq 0x31b0
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/probleminstance.cpp
// Function: maxPreprocessor::ProblemInstance::addClause(std::vector<int, std::allocator<int>> const&, unsigned long)
void ProblemInstance::addClause(const vector<int>& clause, uint64_t weight) {
	clauses.push_back(Clause(clause, weight));
	int cId = clauses.size() - 1;
	populateLitClauses(cId);
	
	removedClauses.push_back(0);
	
	tl.modClause(cId);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1f3de
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x287cc
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x284a4
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x27fd3
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x27fea
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xcccccccd, %eax, %ebp # imm = 0xCCCCCCCD
decl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x27de2
movl $0x0, 0x20(%rsp)
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x28029
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x28037
leaq 0x30(%rbx), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1ffb8
addq $0x68, %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2e882
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2806f
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
jmp 0x2806f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x28086
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/probleminstance.cpp
// Function: maxPreprocessor::ProblemInstance::addVar()
int ProblemInstance::addVar() {
	litClauses.push_back(vector<int>());
	litClauses.push_back(vector<int>());
	isLabel.push_back(0);
	tl.addVar();
	return vars++;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %r14, %rdi
callq 0x2259a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x280cb
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %r14, %rdi
callq 0x2259a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x280fa
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movl $0x0, (%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x2811b
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x50(%rbx)
jmp 0x28127
leaq 0x48(%rbx), %rdi
movq %rsp, %rdx
callq 0x1ffb8
leaq 0x68(%rbx), %rdi
callq 0x2e85c
movl 0x60(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x60(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x28143
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2815c
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/probleminstance.cpp
// Function: maxPreprocessor::ProblemInstance::addLiteralToClause(int, int, bool)
void ProblemInstance::addLiteralToClause(int lit, int clause, bool touch) {
	// Dont add if it already exists
	for (int l : clauses[clause].lit) {
		if (l == lit) return;
		// Tautology -> runtime error
		assert(l != litNegation(lit));
	}
	if (touch) tl.modClause(clause);
	clauses[clause].addLiteral(lit);
	litClauses[lit].push_back(clause);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %edx, 0x4(%rsp)
movslq %edx, %rdx
movq (%rdi), %rax
leaq (%rdx,%rdx,4), %r15
movq (%rax,%r15,8), %rdx
movq 0x8(%rax,%r15,8), %rsi
cmpq %rsi, %rdx
je 0x281a1
movl (%rdx), %edi
cmpl %ebp, %edi
je 0x281ed
xorl %ebp, %edi
cmpl $0x1, %edi
je 0x281f8
addq $0x4, %rdx
jmp 0x28189
testb %cl, %cl
je 0x281b3
leaq 0x68(%r14), %rdi
movl %ebx, %esi
callq 0x2e882
movq (%r14), %rax
leaq (%rax,%r15,8), %rdi
movl %ebp, %esi
callq 0x28848
movslq %ebp, %rax
movq 0x18(%r14), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x281e3
movl %ebx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x281ed
leaq 0x4(%rsp), %rdx
callq 0x98f8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11625(%rip), %rdi     # 0x39824
leaq 0x114b5(%rip), %rsi     # 0x396bb
leaq 0x1162d(%rip), %rcx     # 0x3983a
movl $0x95, %edx
callq 0x31b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/probleminstance.cpp
// Function: maxPreprocessor::ProblemInstance::removeLiteralFromClause(int, int, bool)
void ProblemInstance::removeLiteralFromClause(int lit, int clause, bool touch) {
	if (touch) {
		tl.modClause(clause);
		tl.touchLiteral(lit);
	}
	clauses[clause].removeLiteral(lit);
	removeClauseFromLitClause(clause, lit);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
testl %ecx, %ecx
je 0x28242
leaq 0x68(%r14), %r15
movq %r15, %rdi
movl %ebx, %esi
callq 0x2e882
movq %r15, %rdi
movl %ebp, %esi
callq 0x2e928
movslq %ebx, %rax
leaq (%rax,%rax,4), %rdi
shlq $0x3, %rdi
addq (%r14), %rdi
movl %ebp, %esi
callq 0x2891e
movslq %ebp, %rax
movq 0x18(%r14), %rdi
leaq (%rax,%rax,2), %r8
movq (%rdi,%r8,8), %rcx
movq 0x8(%rdi,%r8,8), %rax
movq %rax, %rdx
subq %rcx, %rdx
movq %rax, %rsi
subq %rcx, %rsi
je 0x282ad
sarq $0x2, %rdx
leaq (%rdi,%r8,8), %rdi
movl $0x1, %r8d
xorl %r9d, %r9d
cmpl %ebx, (%rcx,%r9,4)
je 0x2829d
movl %r8d, %r9d
incl %r8d
cmpq %r9, %rdx
ja 0x2828a
jmp 0x282ad
movl -0x4(%rcx,%rsi), %edx
movl %edx, (%rcx,%r9,4)
addq $-0x4, %rax
movq %rax, 0x8(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/probleminstance.cpp
// Function: maxPreprocessor::ProblemInstance::getWeightSum()
uint64_t ProblemInstance::getWeightSum() {
	uint64_t weightSum = 0;
	for (int c = 0; c < (int)clauses.size(); c++) {
		if (!clauses[c].isHard() && !isClauseRemoved(c)) {
			weightSum += clauses[c].weight;
		}
	}
	return weightSum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
shrq $0x3, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
testl %eax, %eax
jle 0x283a9
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %r14d, %r14d
addq %r15, %rdi
callq 0x2883e
testb %al, %al
je 0x28375
movq (%rbx), %rdi
jmp 0x28388
movq (%rbx), %rdi
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r12,4)
jne 0x28388
addq 0x18(%rdi,%r15), %r14
incq %r12
movq 0x8(%rbx), %rax
subq %rdi, %rax
shrq $0x3, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
cltq
addq $0x28, %r15
cmpq %rax, %r12
jl 0x28364
jmp 0x283ac
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/timer.cpp
// Function: maxPreprocessor::Timer::stop()
void Timer::stop() {
	if (!timing) return;
	timing = false;
	chrono::time_point<std::chrono::steady_clock> endTime = chrono::steady_clock::now();
	elapsedTime += (endTime - startTime);
}

// Assembly:
cmpb $0x1, (%rdi)
jne 0x28771
pushq %rbx
movq %rdi, %rbx
movb $0x0, (%rdi)
callq 0x3390
subq 0x10(%rbx), %rax
cvtsi2sd %rax, %xmm0
divsd 0xe8a2(%rip), %xmm0     # 0x37008
addsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
popq %rbx
retq