LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa7e0
movl $0x0, -0x24(%rbp)
movq -0x60(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x60(%rcx), %eax
jge 0x2bc2b
movq -0x60(%rbp), %rdi
addq $0x48, %rdi
movslq -0x24(%rbp), %rsi
callq 0xa7c0
cmpl $0x0, (%rax)
je 0x2bc1e
movq -0x60(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x5ecc0
movb %al, -0x61(%rbp)
jmp 0x2bbea
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x2bc1e
jmp 0x2bbf3
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0xa8c0
jmp 0x2bc02
jmp 0x2bc1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xab00
jmp 0x2bd47
jmp 0x2bc20
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2bbb7
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 0x2bc63
jmp 0x2bd35
leaq -0x48(%rbp), %rdi
callq 0xa8a0
movq -0x60(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x54(%rbp)
addq $0x48, %rdi
movslq -0x54(%rbp), %rsi
callq 0xa7c0
cmpl $0x1, (%rax)
jne 0x2bcd6
movl -0x54(%rbp), %edi
callq 0x3c5e0
movl %eax, -0x68(%rbp)
jmp 0x2bc94
movl -0x68(%rbp), %esi
movq -0x60(%rbp), %rdi
callq 0x2a280
movl %eax, -0x6c(%rbp)
jmp 0x2bca5
movl -0x6c(%rbp), %eax
cmpl $0x0, %eax
je 0x2bcd4
movq -0x60(%rbp), %rdi
leaq 0x5b206(%rip), %rsi     # 0x86ebe
callq 0x3e470
jmp 0x2bcbf
movq -0x60(%rbp), %rdi
movl -0x54(%rbp), %esi
incl %esi
callq 0x3f300
jmp 0x2bccf
callq 0x41f0
jmp 0x2bd25
movl -0x54(%rbp), %edi
callq 0x3c5d0
movl %eax, -0x70(%rbp)
jmp 0x2bce3
movl -0x70(%rbp), %esi
movq -0x60(%rbp), %rdi
callq 0x2a280
movl %eax, -0x74(%rbp)
jmp 0x2bcf4
movl -0x74(%rbp), %eax
cmpl $0x0, %eax
je 0x2bd23
movq -0x60(%rbp), %rdi
leaq 0x5b1b7(%rip), %rsi     # 0x86ebe
callq 0x3e470
jmp 0x2bd0e
movq -0x60(%rbp), %rdi
movl -0x54(%rbp), %esi
incl %esi
callq 0x3f300
jmp 0x2bd1e
callq 0x41f0
jmp 0x2bd25
jmp 0x2bd27
leaq -0x48(%rbp), %rdi
callq 0xa930
jmp 0x2bc4d
leaq -0x20(%rbp), %rdi
callq 0xab00
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4610
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa7e0
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4510
jmp 0x58300
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x45e0
movb %al, -0x59(%rbp)
jmp 0x58318
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x5834e
jmp 0x58321
movl $0x1, -0x4(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x58433
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xab00
jmp 0x58445
movq -0x58(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x30(%rcx), %rax
jbe 0x58368
movq -0x58(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5836a
movq -0x18(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x4230
movq %rax, -0x68(%rbp)
jmp 0x5837d
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x44b0
movb %al, -0x69(%rbp)
jmp 0x58395
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x5839e
jmp 0x583b7
cmpl $0x0, -0x4c(%rbp)
jne 0x583a6
jmp 0x583b7
leaq -0x38(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0xa8c0
jmp 0x583b5
jmp 0x5836a
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4030
movb %al, -0x6a(%rbp)
jmp 0x583cf
movb -0x6a(%rbp), %al
testb $0x1, %al
jne 0x583d8
jmp 0x583e8
movl $0x1, -0x4(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x58433
cmpq $0x0, -0x20(%rbp)
jne 0x583ff
movl $0x0, -0x4(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x58433
movq -0x58(%rbp), %rdi
addq $0x40, %rdi
leaq -0x38(%rbp), %rsi
callq 0x3e2b0
jmp 0x58412
movq -0x58(%rbp), %rdi
addq $0x58, %rdi
leaq -0x20(%rbp), %rsi
callq 0x3f530
jmp 0x58425
movl $0x0, -0x4(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xab00
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4610
nop
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa7e0
movq -0x18(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x4230
movq %rax, -0x60(%rbp)
jmp 0x58488
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x44b0
movb %al, -0x61(%rbp)
jmp 0x584a0
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x584a9
jmp 0x584dc
cmpl $0x0, -0x3c(%rbp)
jne 0x584cb
jmp 0x584dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xab00
jmp 0x58553
leaq -0x38(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0xa8c0
jmp 0x584da
jmp 0x58475
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4030
movb %al, -0x62(%rbp)
jmp 0x584f4
movb -0x62(%rbp), %al
testb $0x1, %al
jne 0x584fd
jmp 0x5850d
movl $0x1, -0x4(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x58541
movq -0x58(%rbp), %rdi
addq $0x40, %rdi
leaq -0x38(%rbp), %rsi
callq 0x3e2b0
jmp 0x58520
movq -0x58(%rbp), %rdi
addq $0x58, %rdi
leaq -0x20(%rbp), %rsi
callq 0x3f530
jmp 0x58533
movl $0x0, -0x4(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xab00
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4610
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
addq $0x8, %rdi
movl $0x2, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x3c850
movq -0xa8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0xa0(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xa7e0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x3e200
jmp 0x5c2cb
leaq -0x40(%rbp), %rdi
callq 0xab00
movq -0xa8(%rbp), %rdi
addq $0x20, %rdi
callq 0x3e230
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0xa8c0
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x5e970
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x5e9a0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5e9d0
testb $0x1, %al
jne 0x5c328
jmp 0x5c40d
leaq -0x60(%rbp), %rdi
callq 0x5ea10
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x3d080
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x3d0b0
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x3d0e0
testb $0x1, %al
jne 0x5c370
jmp 0x5c3d6
leaq -0x80(%rbp), %rdi
callq 0x3d120
movl (%rax), %eax
movl %eax, -0x8c(%rbp)
movl -0x8c(%rbp), %edi
callq 0x3c880
cmpl -0xc(%rbp), %eax
je 0x5c3c9
movq -0xa8(%rbp), %rdi
addq $0x20, %rdi
callq 0x3e230
movq %rax, %rdi
leaq -0x8c(%rbp), %rsi
callq 0xa8c0
jmp 0x5c3c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xab00
jmp 0x5c416
jmp 0x5c3cb
leaq -0x80(%rbp), %rdi
callq 0x3d160
jmp 0x5c35a
movq -0xa8(%rbp), %rdi
addq $0x20, %rdi
callq 0x3e230
movq %rax, %rdi
movl $0xffffffff, -0x90(%rbp) # imm = 0xFFFFFFFF
leaq -0x90(%rbp), %rsi
callq 0x3c850
leaq -0x60(%rbp), %rdi
callq 0x5ea30
jmp 0x5c312
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4610
nop
// File: Laakeri[P]maxpre/src/trace.cpp
// Function: maxPreprocessor::Trace::BCE(int, std::vector<int, std::allocator<int>> const&)
void Trace::BCE(int lit, const vector<int>& clause) {
	operations.push_back(3);
	data.push_back(vector<int>());
	data.back().push_back(lit);
	for (int l : clause) {
		if (l != lit) {
			data.back().push_back(l);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x8, %rdi
movl $0x3, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x3c850
movq -0x88(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x80(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xa7e0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x3e200
jmp 0x5c48f
leaq -0x40(%rbp), %rdi
callq 0xab00
movq -0x88(%rbp), %rdi
addq $0x20, %rdi
callq 0x3e230
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0xa8c0
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3d080
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3d0b0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3d0e0
testb $0x1, %al
jne 0x5c4e9
jmp 0x5c541
leaq -0x60(%rbp), %rdi
callq 0x3d120
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x5c534
movq -0x88(%rbp), %rdi
addq $0x20, %rdi
callq 0x3e230
movq %rax, %rdi
leaq -0x6c(%rbp), %rsi
callq 0xa8c0
jmp 0x5c534
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xab00
jmp 0x5c54a
jmp 0x5c536
leaq -0x60(%rbp), %rdi
callq 0x3d160
jmp 0x5c4d6
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4610
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
addq $0x8, %rdi
movl $0x4, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x3c850
movq -0xa8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0xa0(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xa7e0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x3e200
jmp 0x5c5de
leaq -0x40(%rbp), %rdi
callq 0xab00
movq -0xa8(%rbp), %rdi
addq $0x20, %rdi
callq 0x3e230
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0xa8c0
movq -0xa8(%rbp), %rdi
addq $0x20, %rdi
callq 0x3e230
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0xa8c0
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x5e970
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x5e9a0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5e9d0
testb $0x1, %al
jne 0x5c657
jmp 0x5c79e
leaq -0x60(%rbp), %rdi
callq 0x5ea10
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x3d080
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x3d0b0
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x3d0e0
testb $0x1, %al
jne 0x5c6a2
jmp 0x5c767
leaq -0x80(%rbp), %rdi
callq 0x3d120
movl (%rax), %eax
movl %eax, -0x8c(%rbp)
movl -0x8c(%rbp), %edi
callq 0x3c880
movl %eax, -0xac(%rbp)
movl -0x10(%rbp), %edi
callq 0x3c880
movl %eax, %ecx
movl -0xac(%rbp), %eax
cmpl %ecx, %eax
je 0x5c6da
jmp 0x5c713
leaq 0x2ae10(%rip), %rdi     # 0x874f1
leaq 0x2ae2f(%rip), %rsi     # 0x87517
movl $0x34, %edx
leaq 0x2ae2d(%rip), %rcx     # 0x87521
callq 0x4260
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xab00
jmp 0x5c7a7
movl -0x8c(%rbp), %edi
callq 0x3c880
movl %eax, -0xb0(%rbp)
movl -0xc(%rbp), %edi
callq 0x3c880
movl %eax, %ecx
movl -0xb0(%rbp), %eax
cmpl %ecx, %eax
je 0x5c757
movq -0xa8(%rbp), %rdi
addq $0x20, %rdi
callq 0x3e230
movq %rax, %rdi
leaq -0x8c(%rbp), %rsi
callq 0xa8c0
jmp 0x5c759
leaq -0x80(%rbp), %rdi
callq 0x3d160
jmp 0x5c689
movq -0xa8(%rbp), %rdi
addq $0x20, %rdi
callq 0x3e230
movq %rax, %rdi
movl $0xffffffff, -0x90(%rbp) # imm = 0xFFFFFFFF
leaq -0x90(%rbp), %rsi
callq 0x3c850
leaq -0x60(%rbp), %rdi
callq 0x5ea30
jmp 0x5c641
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4610
// File: Laakeri[P]maxpre/src/trace.cpp
// Function: maxPreprocessor::Trace::LS(int, int, std::vector<int, std::allocator<int>> const&)
void Trace::LS(int lbl, int lit, const vector<int>& clause) {
	operations.push_back(6);
	data.push_back(vector<int>());
	data.back().push_back(lbl);
	data.back().push_back(lit);
	for (int l : clause) {
		if (l != lit) {
			data.back().push_back(l);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x8, %rdi
movl $0x6, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x3c850
movq -0x88(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x80(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xa7e0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x3e200
jmp 0x5c902
leaq -0x40(%rbp), %rdi
callq 0xab00
movq -0x88(%rbp), %rdi
addq $0x20, %rdi
callq 0x3e230
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0xa8c0
movq -0x88(%rbp), %rdi
addq $0x20, %rdi
callq 0x3e230
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0xa8c0
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3d080
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3d0b0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3d0e0
testb $0x1, %al
jne 0x5c978
jmp 0x5c9d0
leaq -0x60(%rbp), %rdi
callq 0x3d120
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x5c9c3
movq -0x88(%rbp), %rdi
addq $0x20, %rdi
callq 0x3e230
movq %rax, %rdi
leaq -0x6c(%rbp), %rsi
callq 0xa8c0
jmp 0x5c9c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xab00
jmp 0x5c9d9
jmp 0x5c9c5
leaq -0x60(%rbp), %rdi
callq 0x3d160
jmp 0x5c965
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4610
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movl -0x28(%rbp), %r9d
leaq -0x48(%rbp), %rdi
callq 0x5cb20
movq -0x10(%rbp), %rdi
leaq 0x28d99(%rip), %rsi     # 0x875e4
callq 0x4380
jmp 0x5e852
leaq -0x48(%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 0x5e887
jmp 0x5e8e0
leaq -0x68(%rbp), %rdi
callq 0xa8a0
movl (%rax), %eax
movl %eax, -0x74(%rbp)
movq -0x10(%rbp), %rdi
movl -0x74(%rbp), %esi
callq 0x4600
movq %rax, -0x80(%rbp)
jmp 0x5e8a7
movq -0x80(%rbp), %rdi
leaq 0x288a2(%rip), %rsi     # 0x87154
callq 0x4380
jmp 0x5e8b9
jmp 0x5e8bb
leaq -0x68(%rbp), %rdi
callq 0xa930
jmp 0x5e874
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5ea90
jmp 0x5e964
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x4460
jmp 0x5e8f0
movq -0x10(%rbp), %rdi
leaq 0x28cec(%rip), %rsi     # 0x875e7
callq 0x4380
jmp 0x5e902
movq -0x10(%rbp), %rdi
leaq 0x26748(%rip), %rsi     # 0x85055
callq 0x4380
movq %rax, -0x88(%rbp)
jmp 0x5e91b
movq -0x88(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x40c0
movq %rax, -0x90(%rbp)
jmp 0x5e934
movq -0x90(%rbp), %rdi
movl $0xa, %esi
callq 0x4460
jmp 0x5e947
movq -0x10(%rbp), %rdi
callq 0x4270
jmp 0x5e952
leaq -0x48(%rbp), %rdi
callq 0x5ea90
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4610
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x5eafc
xorl %eax, %eax
subl -0x8(%rbp), %eax
shll %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x5eb16
cmpl $0x0, -0x8(%rbp)
jle 0x5eb0f
movl -0x8(%rbp), %eax
shll %eax
subl $0x2, %eax
movl %eax, -0x4(%rbp)
jmp 0x5eb16
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5eb4b
movl -0x8(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
addl $0x1, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x5eb5c
movl -0x8(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x3d060
movq %rax, %rdi
callq 0x60e90
testb $0x1, %al
jne 0x5ebd5
movb $0x0, -0x1(%rbp)
jmp 0x5eca7
movq -0x40(%rbp), %rdi
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movslq -0x14(%rbp), %rsi
callq 0x3d060
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3d080
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3d0b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3d0e0
testb $0x1, %al
jne 0x5ec1a
jmp 0x5ec97
leaq -0x28(%rbp), %rdi
callq 0x3d120
movq %rax, %rcx
movq -0x40(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x34(%rbp)
addq $0x48, %rax
movq %rax, -0x48(%rbp)
movl -0x34(%rbp), %edi
callq 0x3c880
movq -0x48(%rbp), %rdi
movslq %eax, %rsi
callq 0x3c5b0
cmpl $0x0, (%rax)
je 0x5ec87
cmpl $-0x1, -0x18(%rbp)
je 0x5ec5c
movb $0x0, -0x1(%rbp)
jmp 0x5eca7
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movslq -0x34(%rbp), %rsi
callq 0x3d180
movq %rax, %rdi
callq 0xf940
cmpq $0x1, %rax
je 0x5ec81
movb $0x0, -0x1(%rbp)
jmp 0x5eca7
movl -0x34(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x5ec89
leaq -0x28(%rbp), %rdi
callq 0x3d160
jmp 0x5ec07
cmpl $-0x1, -0x18(%rbp)
jne 0x5eca3
movb $0x0, -0x1(%rbp)
jmp 0x5eca7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x48, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3c5b0
cmpl $0x1, (%rax)
jne 0x5ee11
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0x3c5d0
movq -0x28(%rbp), %rdi
movslq %eax, %rsi
callq 0x3d180
movq %rax, %rdi
callq 0xf940
cmpq $0x1, %rax
jne 0x5edad
jmp 0x5edcc
leaq 0x28844(%rip), %rdi     # 0x875f8
leaq 0x28861(%rip), %rsi     # 0x8761c
movl $0x28, %edx
leaq 0x28869(%rip), %rcx     # 0x87630
callq 0x4260
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %edi
callq 0x3c5d0
movq -0x30(%rbp), %rdi
movslq %eax, %rsi
callq 0x3d180
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3c5b0
movq -0x20(%rbp), %rdi
movslq (%rax), %rsi
callq 0x3d060
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5eedb
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3c5b0
cmpl $0x2, (%rax)
jne 0x5eebc
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %edi
callq 0x3c5e0
movq -0x38(%rbp), %rdi
movslq %eax, %rsi
callq 0x3d180
movq %rax, %rdi
callq 0xf940
cmpq $0x1, %rax
jne 0x5ee5b
jmp 0x5ee7a
leaq 0x28810(%rip), %rdi     # 0x87672
leaq 0x287b3(%rip), %rsi     # 0x8761c
movl $0x2c, %edx
leaq 0x287bb(%rip), %rcx     # 0x87630
callq 0x4260
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %edi
callq 0x3c5e0
movq -0x40(%rbp), %rdi
movslq %eax, %rsi
callq 0x3d180
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3c5b0
movq -0x20(%rbp), %rdi
movslq (%rax), %rsi
callq 0x3d060
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5eedb
leaq 0x28d5f(%rip), %rdi     # 0x87c22
leaq 0x28752(%rip), %rsi     # 0x8761c
movl $0x30, %edx
leaq 0x2875a(%rip), %rcx     # 0x87630
callq 0x4260
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0xaab0
movq %rax, %rdi
callq 0xf940
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x5f75b
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0xaab0
movq %rax, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0xa7c0
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x5f74b
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0xaab0
movq -0x20(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0xaab0
movq %rax, %rdi
callq 0xf940
movq -0x38(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0xa7c0
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0xaab0
movq %rax, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0xa7c0
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rdi
movl %ecx, (%rax)
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0xaab0
movq %rax, %rdi
callq 0x60010
jmp 0x5f75b
jmp 0x5f74d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5f671
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x30, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa7c0
cmpl $0x0, (%rax)
jne 0x5f81b
jmp 0x5f83a
leaq 0x27f0a(%rip), %rdi     # 0x8772c
leaq 0x27df3(%rip), %rsi     # 0x8761c
movl $0x74, %edx
leaq 0x27f17(%rip), %rcx     # 0x8774c
callq 0x4260
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
movl -0xc(%rbp), %esi
callq 0x72690
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa7c0
movq -0x18(%rbp), %rdi
movl $0x1, (%rax)
movl -0xc(%rbp), %esi
callq 0x5f770
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3edb0
movq -0x78(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x60da0
jmp 0x5f8ca
movq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x60040
jmp 0x5f8dc
leaq -0x40(%rbp), %rdi
callq 0xd5b0
leaq -0x58(%rbp), %rdi
callq 0xab00
movq -0x80(%rbp), %rdi
callq 0x3c4b0
movq -0x80(%rbp), %rdi
subq $0x1, %rax
movl %eax, -0x68(%rbp)
movl -0x68(%rbp), %esi
callq 0x5f5c0
movq -0x80(%rbp), %rdi
addq $0x30, %rdi
movl $0x0, -0x6c(%rbp)
leaq -0x6c(%rbp), %rsi
callq 0x3c850
movq -0x80(%rbp), %rdi
addq $0x68, %rdi
movl -0x68(%rbp), %esi
callq 0x725d0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x5f95e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd5b0
leaq -0x58(%rbp), %rdi
callq 0xab00
movq -0x60(%rbp), %rdi
callq 0x4610
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x18, %rax
movq %rax, -0x68(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xa7e0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x3e200
jmp 0x5f9ba
leaq -0x20(%rbp), %rdi
callq 0xab00
movq -0x70(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x80(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xa7e0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x3e200
jmp 0x5f9fa
leaq -0x50(%rbp), %rdi
callq 0xab00
movq -0x70(%rbp), %rdi
addq $0x48, %rdi
movl $0x0, -0x54(%rbp)
leaq -0x54(%rbp), %rsi
callq 0x3c850
movq -0x70(%rbp), %rdi
addq $0x68, %rdi
callq 0x72590
movq -0x70(%rbp), %rcx
movl 0x60(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x60(%rcx)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xab00
jmp 0x5fa6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xab00
movq -0x28(%rbp), %rdi
callq 0x4610
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movslq -0x10(%rbp), %rsi
callq 0x3c600
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 0x5fadb
jmp 0x5fb3b
leaq -0x28(%rbp), %rdi
callq 0xa8a0
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x5faf6
jmp 0x5fb86
movl -0x34(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0xc(%rbp), %edi
callq 0x3c5a0
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
je 0x5fb0f
jmp 0x5fb2e
leaq 0x27c6f(%rip), %rdi     # 0x87785
leaq 0x27aff(%rip), %rsi     # 0x8761c
movl $0x95, %edx
leaq 0x27c72(%rip), %rcx     # 0x8779b
callq 0x4260
jmp 0x5fb30
leaq -0x28(%rbp), %rdi
callq 0xa930
jmp 0x5fac8
testb $0x1, -0x11(%rbp)
je 0x5fb51
movq -0x40(%rbp), %rdi
addq $0x68, %rdi
movl -0x10(%rbp), %esi
callq 0x725d0
movq -0x40(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x3c600
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x60ec0
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0xaab0
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0xa8c0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x11(%rbp)
je 0x5fbd7
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
movl -0x10(%rbp), %esi
callq 0x725d0
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
movl -0xc(%rbp), %esi
callq 0x726f0
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x3c600
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x60fd0
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x5f650
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x3c4b0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x5fe3b
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3c600
movq %rax, %rdi
callq 0x60e90
testb $0x1, %al
jne 0x5fe2e
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5eb70
testb $0x1, %al
jne 0x5fe2e
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3c600
movq 0x18(%rax), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x5fe30
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5fdd3
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, (%rax)
jne 0x60a2b
jmp 0x60a6e
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
callq 0x44e0
movq -0x28(%rbp), %rsi
movq %rax, -0x10(%rbp)
addq $0x10, %rsi
leaq -0x10(%rbp), %rdi
callq 0x60b30
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x60b80
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
leaq -0x18(%rbp), %rsi
callq 0x60bc0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, (%rax)
je 0x60ab5
movq -0x18(%rbp), %rdi
callq 0x60a10
movq -0x18(%rbp), %rdi
movq 0x8(%rdi), %rax
movq %rax, -0x8(%rbp)
callq 0x609d0
jmp 0x60ac1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x0, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x3c850
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0xf940
movq %rax, %rcx
movl -0x2c(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x60f9f
movq -0x28(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0xa7c0
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0x60f8f
movq -0x28(%rbp), %rdi
callq 0xf940
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x60f71
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0xa7c0
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0xa7c0
movl -0x30(%rbp), %ecx
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x60f35
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
movslq -0x18(%rbp), %rsi
callq 0xa7c0
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movb $0x1, -0x11(%rbp)
jmp 0x60f9f
jmp 0x60f91
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x60ef2
testb $0x1, -0x11(%rbp)
jne 0x60fb9
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
callq 0x3e270
movl -0x38(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x60e00
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0xd(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0xf940
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x61098
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0xa7c0
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x61088
movb $0x1, -0xd(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
callq 0xf940
movq %rax, %rcx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jge 0x6107d
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0xa7c0
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x18(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0xa7c0
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x61030
movq -0x20(%rbp), %rdi
callq 0x60010
jmp 0x61098
jmp 0x6108a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x60ff2
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x610a7
jmp 0x610c6
leaq 0x26742(%rip), %rdi     # 0x877f0
leaq 0x26745(%rip), %rsi     # 0x877fa
movl $0x3c, %edx
leaq 0x26744(%rip), %rcx     # 0x87805
callq 0x4260
movq -0x20(%rbp), %rdi
callq 0x60e00
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Laakeri[P]maxpre/src/log.cpp
// Function: maxPreprocessor::LogT::LogT()
LogT::LogT() {
	rClauses = 0;
	rVariables = 0;
	rLiterals = 0;
	rLabels = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x62ad0
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x30(%rbp)
callq 0x62ad0
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x28(%rbp)
callq 0x62af0
movq -0x20(%rbp), %rdi
movabsq $0x41cdcd6500000000, %rax # imm = 0x41CDCD6500000000
movq %rax, 0x48(%rdi)
addq $0x68, %rdi
callq 0x60980
jmp 0x6121f
movq -0x38(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x40(%rbp)
callq 0x62b10
movq -0x38(%rbp), %rdi
addq $0x98, %rdi
movq %rdi, -0x48(%rbp)
callq 0x62b30
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rdi
movl $0x0, 0x60(%rax)
movl $0x1e, %esi
callq 0x62b50
jmp 0x6125f
movq -0x38(%rbp), %rdi
addq $0x98, %rdi
movl $0x1e, %esi
callq 0x62be0
jmp 0x61276
movq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x58(%rax)
movl $0x0, 0xb0(%rax)
movl $0x0, 0xb4(%rax)
movl $0x0, 0xb8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rax)
movq $0x0, 0xc0(%rax)
movq $0x0, 0xc8(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x612f0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xc340
movq -0x40(%rbp), %rdi
callq 0xc3a0
movq -0x28(%rbp), %rdi
callq 0xc400
movq -0x30(%rbp), %rdi
callq 0xc460
movq -0x20(%rbp), %rdi
callq 0xc460
movq -0x10(%rbp), %rdi
callq 0x4610
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x25e2b(%rip), %rsi     # 0x87aee
callq 0x4380
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0xb4(%rax), %esi
callq 0x4600
movq %rax, %rdi
movl $0xa, %esi
callq 0x4460
movq -0x10(%rbp), %rdi
leaq 0x25e0e(%rip), %rsi     # 0x87b00
callq 0x4380
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0xb0(%rax), %esi
callq 0x4600
movq %rax, %rdi
movl $0xa, %esi
callq 0x4460
movq -0x10(%rbp), %rdi
leaq 0x25df2(%rip), %rsi     # 0x87b13
callq 0x4380
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0xb8(%rax), %esi
callq 0x4600
movq %rax, %rdi
movl $0xa, %esi
callq 0x4460
movq -0x10(%rbp), %rdi
leaq 0x25dd9(%rip), %rsi     # 0x87b29
callq 0x4380
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0xc0(%rax), %rsi
callq 0x40c0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4460
movq -0x10(%rbp), %rdi
leaq 0x25dc2(%rip), %rsi     # 0x87b42
callq 0x4380
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rsi
callq 0x40c0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4460
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Laakeri[P]maxpre/src/log.cpp
// Function: maxPreprocessor::Log::charToTechnique(char)
Log::Technique Log::charToTechnique(char c) {
	if (c == 'b') return Technique::BCE;
	else if (c == 'u') return Technique::UP;
	else if (c == 'v') return Technique::BVE;
	else if (c == 's') return Technique::SE;
	else if (c == 'r') return Technique::SSR;
	else if (c == 'l') return Technique::SLE;
	else if (c == 'c') return Technique::BCR;
	else if (c == 'i') return Technique::SIE;
	else if (c == 'e') return Technique::EE;
	else if (c == 'a') return Technique::BVA;
	else if (c == 'g') return Technique::GSLE;
	else if (c == 'p') return Technique::FLP;
	else if (c == 'h') return Technique::UH;
	else if (c == 't') return Technique::LS;
	else {
		assert(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x62, %eax
jne 0x61e17
movl $0x1, -0x4(%rbp)
jmp 0x61f35
movsbl -0x11(%rbp), %eax
cmpl $0x75, %eax
jne 0x61e2c
movl $0x2, -0x4(%rbp)
jmp 0x61f35
movsbl -0x11(%rbp), %eax
cmpl $0x76, %eax
jne 0x61e41
movl $0x3, -0x4(%rbp)
jmp 0x61f35
movsbl -0x11(%rbp), %eax
cmpl $0x73, %eax
jne 0x61e56
movl $0x4, -0x4(%rbp)
jmp 0x61f35
movsbl -0x11(%rbp), %eax
cmpl $0x72, %eax
jne 0x61e6b
movl $0x5, -0x4(%rbp)
jmp 0x61f35
movsbl -0x11(%rbp), %eax
cmpl $0x6c, %eax
jne 0x61e80
movl $0x6, -0x4(%rbp)
jmp 0x61f35
movsbl -0x11(%rbp), %eax
cmpl $0x63, %eax
jne 0x61e95
movl $0x7, -0x4(%rbp)
jmp 0x61f35
movsbl -0x11(%rbp), %eax
cmpl $0x69, %eax
jne 0x61eaa
movl $0x8, -0x4(%rbp)
jmp 0x61f35
movsbl -0x11(%rbp), %eax
cmpl $0x65, %eax
jne 0x61ebc
movl $0x9, -0x4(%rbp)
jmp 0x61f35
movsbl -0x11(%rbp), %eax
cmpl $0x61, %eax
jne 0x61ece
movl $0xa, -0x4(%rbp)
jmp 0x61f35
movsbl -0x11(%rbp), %eax
cmpl $0x67, %eax
jne 0x61ee0
movl $0xb, -0x4(%rbp)
jmp 0x61f35
movsbl -0x11(%rbp), %eax
cmpl $0x70, %eax
jne 0x61ef2
movl $0xc, -0x4(%rbp)
jmp 0x61f35
movsbl -0x11(%rbp), %eax
cmpl $0x68, %eax
jne 0x61f04
movl $0xd, -0x4(%rbp)
jmp 0x61f35
movsbl -0x11(%rbp), %eax
cmpl $0x74, %eax
jne 0x61f16
movl $0xe, -0x4(%rbp)
jmp 0x61f35
leaq 0x25d05(%rip), %rdi     # 0x87c22
leaq 0x25977(%rip), %rsi     # 0x8789b
movl $0xa0, %edx
leaq 0x25c2f(%rip), %rcx     # 0x87b5f
callq 0x4260
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd 0x58(%rax), %xmm0
movsd 0x48(%rax), %xmm1
movsd 0x253f7(%rip), %xmm2    # 0x87870
divsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x6248c
movb $0x1, -0x1(%rbp)
jmp 0x625fd
movq -0x38(%rbp), %rax
movl 0x60(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x6249a
jmp 0x624b9
leaq 0x25437(%rip), %rdi     # 0x878d8
leaq 0x253f3(%rip), %rsi     # 0x8789b
movl $0xca, %edx
leaq 0x2572b(%rip), %rcx     # 0x87bdf
callq 0x4260
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
callq 0x62ef0
cmpq $0x0, %rax
je 0x624e0
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
callq 0x62f10
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x624ec
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x62610
movq -0x38(%rbp), %rdi
addq $0x68, %rdi
callq 0x60a80
movsd %xmm0, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xabd0
movq -0x38(%rbp), %rax
ucomisd 0x58(%rax), %xmm0
jbe 0x6251b
movb $0x0, -0x1(%rbp)
jmp 0x625fd
movq -0x38(%rbp), %rdi
addq $0x98, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x62c70
movq %rax, %rdi
callq 0x60a80
movsd %xmm0, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xabd0
movq -0x38(%rbp), %rdi
movsd %xmm0, -0x40(%rbp)
addq $0x18, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x62d40
movsd -0x40(%rbp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x62575
movb $0x1, -0x1(%rbp)
jmp 0x625fd
movq -0x38(%rbp), %rdi
movsd 0x50(%rdi), %xmm0
movsd %xmm0, -0x50(%rbp)
addq $0x18, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x62d40
movsd -0x50(%rbp), %xmm0
movq -0x38(%rbp), %rdi
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rdi)
addq $0x98, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x62c70
movq %rax, %rdi
callq 0x60a80
movsd %xmm0, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xabd0
movq -0x38(%rbp), %rdi
movsd %xmm0, -0x48(%rbp)
addq $0x18, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x62d40
movsd -0x48(%rbp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)