LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Laakeri[P]maxpre/src/AMSLEX.cpp
// Function: maxPreprocessor::AMSLEX::assumeSize(unsigned int)
void AMSLEX::assumeSize(unsigned size) {
	if (dataSize < size) {
		unsigned newSize = max(2 * dataSize, size);
		data = (int*)realloc(data, newSize * sizeof(int));
		dataSize = newSize;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x60(%rax), %eax
cmpl -0xc(%rbp), %eax
jae 0x677f7
movq -0x20(%rbp), %rax
movl 0x60(%rax), %eax
shll %eax
movl %eax, -0x14(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x6f0e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x10(%rbp)
movq 0x58(%rax), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
shlq $0x2, %rsi
callq 0x45d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x58(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x60(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Laakeri[P]maxpre/src/AMSLEX.cpp
// Function: maxPreprocessor::AMSLEX::amsLexSE(std::vector<int, std::allocator<int>> const&)
vector<int> AMSLEX::amsLexSE(const vector<int>& clauses) {
	if (clauses.size() <= 700) {
		return amsLexSENonPerm(clauses);
	}
	else {
		return amsLexSEPerm(clauses);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf940
cmpq $0x2bc, %rax            # imm = 0x2BC
ja 0x69c3b
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
callq 0x683f0
jmp 0x69c4c
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
callq 0x689c0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]maxpre/src/touchedlist.cpp
// Function: maxPreprocessor::TouchedList::init(int)
void TouchedList::init(int vars_) {
	vars = vars_;
	itr = 1;
	frontItr = 1;
	getItr = 1;
	touchedLiterals.clear();
	modLiterals.clear();
	touchedClauses.clear();
	modClauses.clear();
	techniqueItr.clear();
	getI.resize(vars*2);
	for (int i = 0; i < (int)getI.size(); i++) {
		getI[i] = 0;
	}
}

// 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)
movl -0xc(%rbp), %eax
movl %eax, 0x19c(%rdi)
movq $0x1, 0x188(%rdi)
movq $0x1, 0x190(%rdi)
movl $0x1, 0x198(%rdi)
callq 0x740a0
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0x740a0
movq -0x18(%rbp), %rdi
addq $0xa0, %rdi
callq 0x740a0
movq -0x18(%rbp), %rdi
addq $0xf0, %rdi
callq 0x740a0
movq -0x18(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x740e0
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x170, %rdi            # imm = 0x170
movl 0x19c(%rax), %eax
shll %eax
movslq %eax, %rsi
callq 0xa990
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
addq $0x170, %rdi            # imm = 0x170
callq 0xf940
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x7227c
movq -0x18(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
movslq -0x10(%rbp), %rsi
callq 0xa7c0
movl $0x0, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x72237
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]maxpre/src/touchedlist.cpp
// Function: maxPreprocessor::TouchedList::getModLiterals(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<int> TouchedList::getModLiterals(string technique) {
	if (techniqueItr.count(technique) == 0) {
		techniqueItr[technique] = itr;
		vector<int> ret(2*vars);
		for (int i = 0; i < 2*vars; i++) {
			ret[i] = i;
		}
		return ret;
	}
	else {
		getItr++;
		uint64_t eitr = techniqueItr[technique];
		techniqueItr[technique] = itr;
		vector<int> ret;
		getModLiteralsCh(eitr, ret);
		return ret;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x60(%rbp)
movq %rsi, %rax
movq -0x60(%rbp), %rsi
movq %rdi, -0x58(%rbp)
movq %rdi, %rcx
movq %rcx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x140, %rdi            # imm = 0x140
callq 0x743e0
cmpq $0x0, %rax
jne 0x73252
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq 0x188(%rdi), %rax
movq %rax, -0x78(%rbp)
addq $0x140, %rdi            # imm = 0x140
callq 0x74440
movq -0x78(%rbp), %rdx
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rdx, (%rcx)
movb $0x0, -0x19(%rbp)
movl 0x19c(%rax), %eax
addl %eax, %eax
cltq
movq %rax, -0x70(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xa710
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0xa730
jmp 0x731da
leaq -0x1a(%rbp), %rdi
callq 0xa7a0
movl $0x0, -0x30(%rbp)
movq -0x48(%rbp), %rcx
movl -0x30(%rbp), %eax
movl 0x19c(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x7323a
movq -0x58(%rbp), %rdi
movl -0x30(%rbp), %eax
movl %eax, -0x7c(%rbp)
movslq -0x30(%rbp), %rsi
callq 0xa7c0
movl -0x7c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x731ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0xa7a0
jmp 0x7330c
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x7324d
movq -0x58(%rbp), %rdi
callq 0xab00
jmp 0x732ff
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl 0x198(%rdi), %eax
incl %eax
movl %eax, 0x198(%rdi)
addq $0x140, %rdi            # imm = 0x140
movq %rdi, -0x90(%rbp)
callq 0x74440
movq -0x90(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x38(%rbp)
movq 0x188(%rax), %rax
movq %rax, -0x88(%rbp)
callq 0x74440
movq -0x88(%rbp), %rcx
movq -0x58(%rbp), %rdi
movq %rcx, (%rax)
movb $0x0, -0x39(%rbp)
callq 0xa7e0
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rdx
movq -0x38(%rbp), %rsi
callq 0x72990
jmp 0x732d1
movb $0x1, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x732fd
jmp 0x732f4
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xab00
jmp 0x7330c
movq -0x58(%rbp), %rdi
callq 0xab00
jmp 0x732ff
movq -0x50(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4610
nopw %cs:(%rax,%rax)
// File: Laakeri[P]maxpre/src/touchedlist.cpp
// Function: maxPreprocessor::TouchedList::getModVariables(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<int> TouchedList::getModVariables(string technique) {
	if (techniqueItr.count(technique) == 0) {
		techniqueItr[technique] = itr;
		vector<int> ret(vars);
		for (int i = 0; i < vars; i++) {
			ret[i] = i;
		}
		return ret;
	}
	else {
		getItr++;
		uint64_t eitr = techniqueItr[technique];
		techniqueItr[technique] = itr;
		vector<int> ret;
		getModVarsCh(eitr, ret);
		return ret;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x60(%rbp)
movq %rsi, %rax
movq -0x60(%rbp), %rsi
movq %rdi, -0x58(%rbp)
movq %rdi, %rcx
movq %rcx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x140, %rdi            # imm = 0x140
callq 0x743e0
cmpq $0x0, %rax
jne 0x7343b
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq 0x188(%rdi), %rax
movq %rax, -0x78(%rbp)
addq $0x140, %rdi            # imm = 0x140
callq 0x74440
movq -0x78(%rbp), %rdx
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rdx, (%rcx)
movb $0x0, -0x19(%rbp)
movslq 0x19c(%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xa710
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0xa730
jmp 0x733c7
leaq -0x1a(%rbp), %rdi
callq 0xa7a0
movl $0x0, -0x30(%rbp)
movq -0x48(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl 0x19c(%rcx), %eax
jge 0x73423
movq -0x58(%rbp), %rdi
movl -0x30(%rbp), %eax
movl %eax, -0x7c(%rbp)
movslq -0x30(%rbp), %rsi
callq 0xa7c0
movl -0x7c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x733d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0xa7a0
jmp 0x734f5
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x73436
movq -0x58(%rbp), %rdi
callq 0xab00
jmp 0x734e8
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl 0x198(%rdi), %eax
incl %eax
movl %eax, 0x198(%rdi)
addq $0x140, %rdi            # imm = 0x140
movq %rdi, -0x90(%rbp)
callq 0x74440
movq -0x90(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x38(%rbp)
movq 0x188(%rax), %rax
movq %rax, -0x88(%rbp)
callq 0x74440
movq -0x88(%rbp), %rcx
movq -0x58(%rbp), %rdi
movq %rcx, (%rax)
movb $0x0, -0x39(%rbp)
callq 0xa7e0
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rdx
movq -0x38(%rbp), %rsi
callq 0x72e80
jmp 0x734ba
movb $0x1, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x734e6
jmp 0x734dd
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xab00
jmp 0x734f5
movq -0x58(%rbp), %rdi
callq 0xab00
jmp 0x734e8
movq -0x50(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4610
nop
// File: Laakeri[P]maxpre/src/touchedlist.cpp
// Function: maxPreprocessor::TouchedList::getTouchedLiterals(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<int> TouchedList::getTouchedLiterals(string technique) {
	if (techniqueItr.count(technique) == 0) {
		techniqueItr[technique] = itr;
		vector<int> ret(2*vars);
		for (int i = 0; i < 2*vars; i++) {
			ret[i] = i;
		}
		return ret;
	}
	else {
		getItr++;
		uint64_t eitr = techniqueItr[technique];
		techniqueItr[technique] = itr;
		vector<int> ret;
		getModLiteralsCh(eitr, ret);
		getTouchedLiteralsCh(eitr, ret);
		return ret;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x60(%rbp)
movq %rsi, %rax
movq -0x60(%rbp), %rsi
movq %rdi, -0x58(%rbp)
movq %rdi, %rcx
movq %rcx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x140, %rdi            # imm = 0x140
callq 0x743e0
cmpq $0x0, %rax
jne 0x73622
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq 0x188(%rdi), %rax
movq %rax, -0x78(%rbp)
addq $0x140, %rdi            # imm = 0x140
callq 0x74440
movq -0x78(%rbp), %rdx
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rdx, (%rcx)
movb $0x0, -0x19(%rbp)
movl 0x19c(%rax), %eax
addl %eax, %eax
cltq
movq %rax, -0x70(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xa710
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0xa730
jmp 0x735aa
leaq -0x1a(%rbp), %rdi
callq 0xa7a0
movl $0x0, -0x30(%rbp)
movq -0x48(%rbp), %rcx
movl -0x30(%rbp), %eax
movl 0x19c(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x7360a
movq -0x58(%rbp), %rdi
movl -0x30(%rbp), %eax
movl %eax, -0x7c(%rbp)
movslq -0x30(%rbp), %rsi
callq 0xa7c0
movl -0x7c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x735ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0xa7a0
jmp 0x736ef
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x7361d
movq -0x58(%rbp), %rdi
callq 0xab00
jmp 0x736e2
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl 0x198(%rdi), %eax
incl %eax
movl %eax, 0x198(%rdi)
addq $0x140, %rdi            # imm = 0x140
movq %rdi, -0x90(%rbp)
callq 0x74440
movq -0x90(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x38(%rbp)
movq 0x188(%rax), %rax
movq %rax, -0x88(%rbp)
callq 0x74440
movq -0x88(%rbp), %rcx
movq -0x58(%rbp), %rdi
movq %rcx, (%rax)
movb $0x0, -0x39(%rbp)
callq 0xa7e0
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rdx
movq -0x38(%rbp), %rsi
callq 0x72990
jmp 0x736a1
movq -0x58(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x72750
jmp 0x736b4
movb $0x1, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x736e0
jmp 0x736d7
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xab00
jmp 0x736ef
movq -0x58(%rbp), %rdi
callq 0xab00
jmp 0x736e2
movq -0x50(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4610
nopl (%rax,%rax)
// File: Laakeri[P]maxpre/src/touchedlist.cpp
// Function: maxPreprocessor::TouchedList::getTouchedVariables(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<int> TouchedList::getTouchedVariables(string technique) {
	if (techniqueItr.count(technique) == 0) {
		techniqueItr[technique] = itr;
		vector<int> ret(vars);
		for (int i = 0; i < vars; i++) {
			ret[i] = i;
		}
		return ret;
	}
	else {
		getItr++;
		uint64_t eitr = techniqueItr[technique];
		techniqueItr[technique] = itr;
		vector<int> ret;
		getModVarsCh(eitr, ret);
		getTouchedVarsCh(eitr, ret);
		return ret;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x60(%rbp)
movq %rsi, %rax
movq -0x60(%rbp), %rsi
movq %rdi, -0x58(%rbp)
movq %rdi, %rcx
movq %rcx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x140, %rdi            # imm = 0x140
callq 0x743e0
cmpq $0x0, %rax
jne 0x7381b
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq 0x188(%rdi), %rax
movq %rax, -0x78(%rbp)
addq $0x140, %rdi            # imm = 0x140
callq 0x74440
movq -0x78(%rbp), %rdx
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rdx, (%rcx)
movb $0x0, -0x19(%rbp)
movslq 0x19c(%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xa710
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0xa730
jmp 0x737a7
leaq -0x1a(%rbp), %rdi
callq 0xa7a0
movl $0x0, -0x30(%rbp)
movq -0x48(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl 0x19c(%rcx), %eax
jge 0x73803
movq -0x58(%rbp), %rdi
movl -0x30(%rbp), %eax
movl %eax, -0x7c(%rbp)
movslq -0x30(%rbp), %rsi
callq 0xa7c0
movl -0x7c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x737b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0xa7a0
jmp 0x738e8
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x73816
movq -0x58(%rbp), %rdi
callq 0xab00
jmp 0x738db
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl 0x198(%rdi), %eax
incl %eax
movl %eax, 0x198(%rdi)
addq $0x140, %rdi            # imm = 0x140
movq %rdi, -0x90(%rbp)
callq 0x74440
movq -0x90(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x38(%rbp)
movq 0x188(%rax), %rax
movq %rax, -0x88(%rbp)
callq 0x74440
movq -0x88(%rbp), %rcx
movq -0x58(%rbp), %rdi
movq %rcx, (%rax)
movb $0x0, -0x39(%rbp)
callq 0xa7e0
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rdx
movq -0x38(%rbp), %rsi
callq 0x72e80
jmp 0x7389a
movq -0x58(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x72be0
jmp 0x738ad
movb $0x1, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x738d9
jmp 0x738d0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xab00
jmp 0x738e8
movq -0x58(%rbp), %rdi
callq 0xab00
jmp 0x738db
movq -0x50(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4610
nopw %cs:(%rax,%rax)
// File: Laakeri[P]maxpre/src/preprocessorinterface.cpp
// Function: maxPreprocessor::PreprocessorInterface::preprocess(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, double)
void PreprocessorInterface::preprocess(string techniques, int logLevel, double timeLimit) {
		preprocessor.logLevel = logLevel;
		preprocessor.printComments = false;
		preprocessor.skipTechnique = skipTechnique;

    preprocessor.BVEsortMaxFirst = BVEsortMaxFirst;
    preprocessor.BVElocalGrow = BVElocalGrow;
    preprocessor.BVEglobalGrow = BVEglobalGrow;
		
		preprocessor.preprocess(techniques, timeLimit, false, useBVEGateExtraction, !preprocessed, useLabelMatching);
		preprocessed = true;
		variables = max(variables, preprocessor.pi.vars);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x14(%rbp), %ecx
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x60(%rbp)
movl %ecx, 0x2f0(%rax)
movb $0x0, 0x2f4(%rax)
movl 0x1854(%rax), %ecx
movl %ecx, 0x470(%rax)
movb 0x1858(%rax), %cl
andb $0x1, %cl
movb %cl, 0x3a9(%rax)
movl 0x185c(%rax), %ecx
movl %ecx, 0x3ac(%rax)
movl 0x1860(%rax), %ecx
movl %ecx, 0x3b0(%rax)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x4190
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movsd -0x20(%rbp), %xmm0
movb 0x1851(%rcx), %al
notb %al
movzbl 0x1853(%rcx), %r9d
movzbl 0x1852(%rcx), %ecx
andl $0x1, %ecx
andl $0x1, %r9d
movzbl %al, %r8d
andl $0x1, %r8d
xorl %edx, %edx
callq 0x2f0b0
jmp 0x779fb
leaq -0x40(%rbp), %rdi
callq 0x4240
movq -0x68(%rbp), %rdi
movb $0x1, 0x1851(%rdi)
movq %rdi, %rsi
addq $0x8, %rsi
addq $0x60, %rsi
callq 0x3e430
movq %rax, %rcx
movq -0x68(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, (%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4240
movq -0x48(%rbp), %rdi
callq 0x4610
nop
// File: Laakeri[P]maxpre/src/preprocessorinterface.cpp
// Function: maxPreprocessor::PreprocessorInterface::litToSolver(int)
int PreprocessorInterface::litToSolver(int lit) {
		if (PPVarToSolverVar.size() < abs(lit)) PPVarToSolverVar.resize(abs(lit));
		if (PPVarToSolverVar[abs(lit)-1] == 0) {
			PPVarToSolverVar[abs(lit)-1] = solverVarToPPVar.size() + 1;
			solverVarToPPVar.push_back(abs(lit));
		}
		if (lit > 0) return PPVarToSolverVar[abs(lit)-1];
		else return -PPVarToSolverVar[abs(lit)-1];
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x1880, %rdi           # imm = 0x1880
callq 0xf940
movl -0x14(%rbp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jae 0x77da2
movq -0x20(%rbp), %rdi
addq $0x1880, %rdi           # imm = 0x1880
movl -0x14(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movslq %eax, %rsi
callq 0xa990
movq -0x20(%rbp), %rdi
addq $0x1880, %rdi           # imm = 0x1880
movl -0x14(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0xa7c0
cmpl $0x0, (%rax)
jne 0x77e24
movq -0x20(%rbp), %rdi
addq $0x1868, %rdi           # imm = 0x1868
callq 0xf940
movq -0x20(%rbp), %rdi
addq $0x1, %rax
movl %eax, -0x24(%rbp)
addq $0x1880, %rdi           # imm = 0x1880
movl -0x14(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0xa7c0
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rdi
movl %ecx, (%rax)
addq $0x1868, %rdi           # imm = 0x1868
movl -0x14(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x3c850
cmpl $0x0, -0x14(%rbp)
jle 0x77e51
movq -0x20(%rbp), %rdi
addq $0x1880, %rdi           # imm = 0x1880
movl -0x14(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0xa7c0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x77e7b
movq -0x20(%rbp), %rdi
addq $0x1880, %rdi           # imm = 0x1880
movl -0x14(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0xa7c0
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]maxpre/src/preprocessorinterface.cpp
// Function: maxPreprocessor::PreprocessorInterface::reconstruct(std::vector<int, std::allocator<int>> const&)
vector<int> PreprocessorInterface::reconstruct(const vector<int>& trueLiterals) {
		vector<int> ppTrueLiterals;
		for (int lit : trueLiterals) {
			lit = litToPP(lit);
			if (lit == 0) continue;
			ppTrueLiterals.push_back(lit);
		}
		return preprocessor.trace.getSolution(ppTrueLiterals, 0, variables, originalVariables).F;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa7e0
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3d080
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3d0b0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3d0e0
testb $0x1, %al
jne 0x77f01
jmp 0x77f6a
leaq -0x40(%rbp), %rdi
callq 0x3d120
movq -0x88(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %esi
callq 0x77fd0
movl %eax, -0x9c(%rbp)
jmp 0x77f26
movl -0x9c(%rbp), %eax
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jne 0x77f4e
jmp 0x77f5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xab00
jmp 0x77fc7
leaq -0x30(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0xa8c0
jmp 0x77f5d
jmp 0x77f5f
leaq -0x40(%rbp), %rdi
callq 0x3d160
jmp 0x77eee
movq -0x88(%rbp), %rax
movq %rax, %rsi
addq $0x2f8, %rsi            # imm = 0x2F8
movl (%rax), %r8d
movl 0x4(%rax), %r9d
xorl %eax, %eax
movl %eax, %ecx
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x5cb20
jmp 0x77f95
movq -0x98(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x10650
leaq -0x80(%rbp), %rdi
callq 0x5ea90
leaq -0x30(%rbp), %rdi
callq 0xab00
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x4610
// File: Laakeri[P]maxpre/src/preprocessorinterface.cpp
// Function: maxPreprocessor::PreprocessorInterface::printSolution(std::vector<int, std::allocator<int>> const&, std::ostream&, unsigned long)
void PreprocessorInterface::printSolution(const vector<int>& trueLiterals, ostream& output, uint64_t ansWeight) {
		vector<int> ppTrueLiterals;
		for (int lit : trueLiterals) {
			lit = litToPP(lit);
			if (lit == 0) continue;
			ppTrueLiterals.push_back(lit);
		}
		preprocessor.trace.printSolution(output, ppTrueLiterals, ansWeight, variables, originalVariables);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa7e0
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3d080
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3d0b0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3d0e0
testb $0x1, %al
jne 0x780d1
jmp 0x78131
leaq -0x48(%rbp), %rdi
callq 0x3d120
movq -0x70(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %esi
callq 0x77fd0
movl %eax, -0x74(%rbp)
jmp 0x780f0
movl -0x74(%rbp), %eax
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jne 0x78115
jmp 0x78126
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xab00
jmp 0x7816b
leaq -0x38(%rbp), %rdi
leaq -0x54(%rbp), %rsi
callq 0xa8c0
jmp 0x78124
jmp 0x78126
leaq -0x48(%rbp), %rdi
callq 0x3d160
jmp 0x780be
movq -0x70(%rbp), %rax
movq %rax, %rdi
addq $0x2f8, %rdi            # imm = 0x2F8
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl (%rax), %r8d
movl 0x4(%rax), %r9d
leaq -0x38(%rbp), %rdx
callq 0x5e800
jmp 0x78159
leaq -0x38(%rbp), %rdi
callq 0xab00
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x4610
nopw %cs:(%rax,%rax)
// File: Laakeri[P]maxpre/src/preprocessorinterface.cpp
// Function: maxPreprocessor::PreprocessorInterface::addVar(int)
int PreprocessorInterface::addVar(int var) {
		if (!inProcessMode) return 0;
		assert(var >= 0);
		if (var == 0) {
			var = solverVarToPPVar.size() + 1;
		}
		if (var > (int)solverVarToPPVar.size()) {
			solverVarToPPVar.resize(var);
		}
		if (solverVarToPPVar[var-1] != 0) return 0;
		int nv = preprocessor.pi.addVar()+1;
		solverVarToPPVar[var-1] = nv;
		assert((int)PPVarToSolverVar.size() < nv);
		PPVarToSolverVar.resize(nv);
		PPVarToSolverVar[nv-1] = var;
		return var;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x1850(%rax)
jne 0x781cc
movl $0x0, -0x4(%rbp)
jmp 0x78319
cmpl $0x0, -0x14(%rbp)
jl 0x781d4
jmp 0x781f3
leaq 0xfae8(%rip), %rdi      # 0x87cc3
leaq 0xfa42(%rip), %rsi      # 0x87c24
movl $0x70, %edx
leaq 0xfade(%rip), %rcx      # 0x87ccc
callq 0x4260
cmpl $0x0, -0x14(%rbp)
jne 0x78210
movq -0x20(%rbp), %rdi
addq $0x1868, %rdi           # imm = 0x1868
callq 0xf940
addq $0x1, %rax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
addq $0x1868, %rdi           # imm = 0x1868
callq 0xf940
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jle 0x78244
movq -0x20(%rbp), %rdi
addq $0x1868, %rdi           # imm = 0x1868
movslq -0x14(%rbp), %rsi
callq 0xa990
movq -0x20(%rbp), %rdi
addq $0x1868, %rdi           # imm = 0x1868
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0xa7c0
cmpl $0x0, (%rax)
je 0x7826e
movl $0x0, -0x4(%rbp)
jmp 0x78319
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x5f970
movq -0x20(%rbp), %rdi
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
addq $0x1868, %rdi           # imm = 0x1868
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0xa7c0
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rdi
movl %ecx, (%rax)
addq $0x1880, %rdi           # imm = 0x1880
callq 0xf940
cmpl -0x18(%rbp), %eax
jge 0x782bc
jmp 0x782db
leaq 0xfa41(%rip), %rdi      # 0x87d04
leaq 0xf95a(%rip), %rsi      # 0x87c24
movl $0x7a, %edx
leaq 0xf9f6(%rip), %rcx      # 0x87ccc
callq 0x4260
movq -0x20(%rbp), %rdi
addq $0x1880, %rdi           # imm = 0x1880
movslq -0x18(%rbp), %rsi
callq 0xa990
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x1880, %rdi           # imm = 0x1880
movl -0x18(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0xa7c0
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]maxpre/src/preprocessorinterface.cpp
// Function: maxPreprocessor::PreprocessorInterface::addLabel(int, unsigned long)
int PreprocessorInterface::addLabel(int lbl, uint64_t weight) {
		if (!inProcessMode) return 0;
		lbl = addVar(lbl);
		if (lbl == 0) return 0;
		if (weight >= topWeight) weight = HARDWEIGHT;
		int iVar = solverVarToPPVar[lbl-1]-1;
		preprocessor.pi.addClause({negLit(iVar)}, weight);
		preprocessor.pi.isLabel[iVar] = VAR_FALSE;
		return lbl;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
testb $0x1, 0x1850(%rax)
jne 0x78363
movl $0x0, -0x4(%rbp)
jmp 0x78486
movq -0x70(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x781a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x78384
movl $0x0, -0x4(%rbp)
jmp 0x78486
movq -0x70(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x1848(%rcx), %rax
jb 0x783a3
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, -0x20(%rbp)
movq -0x70(%rbp), %rdi
addq $0x1868, %rdi           # imm = 0x1868
movl -0x14(%rbp), %eax
decl %eax
movslq %eax, %rsi
callq 0xa7c0
movq %rax, %rcx
movq -0x70(%rbp), %rax
movl (%rcx), %ecx
decl %ecx
movl %ecx, -0x24(%rbp)
addq $0x8, %rax
movq %rax, -0x80(%rbp)
movl -0x24(%rbp), %edi
callq 0x3c5e0
movl %eax, -0x54(%rbp)
leaq -0x54(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x1, -0x48(%rbp)
leaq -0x55(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xa710
movq -0x78(%rbp), %rcx
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x3c9b0
jmp 0x78410
movq -0x80(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rsi
callq 0x5f880
jmp 0x78423
leaq -0x40(%rbp), %rdi
callq 0xab00
leaq -0x55(%rbp), %rdi
callq 0xa7a0
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
addq $0x48, %rdi
movslq -0x24(%rbp), %rsi
callq 0xa7c0
movl $0x2, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x78486
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x7847b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xab00
leaq -0x55(%rbp), %rdi
callq 0xa7a0
jmp 0x78492
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x4610
nopl (%rax,%rax)
// File: Laakeri[P]maxpre/src/cardinalityconstraint.cpp
// Function: maxPreprocessor::CardinalityConstraint::getLessNetwork(int, std::vector<int, std::allocator<int>>)
pair<CardinalityConstraint::Formula, int> CardinalityConstraint::getLessNetwork(int freeVar, vector<int> input) {
	int k = 1;
	while (k <= K) k *= 2;
	Formula F(freeVar);
	while ((int)input.size()%k != 0) {
		F.clauses.push_back({-F.freeVar});
		input.push_back(F.freeVar++);
	}
	vector<int> output = Card(input, 0, (int)input.size()-1, k, F, true, iff);
	return {F, -output[K]};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rcx, -0xc8(%rbp)
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x1, -0x24(%rbp)
movq -0xb0(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x38(%rcx), %eax
jg 0x7e0dd
movl -0x24(%rbp), %eax
shll %eax
movl %eax, -0x24(%rbp)
jmp 0x7e0c4
movl -0x14(%rbp), %esi
leaq -0x48(%rbp), %rdi
callq 0x7b6b0
movq -0xc8(%rbp), %rdi
callq 0xf940
cltd
idivl -0x24(%rbp)
cmpl $0x0, %edx
je 0x7e1e8
leaq -0x48(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl -0x30(%rbp), %eax
negl %eax
movl %eax, -0x74(%rbp)
leaq -0x74(%rbp), %rax
movq %rax, -0x70(%rbp)
movq $0x1, -0x68(%rbp)
leaq -0x75(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xa710
movq -0xd0(%rbp), %rcx
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x3c9b0
jmp 0x7e14f
movq -0xd8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3e200
jmp 0x7e161
leaq -0x60(%rbp), %rdi
callq 0xab00
leaq -0x75(%rbp), %rdi
callq 0xa7a0
movq -0xc8(%rbp), %rdi
movl -0x30(%rbp), %eax
movl %eax, %ecx
incl %ecx
movl %ecx, -0x30(%rbp)
movl %eax, -0x88(%rbp)
leaq -0x88(%rbp), %rsi
callq 0x3c850
jmp 0x7e198
jmp 0x7e0e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x7e1c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xab00
leaq -0x75(%rbp), %rdi
callq 0xa7a0
jmp 0x7e2b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x7e2b1
movq -0xc8(%rbp), %rdi
callq 0xf940
movq -0xb0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movl %eax, %r8d
decl %r8d
movl -0x24(%rbp), %r9d
movzbl 0x58(%rsi), %ecx
andl $0x1, %ecx
movq %rsp, %rax
movl %ecx, 0x10(%rax)
leaq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movl $0x1, 0x8(%rax)
leaq -0xa0(%rbp), %rdi
xorl %ecx, %ecx
callq 0x7de10
jmp 0x7e237
movq -0xb0(%rbp), %rax
movslq 0x38(%rax), %rsi
leaq -0xa0(%rbp), %rdi
callq 0xa7c0
movq -0xc0(%rbp), %rdi
movl (%rax), %eax
negl %eax
movl %eax, -0xa4(%rbp)
leaq -0x48(%rbp), %rsi
leaq -0xa4(%rbp), %rdx
callq 0x84040
jmp 0x7e271
leaq -0xa0(%rbp), %rdi
callq 0xab00
leaq -0x48(%rbp), %rdi
callq 0x84080
movq -0xb8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xab00
leaq -0x48(%rbp), %rdi
callq 0x84080
movq -0x80(%rbp), %rdi
callq 0x4610
nopw %cs:(%rax,%rax)
// File: Laakeri[P]maxpre/src/cardinalityconstraint.cpp
// Function: maxPreprocessor::CardinalityConstraint::getBestLessNetwork(int, std::vector<int, std::allocator<int>>)
pair<CardinalityConstraint::Formula, int> CardinalityConstraint::getBestLessNetwork(int freeVar, vector<int> input) {
	auto cLess = getLessNetwork(freeVar, input);
	auto cGreater = getGreaterNetwork(freeVar, input);
	if (cLess.F.size() <= cGreater.F.size()) {
		return cLess;
	}
	else {
		return cGreater;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rcx, -0xe8(%rbp)
movq %rsi, %rax
movq -0xe8(%rbp), %rsi
movq %rdi, -0xe0(%rbp)
movq %rdi, %rcx
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xc4(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3edb0
movq -0xd0(%rbp), %rsi
movl -0xc4(%rbp), %edx
movq -0xc0(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0x7e080
jmp 0x7f25f
leaq -0x60(%rbp), %rdi
callq 0xab00
movq -0xe8(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, -0xec(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3edb0
jmp 0x7f286
movl -0xec(%rbp), %edx
movq -0xd0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
leaq -0xb0(%rbp), %rcx
callq 0x7e2d0
jmp 0x7f2a8
leaq -0xb0(%rbp), %rdi
callq 0xab00
leaq -0x48(%rbp), %rdi
callq 0x7b6e0
movq %rax, -0xf8(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x7b6e0
movq %rax, %rcx
movq -0xf8(%rbp), %rax
cmpq %rcx, %rax
ja 0x7f33a
movq -0xe0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x840e0
movl $0x1, -0xb4(%rbp)
jmp 0x7f357
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xab00
jmp 0x7f385
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x7f37c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xab00
jmp 0x7f37c
movq -0xe0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x840e0
movl $0x1, -0xb4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x84120
leaq -0x48(%rbp), %rdi
callq 0x84120
movq -0xd8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x84120
movq -0x68(%rbp), %rdi
callq 0x4610
nop
// File: attractivechaos[P]udb2/tsl_robin_map/./robin_growth_policy.h
// Function: tsl::rh::power_of_two_growth_policy<2ul>::power_of_two_growth_policy(unsigned long&)
explicit power_of_two_growth_policy(std::size_t& min_bucket_count_in_out) {
        if(min_bucket_count_in_out > max_bucket_count()) {
            TSL_RH_THROW_OR_TERMINATE(std::length_error, "The hash table exceeds its maxmimum size.");
        }
        
        if(min_bucket_count_in_out > 0) {
            min_bucket_count_in_out = round_up_to_power_of_two(min_bucket_count_in_out);
            m_mask = min_bucket_count_in_out - 1;
        }
        else {
            m_mask = 0;
        }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x2350
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jbe 0x1fa9
movl $0x10, %edi
callq 0x1080
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x315c(%rip), %rsi      # 0x50ce
callq 0x1120
jmp 0x1f79
movq (%rsp), %rdi
movq 0x605c(%rip), %rsi      # 0x7fe0
movq 0x6045(%rip), %rdx      # 0x7fd0
callq 0x1180
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x10d0
jmp 0x1ff3
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
jbe 0x1fe2
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x2370
movq %rax, %rdx
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rdx, (%rcx)
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x1fee
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x1190
nopl (%rax)
// File: attractivechaos[P]udb2/tsl_robin_map/./robin_hash.h
// Function: tsl::detail_robin_hash::robin_hash<std::pair<unsigned int, unsigned int>, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::rehash_on_extreme_load()
bool rehash_on_extreme_load() {
        if(m_grow_on_next_insert || size() >= m_load_threshold) {
            rehash_impl(GrowthPolicy::next_bucket_count());
            m_grow_on_next_insert = false;
            
            return true;
        }
        
        if(m_try_skrink_on_next_insert) {
            m_try_skrink_on_next_insert = false;
            if(m_min_load_factor != 0.0f && load_factor() < m_min_load_factor) {
                reserve(size() + 1);
                
                return true;
            }
        }
        
        return false;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x44(%rax)
jne 0x35cb
movq (%rsp), %rdi
callq 0x37b0
movq (%rsp), %rcx
cmpq 0x38(%rcx), %rax
jb 0x35ef
movq (%rsp), %rdi
callq 0x3a20
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x37c0
movq (%rsp), %rax
movb $0x0, 0x44(%rax)
movb $0x1, 0x17(%rsp)
jmp 0x3653
movq (%rsp), %rax
testb $0x1, 0x4c(%rax)
je 0x364e
movq (%rsp), %rax
movb $0x0, 0x4c(%rax)
movss 0x48(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3612
jp 0x3612
jmp 0x364c
movq (%rsp), %rdi
callq 0x3ad0
movq (%rsp), %rax
movaps %xmm0, %xmm1
movss 0x48(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x364c
movq (%rsp), %rdi
callq 0x37b0
movq (%rsp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x3bb0
movb $0x1, 0x17(%rsp)
jmp 0x3653
jmp 0x364e
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: attractivechaos[P]udb2/tsl_robin_map/./robin_hash.h
// Function: tsl::detail_robin_hash::robin_hash<std::pair<unsigned int, unsigned int>, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::insert_value_on_rehash(unsigned long, short, unsigned int, std::pair<unsigned int, unsigned int>&&)
void insert_value_on_rehash(std::size_t ibucket, distance_type dist_from_ideal_bucket, 
                                truncated_hash_type hash, value_type&& value) 
    {
        while(true) {
            if(dist_from_ideal_bucket > m_buckets[ibucket].dist_from_ideal_bucket()) {
                if(m_buckets[ibucket].empty()) {
                    m_buckets[ibucket].set_value_of_empty_bucket(dist_from_ideal_bucket, hash, std::move(value));
                    return;
                }
                else {
                    m_buckets[ibucket].swap_with_value_in_bucket(dist_from_ideal_bucket, hash, value);
                }
            }
            
            dist_from_ideal_bucket++;
            ibucket = next_bucket(ibucket);
        }
    }

// Assembly:
subq $0x38, %rsp
movw %dx, %ax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movw %ax, 0x26(%rsp)
movl %ecx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movswl 0x26(%rsp), %ecx
movl %ecx, 0xc(%rsp)
movq 0x20(%rax), %rdi
imulq $0xc, 0x28(%rsp), %rax
addq %rax, %rdi
callq 0x34f0
movw %ax, %cx
movl 0xc(%rsp), %eax
movswl %cx, %ecx
cmpl %ecx, %eax
jle 0x3e19
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
imulq $0xc, 0x28(%rsp), %rax
addq %rax, %rdi
callq 0x1bb0
testb $0x1, %al
jne 0x3dc4
jmp 0x3df1
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
imulq $0xc, 0x28(%rsp), %rax
addq %rax, %rdi
movw 0x26(%rsp), %ax
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
movswl %ax, %esi
callq 0x3660
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
imulq $0xc, 0x28(%rsp), %rax
addq %rax, %rdi
movq 0x18(%rsp), %rcx
leaq 0x26(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x4010
jmp 0x3e19
movq 0x10(%rsp), %rdi
movw 0x26(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x26(%rsp)
movq 0x28(%rsp), %rsi
callq 0x3580
movq %rax, 0x28(%rsp)
jmp 0x3d79
// File: attractivechaos[P]udb2/tsl_robin_map/./robin_hash.h
// Function: tsl::detail_robin_hash::robin_hash<std::pair<unsigned int, unsigned int>, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::swap(tsl::detail_robin_hash::robin_hash<std::pair<unsigned int, unsigned int>, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>&)
void swap(robin_hash& other) {
        using std::swap;
        
        swap(static_cast<Hash&>(*this), static_cast<Hash&>(other));
        swap(static_cast<KeyEqual&>(*this), static_cast<KeyEqual&>(other));
        swap(static_cast<GrowthPolicy&>(*this), static_cast<GrowthPolicy&>(other));
        swap(m_buckets_data, other.m_buckets_data);
        swap(m_buckets, other.m_buckets);
        swap(m_bucket_count, other.m_bucket_count);
        swap(m_nb_elements, other.m_nb_elements);
        swap(m_load_threshold, other.m_load_threshold);
        swap(m_max_load_factor, other.m_max_load_factor);
        swap(m_grow_on_next_insert, other.m_grow_on_next_insert);
        swap(m_min_load_factor, other.m_min_load_factor);
        swap(m_try_skrink_on_next_insert, other.m_try_skrink_on_next_insert);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x4150
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4160
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4170
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x41b0
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
callq 0x41e0
movq (%rsp), %rdi
addq $0x28, %rdi
movq 0x8(%rsp), %rsi
addq $0x28, %rsi
callq 0x4220
movq (%rsp), %rdi
addq $0x30, %rdi
movq 0x8(%rsp), %rsi
addq $0x30, %rsi
callq 0x4220
movq (%rsp), %rdi
addq $0x38, %rdi
movq 0x8(%rsp), %rsi
addq $0x38, %rsi
callq 0x4220
movq (%rsp), %rdi
addq $0x40, %rdi
movq 0x8(%rsp), %rsi
addq $0x40, %rsi
callq 0x4260
movq (%rsp), %rdi
addq $0x44, %rdi
movq 0x8(%rsp), %rsi
addq $0x44, %rsi
callq 0x42a0
movq (%rsp), %rdi
addq $0x48, %rdi
movq 0x8(%rsp), %rsi
addq $0x48, %rsi
callq 0x4260
movq (%rsp), %rdi
addq $0x4c, %rdi
movq 0x8(%rsp), %rsi
addq $0x4c, %rsi
callq 0x42a0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/tsl_robin_map/./robin_hash.h
// Function: tsl::detail_robin_hash::robin_hash<std::pair<unsigned int, unsigned int>, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::erase(tsl::detail_robin_hash::robin_hash<std::pair<unsigned int, unsigned int>, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::robin_iterator<false>)
iterator erase(iterator pos) {
        erase_from_bucket(pos);
        
        /**
         * Erase bucket used a backward shift after clearing the bucket.
         * Check if there is a new value in the bucket, if not get the next non-empty.
         */
        if(pos.m_bucket->empty()) {
            ++pos;
        }
        
        m_try_skrink_on_next_insert = true;
        
        return pos;
    }

// Assembly:
subq $0x28, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0x4760
movq 0x18(%rsp), %rdi
callq 0x1bb0
testb $0x1, %al
jne 0x472b
jmp 0x4735
leaq 0x18(%rsp), %rdi
callq 0x48b0
movq (%rsp), %rax
movb $0x1, 0x4c(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/tsl_robin_map/./robin_hash.h
// Function: tsl::detail_robin_hash::robin_hash<std::pair<unsigned int, unsigned int>, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::robin_iterator<false>::operator++()
robin_iterator& operator++() {
            while(true) {
                if(m_bucket->last_bucket()) {
                    ++m_bucket;
                    return *this;
                }
                
                ++m_bucket;
                if(!m_bucket->empty()) {
                    return *this;
                }
            }
        }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x4920
testb $0x1, %al
jne 0x48d4
jmp 0x48e9
movq (%rsp), %rax
movq (%rax), %rcx
addq $0xc, %rcx
movq %rcx, (%rax)
movq %rax, 0x10(%rsp)
jmp 0x4910
movq (%rsp), %rax
movq (%rax), %rcx
addq $0xc, %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x1bb0
testb $0x1, %al
jne 0x490e
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x4910
jmp 0x48c2
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: ashagraev[P]covariation/main.cpp
// Function: void TPrinter::AddToRow<unsigned long>(unsigned long const&)
void AddToRow(const TValue& value) {
        std::stringstream ss;
        ss.precision(10);
        ss << value;
        Rows.back().push_back(ss.str());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2120
movq -0x198(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x198(%rbp,%rax), %rdi
movl $0xa, %esi
callq 0x7c90
jmp 0x3559
leaq -0x188(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x2050
jmp 0x356e
movq -0x1d0(%rbp), %rdi
addq $0x38, %rdi
callq 0x7cc0
movq %rax, -0x1d8(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x21b0
jmp 0x359a
movq -0x1d8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x7d00
jmp 0x35af
leaq -0x1c8(%rbp), %rdi
callq 0x20f0
leaq -0x198(%rbp), %rdi
callq 0x2140
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x3602
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x20f0
leaq -0x198(%rbp), %rdi
callq 0x2140
movq -0x1a0(%rbp), %rdi
callq 0x2260
nopw (%rax,%rax)