LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x12dc8
movq %rdx, %r15
movq %rsi, %rbx
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
sarq $0x3, %rsi
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x6852
leaq 0x7(%rsp), %rax
movb $0x0, (%rax)
movq %rbx, 0x10(%rsp)
movq (%rbx), %rax
movq (%rax), %rbx
movq 0x8(%rax), %r13
pushq $0xa
popq %r12
xorl %ebp, %ebp
cmpq %r13, %rbx
je 0x12dbc
movslq (%rbx), %r14
movq (%r15), %rax
movq 0x28(%rsp), %rdx
subq (%rax,%r14,8), %rdx
jb 0x12db6
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movl $0x1, (%rax,%r14,4)
movq 0x18(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x30(%rsp), %rcx
movq %r15, %r8
movq 0x10(%rsp), %r9
leaq 0x8(%rsp), %rax
pushq %rax
leaq 0xf(%rsp), %rax
pushq %rax
callq 0x12bd0
addq $0x10, %rsp
movq 0x30(%rsp), %rax
andl $0x0, (%rax,%r14,4)
movb 0x7(%rsp), %bpl
testb %bpl, %bpl
jne 0x12dbc
testl %r12d, %r12d
jle 0x12dbc
decl %r12d
addq $0x4, %rbx
jmp 0x12d43
leaq 0x30(%rsp), %rdi
callq 0x7512
jmp 0x12dcb
movb $0x1, %bpl
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_O2/Laakeri[P]maxpre/src/./GSLE.cpp
// Function: maxPreprocessor::Preprocessor::doGSLE2()
void Preprocessor::doGSLE2() {
	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 var : lbs) {
		if (pi.isLabel[var] == VAR_TRUE) {
			if (tryGSLE(negLit(var))) {
				print("fail GSLE");
				print(var + 1);
				abort();
			}
		}
		else {
			if (tryGSLE(posLit(var))) {
				print("fail GSLE");
				print(var + 1);
				abort();
			}
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
xorl %esi, %esi
leaq 0xc(%rsp), %r15
movl %esi, 0xc(%rsp)
cmpl 0x60(%rbx), %esi
jge 0x13847
movslq %esi, %rax
movq 0x48(%rbx), %rcx
cmpl $0x0, (%rcx,%rax,4)
je 0x1383f
movq %rbx, %rdi
callq 0x20fae
testb %al, %al
jne 0x1383f
movq %r14, %rdi
movq %r15, %rsi
callq 0x68a4
movl 0xc(%rsp), %esi
incl %esi
jmp 0x13812
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %r12
cmpq %r12, %r15
je 0x1388b
movslq (%r15), %r14
movq 0x48(%rbx), %rax
leal (%r14,%r14), %esi
cmpl $0x1, (%rax,%r14,4)
jne 0x13879
orl $0x1, %esi
movq %rbx, %rdi
callq 0x12de0
testl %eax, %eax
je 0x13885
jmp 0x138a1
movq %rbx, %rdi
callq 0x12de0
testl %eax, %eax
jne 0x138be
addq $0x4, %r15
jmp 0x13851
leaq 0x10(%rsp), %rdi
callq 0x7512
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1c6b6(%rip), %rsi     # 0x2ff5e
movq %rbx, %rdi
callq 0x18fd8
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0x193b8
jmp 0x138d9
leaq 0x1c699(%rip), %rsi     # 0x2ff5e
movq %rbx, %rdi
callq 0x18fd8
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0x193b8
callq 0x3190
jmp 0x138e2
jmp 0x138e2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7512
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]maxpre/src/./FLP.cpp
// Function: maxPreprocessor::Preprocessor::doFLP()
int Preprocessor::doFLP() {
	rLog.startTechnique(Log::Technique::FLP);
	if (!rLog.requestTime(Log::Technique::FLP)) {
		rLog.stopTechnique(Log::Technique::FLP);
		return 0;
	}
	int removed = 0;
	for (int c = 0; c < (int)pi.clauses.size(); c++) {
		if (!rLog.requestTime(Log::Technique::FLP)) break;
		if (pi.isClauseRemoved(c)) continue;
		if (!pi.clauses[c].isHard()) continue;
		vector<int> lbs;
		bool f = false;
		for (int lit : pi.clauses[c].lit) {
			if (pi.isLabel[litVariable(lit)]) lbs.push_back(lit);
			else f = true;
		}
		if (lbs.size() > 0 && f) removed += tryFLP(lbs, c);
	}
	log(removed, " cores found by FLP");
	rLog.stopTechnique(Log::Technique::FLP);
	return removed;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x218(%rdi), %rbx
pushq $0xc
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x21e0a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x227d2
testb %al, %al
je 0x13f68
xorl %r15d, %r15d
pushq $0x28
popq %rbp
pushq $0xc
popq %r12
leaq 0x10(%rsp), %r13
movl $0x0, (%rsp)
movq %rbx, 0x8(%rsp)
movq 0x8(%r14), %rax
subq (%r14), %rax
cqto
idivq %rbp
cltq
cmpq %rax, %r15
jge 0x13f77
movq %rbx, %rdi
movl %r12d, %esi
callq 0x227d2
testb %al, %al
je 0x13f77
movq %r14, %rdi
movl %r15d, %esi
callq 0x20f14
testb %al, %al
jne 0x13f60
imulq $0x28, %r15, %r12
movq (%r14), %rdi
addq %r12, %rdi
callq 0x21bac
testb %al, %al
je 0x13efc
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq (%r14), %rax
movq (%rax,%r12), %rbx
movq 0x8(%rax,%r12), %rbp
xorl %r12d, %r12d
cmpq %rbp, %rbx
je 0x13f02
movl (%rbx), %eax
movl %eax, 0x4(%rsp)
sarl %eax
cltq
movq 0x48(%r14), %rcx
cmpl $0x0, (%rcx,%rax,4)
je 0x13ef3
movq %r13, %rdi
leaq 0x4(%rsp), %rsi
callq 0x68a4
jmp 0x13ef6
movb $0x1, %r12b
addq $0x4, %rbx
jmp 0x13ecb
pushq $0xc
popq %r12
jmp 0x13f60
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
setne %al
testb %r12b, %al
je 0x13f4c
leaq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0x19284
movq 0x8(%rsp), %rbx
pushq $0x28
popq %rbp
pushq $0xc
popq %r12
movq %r14, %rdi
leaq 0x30(%rsp), %rsi
movl %r15d, %edx
callq 0x138f8
addl %eax, (%rsp)
leaq 0x30(%rsp), %rdi
callq 0x7512
jmp 0x13f58
movq 0x8(%rsp), %rbx
pushq $0x28
popq %rbp
pushq $0xc
popq %r12
movq %r13, %rdi
callq 0x7512
incq %r15
jmp 0x13e5e
pushq $0xc
popq %rsi
movq %rbx, %rdi
callq 0x21e46
xorl %ebp, %ebp
jmp 0x13f96
leaq 0x1c056(%rip), %rdx     # 0x2ffd4
movq %r14, %rdi
movl (%rsp), %ebp
movl %ebp, %esi
callq 0x189d8
pushq $0xc
popq %rsi
movq %rbx, %rdi
callq 0x21e46
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x7512
jmp 0x13fbb
jmp 0x13fb8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7512
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]maxpre/src/./LS.cpp
// Function: maxPreprocessor::Preprocessor::tryLSBCE(int, std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>&, std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&)
void Preprocessor::tryLSBCE(int lit, unordered_set<int>& deletedClauses, unordered_set<int>& touchedList, vector<pair<int, int> >& blockedClauses) {
	for (int c1i : pi.litClauses[lit]) {
		if (deletedClauses.count(c1i)) continue;
		const vector<int>& c1 = pi.clauses[c1i].lit;
		bool f = false;
		for (int c2i : pi.litClauses[litNegation(lit)]) {
			if (deletedClauses.count(c2i)) continue;
			const vector<int>& c2 = pi.clauses[c2i].lit;
			bool ff = false;
			for (int c1l : c1) {
				for (int c2l : c2) {
					if (litNegation(c1l) == c2l && c1l != lit) {
						ff = true;
						break;
					}
				}
				if (ff) break;
			}
			if (!ff) {
				f = true;
				break;
			}
		}
		if (!f) {
			deletedClauses.insert(c1i);
			blockedClauses.push_back({c1i, lit});
			for (int l : c1) {
				touchedList.insert(litVariable(l));
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, 0x28(%rsp)
movq %rcx, %r13
movq %rdx, %r15
movl %esi, %ebp
movslq %esi, %rax
movq %rdi, 0x18(%rsp)
movq 0x18(%rdi), %rcx
imulq $0x18, %rax, %rdx
movq (%rcx,%rdx), %rsi
movq 0x8(%rcx,%rdx), %rcx
movq %rcx, 0x38(%rsp)
xorl $0x1, %eax
cltq
imulq $0x18, %rax, %rax
movq %rax, 0x30(%rsp)
leaq 0x10(%rsp), %rbx
movq %r13, 0x20(%rsp)
cmpq 0x38(%rsp), %rsi
je 0x1413b
movq %rsi, 0x40(%rsp)
movl (%rsi), %eax
movl %eax, 0xc(%rsp)
movq %r15, %rdi
leaq 0xc(%rsp), %rsi
callq 0x1e0fa
testq %rax, %rax
je 0x14052
movq 0x40(%rsp), %rsi
addq $0x4, %rsi
jmp 0x1401f
movslq 0xc(%rsp), %rax
imulq $0x28, %rax, %r12
movq 0x18(%rsp), %rax
addq (%rax), %r12
movq 0x18(%rax), %rax
movq 0x30(%rsp), %rcx
movq (%rax,%rcx), %r13
movq 0x8(%rax,%rcx), %r14
cmpq %r14, %r13
je 0x140e4
movl (%r13), %eax
movl %eax, 0x10(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1e0fa
testq %rax, %rax
je 0x14098
addq $0x4, %r13
jmp 0x14075
movslq 0x10(%rsp), %rax
imulq $0x28, %rax, %rax
movq 0x18(%rsp), %rcx
addq (%rcx), %rax
movq (%r12), %rcx
movq 0x8(%r12), %rdx
cmpq %rdx, %rcx
je 0x14047
movl (%rcx), %esi
movq (%rax), %r8
movq 0x8(%rax), %rdi
cmpq %rdi, %r8
je 0x140de
movq %r8, %r9
addq $0x4, %r8
cmpl %ebp, %esi
je 0x140c0
movl (%r9), %r9d
xorl %esi, %r9d
cmpl $0x1, %r9d
jne 0x140c0
jmp 0x14092
addq $0x4, %rcx
jmp 0x140b2
movq %r15, %rdi
leaq 0xc(%rsp), %rsi
callq 0x1e18a
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
movl %ebp, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x1d392
movq (%r12), %r14
movq 0x8(%r12), %r12
movq 0x20(%rsp), %r13
cmpq %r12, %r14
je 0x14047
movl (%r14), %eax
sarl %eax
movl %eax, 0x10(%rsp)
movq %r13, %rdi
movq %rbx, %rsi
callq 0x1e470
addq $0x4, %r14
jmp 0x14118
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rdi, %r14
movq %r14, %rdi
callq 0xde26
testl %eax, %eax
jne 0x14459
leaq 0x218(%r14), %rbx
pushq $0xe
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x21e0a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x227d2
testb %al, %al
je 0x1450f
leaq 0x1bbb1(%rip), %rsi     # 0x30043
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6788
leaq 0x68(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x2778e
leaq 0x28(%rsp), %rdi
callq 0x3130
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %r15
xorl %ebp, %ebp
cmpq %r15, %r13
je 0x1451e
movslq (%r13), %r12
movq 0x48(%r14), %rax
cmpl $0x0, (%rax,%r12,4)
je 0x14509
movq %r14, %rdi
movl %r12d, %esi
callq 0x20fae
testb %al, %al
jne 0x14509
movq %rbx, %rdi
pushq $0xe
popq %rsi
callq 0x227d2
testb %al, %al
je 0x1451e
movq %r14, %rdi
movl %r12d, %esi
callq 0x1414a
addl %eax, %ebp
addq $0x4, %r13
jmp 0x144ca
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0x21e46
xorl %ebp, %ebp
jmp 0x14544
leaq 0x1bb0a(%rip), %rdx     # 0x3002f
movq %r14, %rdi
movl %ebp, %esi
callq 0x189d8
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0x21e46
leaq 0x10(%rsp), %rdi
callq 0x7512
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3130
jmp 0x14578
movq %rax, %rbx
jmp 0x14578
jmp 0x1456b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7512
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x1b655(%rip), %rsi     # 0x30170
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x6788
movl 0x8(%rbx), %eax
movq (%r14), %rcx
movq 0x8(%r14), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
xorl %edi, %edi
cmpq %rax, %rsi
je 0x14b9d
movq (%rbx), %r9
movzbl (%r9,%rsi), %r8d
cmpl $0x5b, %r8d
je 0x14b69
cmpl $0x5d, %r8d
jne 0x14b6d
testl %edi, %edi
jle 0x14b87
cmpb $0x5b, -0x1(%r9,%rsi)
je 0x14b87
decl %edi
jmp 0x14b82
incl %edi
jmp 0x14b82
xorl %r9d, %r9d
cmpq %r9, %rdx
je 0x14b87
leaq 0x1(%r9), %r10
cmpb (%rcx,%r9), %r8b
movq %r10, %r9
jne 0x14b70
incq %rsi
jmp 0x14b40
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0x3130
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
testl %edi, %edi
sete %bl
jmp 0x14b89
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x1b5ca(%rip), %rsi     # 0x3017f
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x6788
movl 0x8(%rbx), %eax
movq (%r14), %rcx
movq 0x8(%r14), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
xorl %edi, %edi
cmpq %rax, %rsi
je 0x14c37
movq (%rbx), %r9
movzbl (%r9,%rsi), %r8d
cmpl $0x5b, %r8d
je 0x14c03
cmpl $0x5d, %r8d
jne 0x14c07
testl %edi, %edi
jle 0x14c21
cmpb $0x5b, -0x1(%r9,%rsi)
je 0x14c21
decl %edi
jmp 0x14c1c
incl %edi
jmp 0x14c1c
xorl %r9d, %r9d
cmpq %r9, %rdx
je 0x14c21
leaq 0x1(%r9), %r10
cmpb (%rcx,%r9), %r8b
movq %r10, %r9
jne 0x14c0a
incq %rsi
jmp 0x14bda
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0x3130
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
testl %edi, %edi
sete %bl
jmp 0x14c23
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x20(%rsp)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x3170
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
jne 0x1e84e
movq 0x30(%rbx), %rax
cmpq %rax, (%rsp)
jbe 0x1e808
movq %rax, (%rsp)
leaq 0xc(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x31a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1e83f
cmpl $0x0, 0xc(%rsp)
je 0x1e83f
movq %r12, %rdi
movq %r15, %rsi
callq 0x68a4
jmp 0x1e812
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x1e86a
pushq $0x1
popq %rbp
leaq 0x10(%rsp), %rdi
callq 0x7512
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
cmpq $0x0, (%rsp)
je 0x1e851
leaq 0x40(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x18f96
addq $0x58, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x193d8
jmp 0x1e851
jmp 0x1e896
jmp 0x1e896
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7512
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
leaq 0x4(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x31a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1e906
cmpl $0x0, 0x4(%rsp)
je 0x1e906
movq %r15, %rdi
movq %r12, %rsi
callq 0x68a4
jmp 0x1e8d9
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x1e91a
pushq $0x1
popq %rbp
jmp 0x1e93b
leaq 0x40(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x18f96
addq $0x58, %rbx
xorl %ebp, %ebp
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x193d8
leaq 0x10(%rsp), %rdi
callq 0x7512
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1e956
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7512
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
addq $0x8, %rdi
leaq 0x10(%rsp), %r14
movl $0x2, (%r14)
movq %r14, %rsi
callq 0x19ed4
leaq 0x20(%rbx), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x10(%rsp), %rsi
callq 0x1cb40
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x7512
movq 0x28(%rbx), %rdi
addq $-0x18, %rdi
leaq 0xc(%rsp), %rsi
callq 0x68a4
movq (%r15), %r12
movq 0x8(%r15), %r15
cmpq %r15, %r12
je 0x2040e
movq (%r12), %r13
movq 0x8(%r12), %rbp
cmpq %rbp, %r13
je 0x203f3
movl (%r13), %eax
movl %eax, 0x10(%rsp)
sarl %eax
cmpl 0xc(%rsp), %eax
je 0x203ed
movq 0x28(%rbx), %rdi
addq $-0x18, %rdi
movq %r14, %rsi
callq 0x68a4
addq $0x4, %r13
jmp 0x203c8
movq 0x28(%rbx), %rdi
addq $-0x18, %rdi
orl $-0x1, 0x10(%rsp)
movq %r14, %rsi
callq 0x19ed4
addq $0x18, %r12
jmp 0x203ba
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7512
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
addq $0x8, %rdi
leaq 0x10(%rsp), %r15
movl $0x3, (%r15)
movq %r15, %rsi
callq 0x19ed4
leaq 0x20(%rbx), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
leaq 0x10(%rsp), %rsi
callq 0x1cb40
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x7512
movq 0x28(%rbx), %rdi
addq $-0x18, %rdi
leaq 0xc(%rsp), %rsi
callq 0x68a4
movq (%r14), %r12
movq 0x8(%r14), %r14
cmpq %r14, %r12
je 0x204c8
movl (%r12), %eax
movl %eax, 0x10(%rsp)
cmpl 0xc(%rsp), %eax
je 0x204c2
movq 0x28(%rbx), %rdi
addq $-0x18, %rdi
movq %r15, %rsi
callq 0x68a4
addq $0x4, %r12
jmp 0x2049f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7512
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
addq $0x8, %rdi
leaq 0x10(%rsp), %r14
movl $0x4, (%r14)
movq %r14, %rsi
callq 0x19ed4
leaq 0x20(%rbx), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x10(%rsp), %rsi
callq 0x1cb40
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x7512
movq 0x28(%rbx), %rdi
addq $-0x18, %rdi
leaq 0xc(%rsp), %rsi
callq 0x68a4
movq 0x28(%rbx), %rdi
addq $-0x18, %rdi
leaq 0x8(%rsp), %rsi
callq 0x68a4
movq (%r15), %r12
movq 0x8(%r15), %r15
cmpq %r15, %r12
je 0x205d2
movq (%r12), %r13
movq 0x8(%r12), %rbp
cmpq %rbp, %r13
je 0x205b7
movl (%r13), %eax
movl %eax, 0x10(%rsp)
sarl %eax
movl 0x8(%rsp), %ecx
sarl %ecx
cmpl %ecx, %eax
je 0x205e1
movl 0xc(%rsp), %ecx
sarl %ecx
cmpl %ecx, %eax
je 0x205b1
movq 0x28(%rbx), %rdi
addq $-0x18, %rdi
movq %r14, %rsi
callq 0x68a4
addq $0x4, %r13
jmp 0x2057e
movq 0x28(%rbx), %rdi
addq $-0x18, %rdi
orl $-0x1, 0x10(%rsp)
movq %r14, %rsi
callq 0x19ed4
addq $0x18, %r12
jmp 0x20570
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xff28(%rip), %rdi      # 0x30510
leaq 0xff47(%rip), %rsi      # 0x30536
leaq 0xff4a(%rip), %rcx      # 0x30540
pushq $0x34
popq %rdx
callq 0x31c0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7512
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
addq $0x8, %rdi
leaq 0x10(%rsp), %r15
movl $0x6, (%r15)
movq %r15, %rsi
callq 0x19ed4
leaq 0x20(%rbx), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
leaq 0x10(%rsp), %rsi
callq 0x1cb40
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x7512
movq 0x28(%rbx), %rdi
addq $-0x18, %rdi
leaq 0xc(%rsp), %rsi
callq 0x68a4
movq 0x28(%rbx), %rdi
addq $-0x18, %rdi
leaq 0x8(%rsp), %rsi
callq 0x68a4
movq (%r14), %r12
movq 0x8(%r14), %r14
cmpq %r14, %r12
je 0x2073a
movl (%r12), %eax
movl %eax, 0x10(%rsp)
cmpl 0x8(%rsp), %eax
je 0x20734
movq 0x28(%rbx), %rdi
addq $-0x18, %rdi
movq %r15, %rsi
callq 0x68a4
addq $0x4, %r12
jmp 0x20711
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7512
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x207ec
leaq 0xf7d1(%rip), %rsi      # 0x30603
movq %rbx, %rdi
callq 0x32a0
movq 0x8(%rsp), %r15
movq 0x10(%rsp), %r12
leaq 0xf3a9(%rip), %r14      # 0x301f4
cmpq %r12, %r15
je 0x20e6c
movl (%r15), %esi
movq %rbx, %rdi
callq 0x3480
movq %rax, %rdi
movq %r14, %rsi
callq 0x32a0
addq $0x4, %r15
jmp 0x20e4b
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x3320
leaq 0xf788(%rip), %rsi      # 0x30606
movq %rbx, %rdi
callq 0x32a0
leaq 0xd1d4(%rip), %rsi      # 0x2e061
movq %rbx, %rdi
callq 0x32a0
movq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x31e0
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x3320
movq %rbx, %rdi
callq 0x31f0
leaq 0x8(%rsp), %rdi
callq 0x7512
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x20ecd
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7512
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20ef4
je 0x20ef9
leal -0x2(,%rax,2), %eax
retq
addl %eax, %eax
notl %eax
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]maxpre/src/utility.cpp
// Function: maxPreprocessor::litToDimacs(int)
int litToDimacs(int lit) {
	if (lit&1) {
		return -(lit/2+1);
	}
	else {
		return lit/2+1;
	}
}

// Assembly:
movl %edi, %eax
testb $0x1, %al
jne 0x20f08
sarl %eax
incl %eax
retq
pushq $-0x2
popq %rcx
cltd
idivl %ecx
decl %eax
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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
imulq $0x28, %rax, %r14
movq (%rdi), %rdi
addq %r14, %rdi
callq 0x21bac
testb %al, %al
je 0x20f9a
movq (%rbx), %rdx
movq 0x18(%rbx), %rax
movq (%rdx,%r14), %rcx
movq 0x8(%rdx,%r14), %rdx
movq 0x48(%rbx), %rsi
pushq $-0x1
popq %r8
cmpq %rdx, %rcx
je 0x20f9e
movl (%rcx), %edi
movl %edi, %r9d
sarl %r9d
movslq %r9d, %r9
cmpl $0x0, (%rsi,%r9,4)
je 0x20f8e
cmpl $-0x1, %r8d
jne 0x20f9a
movslq %edi, %r8
imulq $0x18, %r8, %r8
movq 0x8(%rax,%r8), %r9
subq (%rax,%r8), %r9
cmpq $0x4, %r9
je 0x20f91
jmp 0x20f9a
movl %r8d, %edi
addq $0x4, %rcx
movl %edi, %r8d
jmp 0x20f59
xorl %eax, %eax
jmp 0x20fa5
cmpl $-0x1, %r8d
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21039
cmpl $0x1, %eax
jne 0x2106d
addl %esi, %esi
movslq %esi, %rax
movq 0x18(%rdi), %rcx
imulq $0x18, %rax, %rdx
movq (%rcx,%rdx), %rax
movq 0x8(%rcx,%rdx), %rcx
subq %rax, %rcx
cmpq $0x4, %rcx
je 0x2105c
leaq 0xf5f0(%rip), %rdi      # 0x30617
leaq 0xf60d(%rip), %rsi      # 0x3063b
leaq 0xf61a(%rip), %rcx      # 0x3064f
pushq $0x28
jmp 0x2109d
leal 0x1(,%rsi,2), %eax
cltq
movq 0x18(%rdi), %rcx
imulq $0x18, %rax, %rdx
movq (%rcx,%rdx), %rax
movq 0x8(%rcx,%rdx), %rcx
subq %rax, %rcx
cmpq $0x4, %rcx
jne 0x21086
movslq (%rax), %rax
movq (%rdi), %rcx
imulq $0x28, %rax, %rax
movq 0x18(%rcx,%rax), %rax
popq %rcx
retq
leaq 0xfc51(%rip), %rdi      # 0x30cc5
leaq 0xf5c0(%rip), %rsi      # 0x3063b
leaq 0xf5cd(%rip), %rcx      # 0x3064f
pushq $0x30
jmp 0x2109d
leaq 0xf604(%rip), %rdi      # 0x30691
leaq 0xf5a7(%rip), %rsi      # 0x3063b
leaq 0xf5b4(%rip), %rcx      # 0x3064f
pushq $0x2c
popq %rdx
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rcx
imulq $0x18, %rax, %rdi
leaq (%rcx,%rdi), %rax
movq (%rcx,%rdi), %rdx
movq 0x8(%rcx,%rdi), %rcx
movq %rcx, %rdi
subq %rdx, %rdi
movq %rdi, %r8
sarq $0x2, %r8
xorl %r10d, %r10d
movl %r10d, %r9d
cmpq %r9, %r8
jbe 0x2144a
leal 0x1(%r9), %r10d
cmpl %esi, (%rdx,%r9,4)
jne 0x21428
movl -0x4(%rdx,%rdi), %esi
movl %esi, (%rdx,%r9,4)
addq $-0x4, %rcx
movq %rcx, 0x8(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x214cb
movq %rdi, %r14
addq $0x68, %rdi
movl %ebx, %esi
callq 0x26f4c
movq 0x30(%r14), %rax
movl $0x1, (%rax,%rbx,4)
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2144c
leaq 0xf279(%rip), %rdi      # 0x3074b
leaq 0xf162(%rip), %rsi      # 0x3063b
leaq 0xf28b(%rip), %rcx      # 0x3076b
pushq $0x74
popq %rdx
callq 0x31c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19284
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x21b64
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x218a8
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x7512
leaq 0x8(%rsp), %rdi
callq 0x7512
movq 0x8(%rbx), %rax
subq (%rbx), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
leal -0x1(%rax), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x213b0
leaq 0x30(%rbx), %rdi
andl $0x0, (%r14)
leaq 0x20(%rsp), %rsi
callq 0x19ed4
addq $0x68, %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x26ede
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7512
jmp 0x21592
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7512
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %r14, %rdi
callq 0x1cb40
movq %rsp, %r15
movq %r15, %rdi
callq 0x7512
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x1cb40
movq %rsp, %r14
movq %r14, %rdi
callq 0x7512
leaq 0x48(%rbx), %rdi
andl $0x0, (%r14)
movq %rsp, %rsi
callq 0x19ed4
leaq 0x68(%rbx), %rdi
callq 0x26eb8
movl 0x60(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x60(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x21625
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7512
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl %edx, 0xc(%rsp)
movslq %edx, %rax
movq (%rdi), %rdi
imulq $0x28, %rax, %r14
movq (%rdi,%r14), %rax
movq 0x8(%rdi,%r14), %rsi
cmpq %rsi, %rax
je 0x21695
movl (%rax), %r8d
cmpl %ebp, %r8d
je 0x216c6
xorl %ebp, %r8d
addq $0x4, %rax
cmpl $0x1, %r8d
jne 0x2165c
leaq 0xf127(%rip), %rdi      # 0x307a4
leaq 0xefb7(%rip), %rsi      # 0x3063b
leaq 0xf12f(%rip), %rcx      # 0x307ba
movl $0x95, %edx
callq 0x31c0
testb %cl, %cl
je 0x216a7
leaq 0x68(%rbx), %rdi
movl %edx, %esi
callq 0x26ede
movq (%rbx), %rdi
addq %r14, %rdi
movl %ebp, %esi
callq 0x21bb6
movslq %ebp, %rax
imulq $0x18, %rax, %rdi
addq 0x18(%rbx), %rdi
leaq 0xc(%rsp), %rsi
callq 0x68a4
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebp
movl %esi, %ebx
movq %rdi, %r14
testl %ecx, %ecx
je 0x216fa
leaq 0x68(%r14), %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x26ede
movq %r15, %rdi
movl %ebx, %esi
callq 0x26f84
movslq %ebp, %rax
imulq $0x28, %rax, %rdi
addq (%r14), %rdi
movl %ebx, %esi
callq 0x21c2e
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21400
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
pushq $0x28
popq %r12
xorl %r13d, %r13d
xorl %r14d, %r14d
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
cqto
idivq %r12
cltq
cmpq %rax, %r13
jge 0x217f9
addq %r15, %rdi
callq 0x21bac
testb %al, %al
jne 0x217f0
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r13,4)
jne 0x217f0
movq (%rbx), %rax
addq 0x18(%rax,%r15), %r14
incq %r13
addq $0x28, %r15
jmp 0x217bb
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21b25
pushq %rbx
movq %rdi, %rbx
movb $0x0, (%rdi)
callq 0x3390
subq 0x10(%rbx), %rax
cvtsi2sd %rax, %xmm0
divsd 0xc4ee(%rip), %xmm0     # 0x2e008
addsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]maxpre/src/timer.cpp
// Function: maxPreprocessor::Timer::getTime()
chrono::duration<double> Timer::getTime() {
	if (timing) {
		stop();
		chrono::duration<double> ret = elapsedTime;
		start();
		return ret;
	}
	else {
		return elapsedTime;
	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x1, (%rdi)
jne 0x21b56
movq %rbx, %rdi
callq 0x21af8
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x21ae0
movsd 0x8(%rsp), %xmm0
jmp 0x21b5b
movsd 0x8(%rbx), %xmm0
addq $0x10, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]maxpre/src/clause.cpp
// Function: maxPreprocessor::Clause::addLiteral(int)
void Clause::addLiteral(int l) {
	lit.push_back(0);
	bool f = false;
	for (int i = 0; i < (int)lit.size() - 1; i++) {
		if (lit[i] > l) {
			for (int j = (int)lit.size() - 1; j > i; j--) {
				lit[j] = lit[j - 1];
			}
			lit[i] = l;
			f = true;
			break;
		}
	}
	if (!f) lit.back() = l;
	
	updateHash();
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
callq 0x19ed4
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
movq %rsi, %rdi
subq %rax, %rdi
shrq $0x2, %rdi
cmpl $0x2, %edi
pushq $0x1
popq %r8
cmovgel %edi, %r8d
decl %r8d
xorl %edx, %edx
movq %rax, %rcx
cmpq %rdx, %r8
je 0x21c01
cmpl %ebp, (%rcx)
jg 0x21c19
incq %rdx
addq $0x4, %rcx
jmp 0x21bef
addq $-0x4, %rsi
movq %rsi, %rcx
movl %ebp, (%rcx)
movq %rbx, %rdi
callq 0x21b86
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movslq %edi, %rsi
decq %rsi
cmpq %rdx, %rsi
jle 0x21c08
movl -0x4(%rax,%rsi,4), %edi
movl %edi, (%rax,%rsi,4)
jmp 0x21c1c
nop
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]maxpre/src/clause.cpp
// Function: maxPreprocessor::Clause::removeLiteral(int)
void Clause::removeLiteral(int l) {
	bool f = false;
	
	for (int i = 0; i < (int)lit.size(); i++) {
		if (lit[i] == l) {
			f = true;
			for (int j = i + 1; j < (int)lit.size(); j++) {
				lit[j - 1] = lit[j];
			}
			lit.pop_back();
			break;
		}
	}
	
	assert(f == true);
	updateHash();
}

// Assembly:
pushq %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
movq %rax, %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
xorl %r9d, %r9d
testl %edx, %edx
cmovgl %edx, %r9d
negq %r9
pushq $0x1
popq %r8
leaq (%r9,%r8), %r10
cmpq $0x1, %r10
je 0x21c85
cmpl %esi, -0x4(%rcx,%r8,4)
je 0x21c72
incq %r8
jmp 0x21c50
movl (%rcx,%r8,4), %esi
movl %esi, -0x4(%rcx,%r8,4)
incq %r8
cmpl %edx, %r8d
jl 0x21c66
addq $-0x4, %rax
movq %rax, 0x8(%rdi)
popq %rax
jmp 0x21b86
leaq 0xeb78(%rip), %rdi      # 0x30804
leaq 0xeb7b(%rip), %rsi      # 0x3080e
leaq 0xeb7f(%rip), %rcx      # 0x30819
pushq $0x3c
popq %rdx
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]maxpre/src/log.cpp
// Function: maxPreprocessor::Log::Log()
Log::Log() {
	activeTechnique = none;
	tLog.resize(30);
	tTimer.resize(30);
	timeLimit = 0;
	gatesExtracted = 0;
	labelsMatched = 0;
	binaryCoresFound = 0;
	toReallocate = 0;
	initialWeightRange = 0;
	weightRange = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
andq $0x0, 0x40(%rdi)
movups %xmm0, (%rdi)
movabsq $0x41cdcd6500000000, %rax # imm = 0x41CDCD6500000000
movq %rax, 0x48(%rdi)
addq $0x68, %rdi
callq 0x21ad4
leaq 0x80(%rbx), %r14
andl $0x0, 0x60(%rbx)
leaq 0x98(%rbx), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rbx)
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0xa0(%rbx)
pushq $0x1e
popq %rsi
movq %r14, %rdi
callq 0x22ade
pushq $0x1e
popq %rsi
movq %r12, %rdi
callq 0x22b12
andq $0x0, 0xb0(%rbx)
andl $0x0, 0xb8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0xc0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x21de4
movq %rax, %r15
movq %r12, %rdi
callq 0x6d3a
movq %r14, %rdi
callq 0x6d76
leaq 0x30(%rbx), %rdi
leaq 0x18(%rbx), %r14
callq 0x6daa
movq %r14, %rdi
callq 0x6dde
movq %rbx, %rdi
callq 0x6dde
movq %r15, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]maxpre/src/log.cpp
// Function: maxPreprocessor::Log::print(std::ostream&)
void Log::print(ostream& out) {
	out<<"c removed clauses, variables, literals, labels\n";
	out<<"c BCE\n";
	tLog[BCE].print(out);
	out<<"c UP\n";
	tLog[UP].print(out);
	out<<"c BVE\n";
	tLog[BVE].print(out);
	out<<"c SE\n";
	tLog[SE].print(out);
	out<<"c SSR\n";
	tLog[SSR].print(out);
	out<<"c SLE\n";
	tLog[SLE].print(out);
	out<<"c BCR\n";
	tLog[BCR].print(out);
	out<<"c SIE\n";
	tLog[SIE].print(out);
	out<<"c EE\n";
	tLog[EE].print(out);
	out<<"c BVA\n";
	tLog[BVA].print(out);
	out<<"c GSLE\n";
	tLog[GSLE].print(out);
	out<<"c FLP\n";
	tLog[FLP].print(out);
	out<<"c UH\n";
	tLog[UH].print(out);
	out<<"c LS\n";
	tLog[LS].print(out);
	out.flush();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xeaba(%rip), %rsi      # 0x30a37
movq %rbx, %rdi
callq 0x32a0
leaq 0xeadb(%rip), %rsi      # 0x30a67
movq %rbx, %rdi
callq 0x32a0
movq 0x80(%r14), %rdi
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x21cac
leaq 0xeac0(%rip), %rsi      # 0x30a6e
movq %rbx, %rdi
callq 0x32a0
movq 0x80(%r14), %rdi
addq $0x20, %rdi
movq %rbx, %rsi
callq 0x21cac
leaq 0xeaa4(%rip), %rsi      # 0x30a74
movq %rbx, %rdi
callq 0x32a0
movq 0x80(%r14), %rdi
addq $0x30, %rdi
movq %rbx, %rsi
callq 0x21cac
leaq 0xea89(%rip), %rsi      # 0x30a7b
movq %rbx, %rdi
callq 0x32a0
movq 0x80(%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x21cac
leaq 0xea6d(%rip), %rsi      # 0x30a81
movq %rbx, %rdi
callq 0x32a0
movq 0x80(%r14), %rdi
addq $0x50, %rdi
movq %rbx, %rsi
callq 0x21cac
leaq 0xea52(%rip), %rsi      # 0x30a88
movq %rbx, %rdi
callq 0x32a0
movq 0x80(%r14), %rdi
addq $0x60, %rdi
movq %rbx, %rsi
callq 0x21cac
leaq 0xea37(%rip), %rsi      # 0x30a8f
movq %rbx, %rdi
callq 0x32a0
movq 0x80(%r14), %rdi
addq $0x70, %rdi
movq %rbx, %rsi
callq 0x21cac
leaq 0xea1c(%rip), %rsi      # 0x30a96
movq %rbx, %rdi
callq 0x32a0
movq 0x80(%r14), %rdi
addq $0x80, %rdi
movq %rbx, %rsi
callq 0x21cac
leaq 0xe9fe(%rip), %rsi      # 0x30a9d
movq %rbx, %rdi
callq 0x32a0
movl $0x90, %edi
addq 0x80(%r14), %rdi
movq %rbx, %rsi
callq 0x21cac
leaq 0xe9e1(%rip), %rsi      # 0x30aa3
movq %rbx, %rdi
callq 0x32a0
movl $0xa0, %edi
addq 0x80(%r14), %rdi
movq %rbx, %rsi
callq 0x21cac
leaq 0xe9c5(%rip), %rsi      # 0x30aaa
movq %rbx, %rdi
callq 0x32a0
movl $0xb0, %edi
addq 0x80(%r14), %rdi
movq %rbx, %rsi
callq 0x21cac
leaq 0xe9aa(%rip), %rsi      # 0x30ab2
movq %rbx, %rdi
callq 0x32a0
movl $0xc0, %edi
addq 0x80(%r14), %rdi
movq %rbx, %rsi
callq 0x21cac
leaq 0xe98e(%rip), %rsi      # 0x30ab9
movq %rbx, %rdi
callq 0x32a0
movl $0xd0, %edi
addq 0x80(%r14), %rdi
movq %rbx, %rsi
callq 0x21cac
leaq 0xe971(%rip), %rsi      # 0x30abf
movq %rbx, %rdi
callq 0x32a0
movl $0xe0, %edi
addq 0x80(%r14), %rdi
movq %rbx, %rsi
callq 0x21cac
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x31f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]maxpre/src/log.cpp
// Function: maxPreprocessor::Log::printInfo(std::ostream&)
void Log::printInfo(ostream& out) {
	out<<"c Labels matched "<<labelsMatched<<'\n';
	out<<"c Gates extracted "<<gatesExtracted<<'\n';
	out<<"c Binary cores found "<<binaryCoresFound<<'\n';
	out<<"c Original weight range "<<initialWeightRange<<'\n';
	out<<"c Preprocessed weight range "<<weightRange<<'\n';
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xe683(%rip), %rsi      # 0x30b36
movq %r14, %rdi
callq 0x32a0
movl 0xb4(%rbx), %esi
movq %rax, %rdi
callq 0x3480
pushq $0xa
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0x3320
leaq 0xe66b(%rip), %rsi      # 0x30b48
movq %r14, %rdi
callq 0x32a0
movl 0xb0(%rbx), %esi
movq %rax, %rdi
callq 0x3480
movq %rax, %rdi
movl %ebp, %esi
callq 0x3320
leaq 0xe657(%rip), %rsi      # 0x30b5b
movq %r14, %rdi
callq 0x32a0
movl 0xb8(%rbx), %esi
movq %rax, %rdi
callq 0x3480
movq %rax, %rdi
movl %ebp, %esi
callq 0x3320
leaq 0xe646(%rip), %rsi      # 0x30b71
movq %r14, %rdi
callq 0x32a0
movq 0xc0(%rbx), %rsi
movq %rax, %rdi
callq 0x31e0
movq %rax, %rdi
movl %ebp, %esi
callq 0x3320
leaq 0xe637(%rip), %rsi      # 0x30b8a
movq %r14, %rdi
callq 0x32a0
movq 0xc8(%rbx), %rsi
movq %rax, %rdi
callq 0x31e0
movq %rax, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]maxpre/src/log.cpp
// Function: maxPreprocessor::Log::requestTime(maxPreprocessor::Log::Technique)
bool Log::requestTime(Technique t) {
	if (timeLimit > infTime/2) return true;
	assert(activeTechnique == t);
	if (askHistory.size() == 0 || askHistory.back() != t) newRequest(t);
	if (totalTimer.getTime().count() > timeLimit) return false;
	if (tTimer[t].getTime().count() < tTimeLimit[t]) return true;
	tTimeLimit[t] += toReallocate; // give reallocate time
	toReallocate = 0;
	return tTimer[t].getTime().count() < tTimeLimit[t];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd 0x48(%rdi), %xmm0
mulsd 0xe0d2(%rip), %xmm0     # 0x308b8
movsd 0x58(%rdi), %xmm1
movb $0x1, %bpl
ucomisd %xmm0, %xmm1
ja 0x2288d
movl %esi, %r14d
movq %rdi, %rbx
cmpl %esi, 0x60(%rdi)
jne 0x2289a
movq 0x38(%rbx), %rax
cmpq 0x30(%rbx), %rax
je 0x22817
cmpl %r14d, -0x4(%rax)
je 0x22822
movq %rbx, %rdi
movl %r14d, %esi
callq 0x228ba
leaq 0x68(%rbx), %rdi
callq 0x21b26
ucomisd 0x58(%rbx), %xmm0
jbe 0x22836
xorl %ebp, %ebp
jmp 0x2288d
movl %r14d, %r15d
imulq $0x18, %r15, %r14
movq 0x98(%rbx), %rdi
addq %r14, %rdi
callq 0x21b26
movq 0x18(%rbx), %rax
movsd (%rax,%r15,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x2288d
addsd 0x50(%rbx), %xmm1
movsd %xmm1, (%rax,%r15,8)
andq $0x0, 0x50(%rbx)
addq 0x98(%rbx), %r14
movq %r14, %rdi
callq 0x21b26
movq 0x18(%rbx), %rax
movsd (%rax,%r15,8), %xmm1
ucomisd %xmm0, %xmm1
seta %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe07f(%rip), %rdi      # 0x30920
leaq 0xe03b(%rip), %rsi      # 0x308e3
leaq 0xe378(%rip), %rcx      # 0x30c27
movl $0xca, %edx
callq 0x31c0
nop