LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dekanfrus[P]pThreads/osproj2c.cpp
// Function: main
int main() {

	pthread_t tid1, tid2;
	string input;
	string buffer;

	cout << "Please enter a phrase: ";
	getline(cin, input);
		
	stringstream stream(input);

	while (stream >> buffer)
		phrase.push_back(buffer);

	pthread_create(&tid2, NULL, &vow, NULL);
	pthread_create(&tid1, NULL, &con, NULL);

	pthread_join(tid1, NULL);
	pthread_join(tid2, NULL);



	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2160
leaq -0x58(%rbp), %rdi
callq 0x2160
movq 0x37f5(%rip), %rdi      # 0x5fd0
leaq 0x182e(%rip), %rsi      # 0x4010
callq 0x2100
jmp 0x27e9
movq 0x37f0(%rip), %rdi      # 0x5fe0
leaq -0x38(%rbp), %rsi
callq 0x2030
jmp 0x27fb
movl $0x10, %edi
movl $0x8, %esi
callq 0x2a20
movl %eax, -0x1f4(%rbp)
jmp 0x2812
movl -0x1f4(%rbp), %edx
leaq -0x1f0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x21a0
jmp 0x282a
jmp 0x282c
leaq -0x1f0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2150
movq %rax, -0x200(%rbp)
jmp 0x2845
movq -0x200(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2140
movb %al, -0x201(%rbp)
jmp 0x2863
movb -0x201(%rbp), %al
testb $0x1, %al
jne 0x286f
jmp 0x28b1
leaq 0x38b2(%rip), %rdi      # 0x6128
leaq -0x58(%rbp), %rsi
callq 0x2a40
jmp 0x2881
jmp 0x282c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x293b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x20b0
jmp 0x293b
leaq -0x328(%rip), %rdx      # 0x2590
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, -0x210(%rbp)
leaq -0x18(%rbp), %rdi
movq %rcx, %rsi
callq 0x21e0
movq -0x210(%rbp), %rcx
leaq -0x56d(%rip), %rdx      # 0x2370
leaq -0x10(%rbp), %rdi
movq %rcx, %rsi
callq 0x21e0
movq -0x210(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x20f0
jmp 0x28fb
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20f0
jmp 0x290a
movl $0x0, -0x4(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x20b0
leaq -0x58(%rbp), %rdi
callq 0x20a0
leaq -0x38(%rbp), %rdi
callq 0x20a0
movl -0x4(%rbp), %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x20a0
leaq -0x38(%rbp), %rdi
callq 0x20a0
movq -0x60(%rbp), %rdi
callq 0x21c0
nopw %cs:(%rax,%rax)
// File: Laakeri[P]maxpre/src/preprocessor.cpp
// Function: maxPreprocessor::Preprocessor::isTautology(maxPreprocessor::Clause const&) const
bool Preprocessor::isTautology(const Clause& clause) const {
	for (unsigned i = 1; i < clause.lit.size(); i++) {
		if (litNegation(clause.lit[i]) == clause.lit[i - 1]) {
			return true;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf940
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x10a4b
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x3c5b0
movl (%rax), %edi
callq 0x3c5a0
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x3c5b0
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl (%rcx), %eax
jne 0x10a3e
movb $0x1, -0x1(%rbp)
jmp 0x10a4f
jmp 0x10a40
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x109e7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Laakeri[P]maxpre/src/preprocessor.cpp
// Function: maxPreprocessor::Preprocessor::removeTautologies()
void Preprocessor::removeTautologies() {
	int found = 0;
	
	for (unsigned i = 0; i < pi.clauses.size(); i++) {
		if (isTautology(pi.clauses[i])) {
			found++;
			pi.removeClause(i);
		}
	}
	
	log(found, " tautologies removed");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movq %rax, -0x20(%rbp)
callq 0x3c4b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x10d00
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x3c600
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x109d0
testb $0x1, %al
jne 0x10cde
jmp 0x10cf3
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %esi
callq 0x5f7f0
jmp 0x10cf5
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x10ca2
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq 0x75582(%rip), %rdx     # 0x86290
callq 0x3c620
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Laakeri[P]maxpre/src/preprocessor.cpp
// Function: maxPreprocessor::Preprocessor::removeEmptyClauses()
int Preprocessor::removeEmptyClauses() {
	int removed = 0;
	vector<int> src;
	for (unsigned i = 0; i < pi.clauses.size(); i++) {
		if (!pi.isClauseRemoved(i)) {
			if (pi.clauses[i].lit.size() == 0) {
				if (pi.clauses[i].isHard()) {
					
				}
				else {
					src.push_back(i);
				}
			}
		}
	}
	for (int c : src) {
		trace.removeWeight(pi.clauses[c].weight);
		pi.removeClause(c);
		removed++;
	}
	log(removed, " empty clauses removed");
	return removed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xa7e0
movl $0x0, -0x2c(%rbp)
movq -0x68(%rbp), %rdi
movl -0x2c(%rbp), %eax
movq %rax, -0x70(%rbp)
callq 0x3c4b0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x12acf
movq -0x68(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x5eb70
movb %al, -0x71(%rbp)
jmp 0x12a3f
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x12abf
jmp 0x12a48
movq -0x68(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x3c600
movq %rax, %rdi
callq 0xf940
cmpq $0x0, %rax
jne 0x12abd
movq -0x68(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x3c600
movq %rax, %rdi
callq 0x60e90
movb %al, -0x72(%rbp)
jmp 0x12a7f
movb -0x72(%rbp), %al
testb $0x1, %al
jne 0x12a88
jmp 0x12aa4
jmp 0x12abb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xab00
jmp 0x12b93
movl -0x2c(%rbp), %eax
movl %eax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3c850
jmp 0x12ab9
jmp 0x12abb
jmp 0x12abd
jmp 0x12abf
jmp 0x12ac1
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x12a0e
leaq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xa800
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0xa830
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa860
testb $0x1, %al
jne 0x12b04
jmp 0x12b5d
leaq -0x50(%rbp), %rdi
callq 0xa8a0
movq -0x68(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
movq %rdi, %rax
addq $0x2f0, %rax            # imm = 0x2F0
movq %rax, -0x80(%rbp)
movslq -0x5c(%rbp), %rsi
callq 0x3c600
movq -0x80(%rbp), %rdi
movq 0x18(%rax), %rsi
callq 0x5cae0
jmp 0x12b3b
movq -0x68(%rbp), %rdi
movl -0x5c(%rbp), %esi
callq 0x5f7f0
jmp 0x12b49
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa930
jmp 0x12af1
movq -0x68(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq 0x737fa(%rip), %rdx     # 0x86365
callq 0x3c620
jmp 0x12b72
movl -0xc(%rbp), %eax
movl %eax, -0x84(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xab00
movl -0x84(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4610
nopl (%rax)
// File: Laakeri[P]maxpre/src/preprocessor.cpp
// Function: maxPreprocessor::Preprocessor::tryUP(int)
int Preprocessor::tryUP(int lit) {
	for (int c : pi.litClauses[lit]) {
		if (pi.clauses[c].lit.size() == 1 && pi.clauses[c].isHard()) {
			if (pi.isLabel[litVariable(lit)] != VAR_UNDEFINED) {
				rLog.removeLabel(1);
			}
			else {
				rLog.removeVariable(1);
			}
			int rmClauses = setVariable(litVariable(lit), litValue(lit));
			rLog.removeClause(rmClauses);
			return rmClauses;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0xaab0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa800
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa830
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa860
testb $0x1, %al
jne 0x12bf8
jmp 0x12ced
leaq -0x28(%rbp), %rdi
callq 0xa8a0
movq -0x40(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rsi
callq 0x3c600
movq %rax, %rdi
callq 0xf940
cmpq $0x1, %rax
jne 0x12cdd
movq -0x40(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x3c600
movq %rax, %rdi
callq 0x60e90
testb $0x1, %al
jne 0x12c43
jmp 0x12cdd
movq -0x40(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x48(%rbp)
movl -0x14(%rbp), %edi
callq 0x3c880
movq -0x48(%rbp), %rdi
movslq %eax, %rsi
callq 0xa7c0
cmpl $0x0, (%rax)
je 0x12c7f
movq -0x40(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
movl $0x1, %esi
callq 0x61590
jmp 0x12c94
movq -0x40(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
movl $0x1, %esi
callq 0x61490
movl -0x14(%rbp), %edi
callq 0x3c880
movl %eax, -0x4c(%rbp)
movl -0x14(%rbp), %edi
callq 0x3c890
movl -0x4c(%rbp), %esi
movq -0x40(%rbp), %rdi
cmpl $0x0, %eax
setne %al
movzbl %al, %edx
andl $0x1, %edx
callq 0x10a60
movq -0x40(%rbp), %rdi
movl %eax, -0x38(%rbp)
addq $0x218, %rdi            # imm = 0x218
movl -0x38(%rbp), %esi
callq 0x61410
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12cf4
jmp 0x12cdf
leaq -0x28(%rbp), %rdi
callq 0xa930
jmp 0x12be2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Laakeri[P]maxpre/src/preprocessor.cpp
// Function: maxPreprocessor::Preprocessor::tryUPAll()
int Preprocessor::tryUPAll() {
	int removed = 0;
	for (unsigned c = 0; c < pi.clauses.size(); c++) {
		if (pi.clauses[c].lit.size() == 1 && pi.clauses[c].isHard() && !pi.isClauseRemoved(c)) {
			int lit = pi.clauses[c].lit[0];
			if (pi.isLabel[litVariable(lit)] != VAR_UNDEFINED) {
				rLog.removeLabel(1);
			}
			else {
				rLog.removeVariable(1);
			}
			int rmClauses = setVariable(litVariable(lit), litValue(lit));
			rLog.removeClause(rmClauses);
			removed += rmClauses;
			if (!rLog.requestTime(Log::Technique::UP)) break;
		}
	}
	return removed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x3c4b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x12e7f
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x3c600
movq %rax, %rdi
callq 0xf940
cmpq $0x1, %rax
jne 0x12e6f
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x3c600
movq %rax, %rdi
callq 0x60e90
testb $0x1, %al
jne 0x12d81
jmp 0x12e6f
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x5eb70
testb $0x1, %al
jne 0x12e6f
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x3c600
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa7c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x14(%rbp)
addq $0x48, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %edi
callq 0x3c880
movq -0x30(%rbp), %rdi
movslq %eax, %rsi
callq 0xa7c0
cmpl $0x0, (%rax)
je 0x12df3
movq -0x20(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
movl $0x1, %esi
callq 0x61590
jmp 0x12e08
movq -0x20(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
movl $0x1, %esi
callq 0x61490
movl -0x14(%rbp), %edi
callq 0x3c880
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %edi
callq 0x3c890
movl -0x34(%rbp), %esi
movq -0x20(%rbp), %rdi
cmpl $0x0, %eax
setne %al
movzbl %al, %edx
andl $0x1, %edx
callq 0x10a60
movq -0x20(%rbp), %rdi
movl %eax, -0x18(%rbp)
addq $0x218, %rdi            # imm = 0x218
movl -0x18(%rbp), %esi
callq 0x61410
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
addq $0x218, %rdi            # imm = 0x218
movl $0x2, %esi
callq 0x62450
testb $0x1, %al
jne 0x12e6d
jmp 0x12e7f
jmp 0x12e6f
jmp 0x12e71
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12d22
movl -0xc(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Laakeri[P]maxpre/src/preprocessor.cpp
// Function: maxPreprocessor::Preprocessor::doUP2()
void Preprocessor::doUP2() {
	rLog.startTechnique(Log::Technique::UP);
	for (int lit = 0; lit < 2*pi.vars; lit++) {
		assert(tryUP(lit) == 0);
	}
	rLog.stopTechnique(Log::Technique::UP);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x218, %rdi            # imm = 0x218
movl $0x2, %esi
callq 0x61320
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x60(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x1316b
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x12ba0
cmpl $0x0, %eax
jne 0x1313f
jmp 0x1315e
leaq 0x7324d(%rip), %rdi     # 0x86393
leaq 0x7317a(%rip), %rsi     # 0x862c7
movl $0x154, %edx            # imm = 0x154
leaq 0x7324a(%rip), %rcx     # 0x863a3
callq 0x4260
jmp 0x13160
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1311c
movq -0x18(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
movl $0x2, %esi
callq 0x61390
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]maxpre/src/./SE.cpp
// Function: maxPreprocessor::Preprocessor::isSubsumed(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&) const
bool Preprocessor::isSubsumed(const vector<int>& a, const vector<int>& b) const {
	unsigned i2 = 0;
	for (unsigned i = 0; i < b.size(); i++) {
		while (i2 < a.size() && a[i2] < b[i]) {
			i2++;
		}
		if (i2 >= a.size() || a[i2] != b[i]) return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf940
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x13b05
jmp 0x13a44
movl -0x24(%rbp), %eax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf940
movq -0x40(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x31(%rbp)
jae 0x13a94
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3c5b0
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x3c5b0
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl (%rcx), %eax
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x13a9d
jmp 0x13aa8
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x13a44
movl -0x24(%rbp), %eax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf940
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x13aef
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3c5b0
movl (%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x3c5b0
movq %rax, %rcx
movl -0x54(%rbp), %eax
cmpl (%rcx), %eax
je 0x13af5
movb $0x0, -0x1(%rbp)
jmp 0x13b09
jmp 0x13af7
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x13a22
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]maxpre/src/./SE.cpp
// Function: maxPreprocessor::Preprocessor::doSE2()
void Preprocessor::doSE2() {
	for (int lit = 0; lit < 2*pi.vars; lit++) {
		if (trySESlow(lit) != 0) {
			print("fail SE ", litToDimacs(lit));
			abort();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x60(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x15998
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x13b20
cmpl $0x0, %eax
je 0x1598b
movl -0xc(%rbp), %edi
callq 0x5eb20
movq -0x18(%rbp), %rdi
movl %eax, %edx
leaq 0x70a77(%rip), %rsi     # 0x863f8
callq 0x3cfa0
callq 0x41f0
jmp 0x1598d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1594b
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Laakeri[P]maxpre/src/./BVE.cpp
// Function: maxPreprocessor::Preprocessor::getBVEHash(std::vector<int, std::allocator<int>> const&, int, int) const
vector<uint64_t> Preprocessor::getBVEHash(const vector<int>& cs, int var, int sw) const {
	vector<uint64_t> h(cs.size());
	for (unsigned i = 0; i < cs.size(); i++) {
		for (int l : pi.clauses[cs[i]].lit) {
			if (litVariable(l) != var) h[i] |= ((uint64_t)1<<(uint64_t)((l^sw)&63));
		}
	}
	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf940
movq %rax, -0x68(%rbp)
leaq -0x22(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xb6b0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x3cff0
jmp 0x15a02
leaq -0x22(%rbp), %rdi
callq 0xbca0
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf940
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x15b35
movq -0x18(%rbp), %rdi
movl -0x38(%rbp), %eax
movl %eax, %esi
callq 0x3c5b0
movq -0x78(%rbp), %rdi
movslq (%rax), %rsi
callq 0x3d060
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3d080
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3d0b0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3d0e0
testb $0x1, %al
jne 0x15a86
jmp 0x15b25
leaq -0x48(%rbp), %rdi
callq 0x3d120
movl (%rax), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %edi
callq 0x3c880
movl %eax, -0x8c(%rbp)
jmp 0x15aa4
movl -0x8c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x15b15
movq -0x70(%rbp), %rdi
movl -0x54(%rbp), %eax
xorl -0x20(%rbp), %eax
andl $0x3f, %eax
movslq %eax, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x98(%rbp)
movl -0x38(%rbp), %eax
movl %eax, %esi
callq 0x3d140
movq -0x98(%rbp), %rcx
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x15b15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x22(%rbp), %rdi
callq 0xbca0
jmp 0x15b55
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xb910
jmp 0x15b55
jmp 0x15b17
leaq -0x48(%rbp), %rdi
callq 0x3d160
jmp 0x15a70
jmp 0x15b27
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x15a12
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x15b48
movq -0x70(%rbp), %rdi
callq 0xb910
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4610
nop
// File: Laakeri[P]maxpre/src/./BVE.cpp
// Function: maxPreprocessor::Preprocessor::doBVE2()
void Preprocessor::doBVE2() {
	for (int var = 0; var < pi.vars; var++) {
		if (pi.isLabel[var] == 0 && (pi.litClauses[posLit(var)].size() > 0 || pi.litClauses[negLit(var)].size() > 0)) {
			if (tryBVE(var) != 0) {
				print("fail BVE ", var + 1);
				abort();
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x60(%rcx), %eax
jge 0x1bbdf
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa7c0
cmpl $0x0, (%rax)
jne 0x1bbcf
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x3c5d0
movq -0x20(%rbp), %rdi
movslq %eax, %rsi
callq 0xaab0
movq %rax, %rdi
callq 0xf940
cmpq $0x0, %rax
ja 0x1bba1
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
callq 0x3c5e0
movq -0x28(%rbp), %rdi
movslq %eax, %rsi
callq 0xaab0
movq %rax, %rdi
callq 0xf940
cmpq $0x0, %rax
jbe 0x1bbcf
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1a760
cmpl $0x0, %eax
je 0x1bbcd
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x1, %edx
leaq 0x6ab79(%rip), %rsi     # 0x8673c
callq 0x3cfa0
callq 0x41f0
jmp 0x1bbcf
jmp 0x1bbd1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1bb1b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]maxpre/src/./SSR.cpp
// Function: maxPreprocessor::Preprocessor::canSSR(int, maxPreprocessor::Clause const&, maxPreprocessor::Clause const&)
bool Preprocessor::canSSR(int var, const Clause& c1, const Clause& c2) {
	if (c1.lit.size() > c2.lit.size()) return false;
	int i2 = 0;
	for (int i = 0; i < (int)c1.lit.size(); i++) {
		while (i2 < (int)c2.lit.size() && c2.lit[i2] < c1.lit[i]) {
			i2++;
		}
		if (litVariable(c1.lit[i]) != var && (i2 >= (int)c2.lit.size() || c2.lit[i2] != c1.lit[i])) return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf940
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0xf940
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jbe 0x1bc32
movb $0x0, -0x1(%rbp)
jmp 0x1bd32
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf940
movq %rax, %rcx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x1bd2e
jmp 0x1bc5f
movl -0x2c(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x28(%rbp), %rdi
callq 0xf940
movl -0x44(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x3d(%rbp)
jge 0x1bca9
movq -0x28(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x3c5b0
movl (%rax), %eax
movl %eax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x3c5b0
movq %rax, %rcx
movl -0x48(%rbp), %eax
cmpl (%rcx), %eax
setl %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x1bcb2
jmp 0x1bcbd
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1bc5f
movq -0x20(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x3c5b0
movl (%rax), %edi
callq 0x3c880
cmpl -0x14(%rbp), %eax
je 0x1bd1e
movl -0x2c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x28(%rbp), %rdi
callq 0xf940
movq %rax, %rcx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jge 0x1bd18
movq -0x28(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x3c5b0
movl (%rax), %eax
movl %eax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x3c5b0
movq %rax, %rcx
movl -0x50(%rbp), %eax
cmpl (%rcx), %eax
je 0x1bd1e
movb $0x0, -0x1(%rbp)
jmp 0x1bd32
jmp 0x1bd20
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1bc40
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Laakeri[P]maxpre/src/./SSR.cpp
// Function: maxPreprocessor::Preprocessor::doSSR2()
void Preprocessor::doSSR2() {
	for (int var = 0; var < pi.vars; var++) {
		if (pi.isLabel[var] == 0 && pi.litClauses[posLit(var)].size() > 0 && pi.litClauses[negLit(var)].size() > 0) {
			if (trySSR(var) != 0){
				print("fail SSR ", var + 1);
				abort();
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x60(%rcx), %eax
jge 0x1e38f
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa7c0
cmpl $0x0, (%rax)
jne 0x1e37f
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x3c5d0
movq -0x20(%rbp), %rdi
movslq %eax, %rsi
callq 0xaab0
movq %rax, %rdi
callq 0xf940
cmpq $0x0, %rax
jbe 0x1e37f
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
callq 0x3c5e0
movq -0x28(%rbp), %rdi
movslq %eax, %rsi
callq 0xaab0
movq %rax, %rdi
callq 0xf940
cmpq $0x0, %rax
jbe 0x1e37f
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1d700
cmpl $0x0, %eax
je 0x1e37d
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x1, %edx
leaq 0x683f2(%rip), %rsi     # 0x86765
callq 0x3cfa0
callq 0x41f0
jmp 0x1e37f
jmp 0x1e381
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1e2cb
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]maxpre/src/./SLE.cpp
// Function: maxPreprocessor::Preprocessor::vSubsumed(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
bool Preprocessor::vSubsumed(vector<int>& v1, vector<int>& v2) {
	for (int a : v1) {
		bool f = false;
		for (int b : v2) {
			if (a == b) {
				f = true;
				break;
			}
		}
		if (!f) {
			return false;
		}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa800
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa830
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa860
testb $0x1, %al
jne 0x1edbc
jmp 0x1ee48
leaq -0x30(%rbp), %rdi
callq 0xa8a0
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movb $0x0, -0x3d(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xa800
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0xa830
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa860
testb $0x1, %al
jne 0x1ee03
jmp 0x1ee2c
leaq -0x50(%rbp), %rdi
callq 0xa8a0
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x5c(%rbp), %eax
jne 0x1ee1f
movb $0x1, -0x3d(%rbp)
jmp 0x1ee2c
jmp 0x1ee21
leaq -0x50(%rbp), %rdi
callq 0xa930
jmp 0x1edf0
testb $0x1, -0x3d(%rbp)
jne 0x1ee38
movb $0x0, -0x1(%rbp)
jmp 0x1ee4c
jmp 0x1ee3a
leaq -0x30(%rbp), %rdi
callq 0xa930
jmp 0x1eda6
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Laakeri[P]maxpre/src/./SLE.cpp
// Function: maxPreprocessor::Preprocessor::doSLE2()
void Preprocessor::doSLE2() {
	vector<int> lbs;
	for (int var = 0; var < pi.vars; var++) {
		if (pi.isLabel[var] != VAR_UNDEFINED && !pi.isVarRemoved(var)) {
			lbs.push_back(var);
		}
	}
	for (int lb1 : lbs) {
		for (int lb2 : lbs) {
			if (lb1 != lb2 && !pi.isVarRemoved(lb1) && !pi.isVarRemoved(lb2)) {
				if (trySLESlow(lb1, lb2)) {
					print("fail SLE");
					print(lb1 + 1, " ", lb2 + 1);
					abort();
				}
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa7e0
movl $0x0, -0x24(%rbp)
movq -0x80(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x60(%rcx), %eax
jge 0x1fbf1
movq -0x80(%rbp), %rdi
addq $0x48, %rdi
movslq -0x24(%rbp), %rsi
callq 0xa7c0
cmpl $0x0, (%rax)
je 0x1fbe4
movq -0x80(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x5ecc0
movb %al, -0x81(%rbp)
jmp 0x1fbad
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x1fbe4
jmp 0x1fbb9
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0xa8c0
jmp 0x1fbc8
jmp 0x1fbe4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xab00
jmp 0x1fd52
jmp 0x1fbe6
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1fb77
leaq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xa800
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0xa830
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa860
testb $0x1, %al
jne 0x1fc29
jmp 0x1fd40
leaq -0x48(%rbp), %rdi
callq 0xa8a0
movl (%rax), %eax
movl %eax, -0x54(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0xa800
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0xa830
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xa860
testb $0x1, %al
jne 0x1fc6f
jmp 0x1fd30
leaq -0x68(%rbp), %rdi
callq 0xa8a0
movl (%rax), %eax
movl %eax, -0x74(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x74(%rbp), %eax
je 0x1fd20
movq -0x80(%rbp), %rdi
movl -0x54(%rbp), %esi
callq 0x5ecc0
movb %al, -0x82(%rbp)
jmp 0x1fc9d
movb -0x82(%rbp), %al
testb $0x1, %al
jne 0x1fd20
jmp 0x1fca9
movq -0x80(%rbp), %rdi
movl -0x74(%rbp), %esi
callq 0x5ecc0
movb %al, -0x83(%rbp)
jmp 0x1fcbd
movb -0x83(%rbp), %al
testb $0x1, %al
jne 0x1fd20
jmp 0x1fcc9
movq -0x80(%rbp), %rdi
movl -0x54(%rbp), %esi
movl -0x74(%rbp), %edx
callq 0x1ee60
movl %eax, -0x88(%rbp)
jmp 0x1fce0
movl -0x88(%rbp), %eax
cmpl $0x0, %eax
je 0x1fd1e
movq -0x80(%rbp), %rdi
leaq 0x66b80(%rip), %rsi     # 0x86876
callq 0x3e470
jmp 0x1fcfd
movq -0x80(%rbp), %rdi
movl -0x54(%rbp), %esi
incl %esi
movl -0x74(%rbp), %ecx
incl %ecx
leaq 0x67442(%rip), %rdx     # 0x87154
callq 0x3e4c0
jmp 0x1fd19
callq 0x41f0
jmp 0x1fd20
jmp 0x1fd22
leaq -0x68(%rbp), %rdi
callq 0xa930
jmp 0x1fc59
jmp 0x1fd32
leaq -0x48(%rbp), %rdi
callq 0xa930
jmp 0x1fc13
leaq -0x20(%rbp), %rdi
callq 0xab00
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4610
nopl (%rax,%rax)
// File: Laakeri[P]maxpre/src/./SIE.cpp
// Function: maxPreprocessor::Preprocessor::SIErndCheck(int, int)
bool Preprocessor::SIErndCheck(int litX, int litY) {
	if (pi.litClauses[litNegation(litX)].size() == 0) return true;
	int c = pi.litClauses[litNegation(litX)].back();
	if (pi.clauses[c].lit.size() > 2) { // magic constant
		if (!binary_search(pi.clauses[c].lit.begin(), pi.clauses[c].lit.end(), litNegation(litY))) {
			return false;
		}
	}
	else {
		bool f = false;
		for (int l : pi.clauses[c].lit) {
			if (l == litNegation(litY)) {
				f = true;
				break;
			}
		}
		if (!f) {
			return false;
		}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x18, %rax
movq %rax, -0x60(%rbp)
movl -0x14(%rbp), %edi
callq 0x3c5a0
movq -0x60(%rbp), %rdi
movslq %eax, %rsi
callq 0xaab0
movq %rax, %rdi
callq 0xf940
cmpq $0x0, %rax
jne 0x21950
movb $0x1, -0x1(%rbp)
jmp 0x21a88
movq -0x68(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x70(%rbp)
movl -0x14(%rbp), %edi
callq 0x3c5a0
movq -0x70(%rbp), %rdi
movslq %eax, %rsi
callq 0xaab0
movq %rax, %rdi
callq 0x3e270
movq -0x68(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x3c600
movq %rax, %rdi
callq 0xf940
cmpq $0x2, %rax
jbe 0x219fc
movq -0x68(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3c600
movq %rax, %rdi
callq 0xa800
movq -0x68(%rbp), %rdi
movq %rax, -0x28(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x3c600
movq %rax, %rdi
callq 0xa830
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %edi
callq 0x3c5a0
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0x3e170
xorb $-0x1, %al
testb $0x1, %al
jne 0x219ee
jmp 0x219f7
movb $0x0, -0x1(%rbp)
jmp 0x21a88
jmp 0x21a84
movq -0x68(%rbp), %rdi
movb $0x0, -0x35(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x3c600
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xa800
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0xa830
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa860
testb $0x1, %al
jne 0x21a3e
jmp 0x21a76
leaq -0x48(%rbp), %rdi
callq 0xa8a0
movl (%rax), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x74(%rbp)
movl -0x18(%rbp), %edi
callq 0x3c5a0
movl %eax, %ecx
movl -0x74(%rbp), %eax
cmpl %ecx, %eax
jne 0x21a69
movb $0x1, -0x35(%rbp)
jmp 0x21a76
jmp 0x21a6b
leaq -0x48(%rbp), %rdi
callq 0xa930
jmp 0x21a2b
testb $0x1, -0x35(%rbp)
jne 0x21a82
movb $0x0, -0x1(%rbp)
jmp 0x21a88
jmp 0x21a84
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]maxpre/src/./SIE.cpp
// Function: maxPreprocessor::Preprocessor::doSIE()
int Preprocessor::doSIE() {
	rLog.startTechnique(Log::Technique::SIE);
	int removed = 0;
	vector<int> checkLit = pi.tl.getTouchedLiterals("SIE");
	for (int lit : checkLit) {
		removed += trySIE(lit);
	}
	log(removed, " clauses removed by SIE");
	rLog.stopTechnique(Log::Technique::SIE);
	return removed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x218, %rdi            # imm = 0x218
movl $0x8, %esi
callq 0x61320
movq -0x98(%rbp), %rax
movl $0x0, -0xc(%rbp)
addq $0x68, %rax
movq %rax, -0x90(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4620
movq -0x88(%rbp), %rdx
leaq 0x642b9(%rip), %rsi     # 0x86b1b
leaq -0x48(%rbp), %rdi
callq 0xa430
jmp 0x2286d
movq -0x90(%rbp), %rsi
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x73500
jmp 0x22883
leaq -0x48(%rbp), %rdi
callq 0x4240
leaq -0x49(%rbp), %rdi
callq 0x43f0
leaq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0xa800
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0xa830
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xa860
testb $0x1, %al
jne 0x228cd
jmp 0x2294e
leaq -0x70(%rbp), %rdi
callq 0xa8a0
movq -0x98(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %esi
callq 0x21e80
movl %eax, -0x9c(%rbp)
jmp 0x228f2
movl -0x9c(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xa930
jmp 0x228b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2292c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4240
leaq -0x49(%rbp), %rdi
callq 0x43f0
jmp 0x229a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xab00
jmp 0x229a1
movq -0x98(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq 0x641a8(%rip), %rdx     # 0x86b07
callq 0x3c620
jmp 0x22966
movq -0x98(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
movl $0x8, %esi
callq 0x61390
jmp 0x22980
movl -0xc(%rbp), %eax
movl %eax, -0xa0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xab00
movl -0xa0(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x4610
nopw (%rax,%rax)
// File: Laakeri[P]maxpre/src/./SIE.cpp
// Function: maxPreprocessor::Preprocessor::doSIE2()
void Preprocessor::doSIE2() {
	for (int litX = 0; litX < pi.vars*2; litX++) {
		for (int litY = 0; litY < pi.vars*2; litY++) {
			if (litVariable(litX) != litVariable(litY) && pi.isLabel[litVariable(litX)] == VAR_UNDEFINED && pi.isLabel[litVariable(litY)] == VAR_UNDEFINED) {
				if (!pi.isVarRemoved(litVariable(litX)) && !pi.isVarRemoved(litVariable(litY))) {
					if (try2SIE(litX, litY)) {
						print("fail SIE ", litToDimacs(litX), " ", litToDimacs(litY));
						print("fail SIE ");
						abort();
					}
				}
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x60(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x22b17
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
movl 0x60(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x22b07
movl -0xc(%rbp), %edi
callq 0x3c880
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %edi
callq 0x3c880
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
je 0x22af7
movq -0x18(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
callq 0x3c880
movq -0x28(%rbp), %rdi
movslq %eax, %rsi
callq 0xa7c0
cmpl $0x0, (%rax)
jne 0x22af7
movq -0x18(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x30(%rbp)
movl -0x10(%rbp), %edi
callq 0x3c880
movq -0x30(%rbp), %rdi
movslq %eax, %rsi
callq 0xa7c0
cmpl $0x0, (%rax)
jne 0x22af7
movl -0xc(%rbp), %edi
callq 0x3c880
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x5ecc0
testb $0x1, %al
jne 0x22af5
movl -0x10(%rbp), %edi
callq 0x3c880
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x5ecc0
testb $0x1, %al
jne 0x22af5
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x21aa0
cmpl $0x0, %eax
je 0x22af3
movl -0xc(%rbp), %edi
callq 0x5eb20
movl %eax, -0x34(%rbp)
movl -0x10(%rbp), %edi
callq 0x5eb20
movl -0x34(%rbp), %edx
movq -0x18(%rbp), %rdi
movl %eax, %r8d
leaq 0x6404d(%rip), %rsi     # 0x86b1f
leaq 0x6467b(%rip), %rcx     # 0x87154
callq 0x3e720
movq -0x18(%rbp), %rdi
leaq 0x64036(%rip), %rsi     # 0x86b1f
callq 0x3e470
callq 0x41f0
jmp 0x22af5
jmp 0x22af7
jmp 0x22af9
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x229e6
jmp 0x22b09
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x229cb
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3e890
movl $0x0, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x44(%rbp), %rdx
callq 0x3e8f0
jmp 0x23055
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3e8c0
jmp 0x23064
jmp 0x23066
leaq -0x38(%rbp), %rdi
callq 0x3e920
movb %al, -0x81(%rbp)
jmp 0x23077
movb -0x81(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x23088
jmp 0x231d6
leaq -0x38(%rbp), %rdi
callq 0x3e940
movq %rax, -0x90(%rbp)
jmp 0x2309a
movq -0x90(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3e940
movq %rax, -0x98(%rbp)
jmp 0x230b8
movq -0x98(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3e960
jmp 0x230d0
cmpl $0x0, -0x5c(%rbp)
jne 0x2310e
movq -0x80(%rbp), %rdi
addq $0x3c8, %rdi            # imm = 0x3C8
movslq -0x58(%rbp), %rsi
callq 0xa7c0
cmpl $0x1, (%rax)
jne 0x2310e
jmp 0x23066
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3e980
jmp 0x231e8
movq -0x80(%rbp), %rdi
addq $0x3c8, %rdi            # imm = 0x3C8
movslq -0x58(%rbp), %rsi
callq 0xa7c0
movl $0x1, (%rax)
movl -0x5c(%rbp), %eax
movl %eax, -0x9c(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x58(%rbp), %rsi
callq 0xaab0
movq %rax, %rdi
callq 0xf940
movq %rax, %rcx
movl -0x9c(%rbp), %eax
cmpl %ecx, %eax
jl 0x23164
movq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa8c0
jmp 0x23162
jmp 0x231d1
movl -0x5c(%rbp), %eax
incl %eax
movl %eax, -0x68(%rbp)
leaq -0x64(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x3e8f0
jmp 0x2317f
leaq -0x38(%rbp), %rdi
leaq -0x64(%rbp), %rsi
callq 0x3e8c0
jmp 0x2318e
movq -0x10(%rbp), %rdi
movslq -0x58(%rbp), %rsi
callq 0xaab0
movq %rax, %rdi
movslq -0x5c(%rbp), %rsi
callq 0xa7c0
movq %rax, %rsi
movl $0x0, -0x74(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x74(%rbp), %rdx
callq 0x3e8f0
jmp 0x231c0
leaq -0x38(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3e8c0
jmp 0x231cf
jmp 0x231d1
jmp 0x23066
leaq -0x38(%rbp), %rdi
callq 0x3e980
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4610
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3e890
movl $0x0, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x44(%rbp), %rdx
callq 0x3e8f0
jmp 0x23245
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3e8c0
jmp 0x23254
jmp 0x23256
leaq -0x38(%rbp), %rdi
callq 0x3e920
movb %al, -0x81(%rbp)
jmp 0x23267
movb -0x81(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x23278
jmp 0x233cc
leaq -0x38(%rbp), %rdi
callq 0x3e940
movq %rax, -0x90(%rbp)
jmp 0x2328a
movq -0x90(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3e940
movq %rax, -0x98(%rbp)
jmp 0x232a8
movq -0x98(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3e960
jmp 0x232c0
cmpl $0x0, -0x5c(%rbp)
jne 0x232fe
movq -0x80(%rbp), %rdi
addq $0x3c8, %rdi            # imm = 0x3C8
movslq -0x58(%rbp), %rsi
callq 0xa7c0
cmpl $0x2, (%rax)
jne 0x232fe
jmp 0x23256
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3e980
jmp 0x233de
movq -0x80(%rbp), %rdi
addq $0x3c8, %rdi            # imm = 0x3C8
movslq -0x58(%rbp), %rsi
callq 0xa7c0
movl $0x2, (%rax)
cmpl $0x0, -0x5c(%rbp)
jne 0x2332f
movq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa8c0
jmp 0x2332d
jmp 0x2332f
movl -0x5c(%rbp), %eax
movl %eax, -0x9c(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x58(%rbp), %rsi
callq 0xaab0
movq %rax, %rdi
callq 0xf940
movq %rax, %rcx
movl -0x9c(%rbp), %eax
cmpl %ecx, %eax
jge 0x233c7
movl -0x5c(%rbp), %eax
incl %eax
movl %eax, -0x68(%rbp)
leaq -0x64(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x3e8f0
jmp 0x23375
leaq -0x38(%rbp), %rdi
leaq -0x64(%rbp), %rsi
callq 0x3e8c0
jmp 0x23384
movq -0x10(%rbp), %rdi
movslq -0x58(%rbp), %rsi
callq 0xaab0
movq %rax, %rdi
movslq -0x5c(%rbp), %rsi
callq 0xa7c0
movq %rax, %rsi
movl $0x0, -0x74(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x74(%rbp), %rdx
callq 0x3e8f0
jmp 0x233b6
leaq -0x38(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3e8c0
jmp 0x233c5
jmp 0x233c7
jmp 0x23256
leaq -0x38(%rbp), %rdi
callq 0x3e980
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4610
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl 0x3ac(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x3ac(%rdi)
addq $0x218, %rdi            # imm = 0x218
movl $0x9, %esi
callq 0x61320
movq -0x18(%rbp), %rdi
addq $0x3b0, %rdi            # imm = 0x3B0
callq 0xf940
movq -0x18(%rbp), %rcx
movl 0x60(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x27054
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x3b0, %rdi            # imm = 0x3B0
movl 0x60(%rax), %eax
shll %eax
movslq %eax, %rsi
callq 0xa990
movq -0x18(%rbp), %rdi
addq $0x3c8, %rdi            # imm = 0x3C8
callq 0xf940
movq -0x18(%rbp), %rcx
movl 0x60(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x2708c
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x3c8, %rdi            # imm = 0x3C8
movl 0x60(%rax), %eax
shll %eax
movslq %eax, %rsi
callq 0xa990
movq -0x18(%rbp), %rdi
addq $0x3e0, %rdi            # imm = 0x3E0
callq 0xf940
movq -0x18(%rbp), %rcx
movl 0x60(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x270c4
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x3e0, %rdi            # imm = 0x3E0
movl 0x60(%rax), %eax
shll %eax
movslq %eax, %rsi
callq 0xa990
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
movl 0x60(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x27170
movq -0x18(%rbp), %rdi
addq $0x3b0, %rdi            # imm = 0x3B0
movslq -0x10(%rbp), %rsi
callq 0xa7c0
movq -0x18(%rbp), %rcx
movl (%rax), %eax
cmpl 0x3ac(%rcx), %eax
je 0x27126
movq -0x18(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %edi
callq 0x3c880
movq -0x20(%rbp), %rdi
movslq %eax, %rsi
callq 0xa7c0
cmpl $0x0, (%rax)
je 0x27128
jmp 0x27162
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x23cc0
cmpl $0x0, %eax
je 0x27160
movl -0x10(%rbp), %edi
callq 0x5eb20
movq -0x18(%rbp), %rdi
movl %eax, %edx
leaq 0x5fb01(%rip), %rsi     # 0x86c57
callq 0x3cfa0
callq 0x41f0
jmp 0x27162
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x270cb
movq -0x18(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
movl $0x9, %esi
callq 0x61390
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x218, %rdi            # imm = 0x218
movl $0xa, %esi
callq 0x61320
leaq -0x40(%rbp), %rdi
callq 0x3c470
movl $0x0, -0x44(%rbp)
movq -0x60(%rbp), %rcx
movl -0x44(%rbp), %eax
movl 0x60(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x29de5
movq -0x60(%rbp), %rdi
movl -0x44(%rbp), %esi
leaq -0x40(%rbp), %rdx
callq 0x27860
movl %eax, -0x64(%rbp)
jmp 0x29d6e
movl -0x64(%rbp), %eax
cmpl $0x0, %eax
je 0x29dd5
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
movslq -0x44(%rbp), %rsi
callq 0xaab0
movq %rax, %rdi
callq 0xf940
cmpq $0x2, %rax
jae 0x29dae
jmp 0x29dd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xbcd0
jmp 0x29e0b
movl -0x44(%rbp), %edi
callq 0x5eb20
movl %eax, -0x68(%rbp)
jmp 0x29dbb
movl -0x68(%rbp), %edx
movq -0x60(%rbp), %rdi
leaq 0x5d06a(%rip), %rsi     # 0x86e33
callq 0x3cfa0
jmp 0x29dd0
callq 0x41f0
jmp 0x29dd7
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x29d45
movq -0x60(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
movl $0xa, %esi
callq 0x61390
jmp 0x29dfc
leaq -0x40(%rbp), %rdi
callq 0xbcd0
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4610
nopw %cs:(%rax,%rax)