LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::resolve(Clause*, Literal, Clause*)
Clause* Formula::resolve ( Clause* clause, Literal literal, Clause* reason ) {

	//  Performs extended resolution on clause and reason wrt literal.
	// (See pp.47-50 of Jain: https://github.com/akinanop/mvl-solver/blob/master/literature/Jain_thesis.pdf)

	Clause * resolvent = new Clause();

	Literal neg_lit = literal;
	neg_lit.EQUAL = !literal.EQUAL;

	// Add literals L' from the clause that are satisfied by at least one interpretation that does not satisfy the resolution literal L, i.e., doesn't falsify NOT L.
	for ( unsigned int i = 0; i < clause -> ATOM_LIST.size(); i++ ) {

		Literal c_atom = clause -> ATOM_LIST[i];

		if ( ! falsifies ( c_atom, neg_lit ) ) resolvent -> addAtom ( c_atom );

	}

	// Add literals L' from the reason clause that are satisfied by at least one interpretation that also satisfies the resolution literal L, i.e., doesn't falsify L.
	for ( unsigned int  i = 0; i < reason -> ATOM_LIST.size(); i++ ) {

		Literal r_atom = reason -> ATOM_LIST[i];

		if ( ! falsifies ( r_atom, literal ) && ! hasAtom ( resolvent, r_atom ) ) resolvent -> addAtom ( r_atom );

	}

	return resolvent;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r12
pushq $0x38
popq %rdi
callq 0x2220
movq %rax, %r15
movq %rax, %rdi
callq 0x5720
xorl %r13d, %r13d
movl %r13d, %r13d
movq (%r12), %rcx
movq 0x8(%r12), %rax
subq %rcx, %rax
cqto
pushq $0xc
popq %rsi
idivq %rsi
cmpq %r13, %rax
jbe 0x6f7a
imulq $0xc, %r13, %rax
movq (%rcx,%rax), %rsi
movb 0x8(%rcx,%rax), %al
cmpl %r14d, %esi
jne 0x6f6a
movq %rsi, %rcx
xorq %r14, %rcx
shrq $0x20, %rcx
jne 0x6f5f
movl %eax, %ecx
xorb %bpl, %cl
testb $0x1, %cl
jne 0x6f6a
jmp 0x6f75
testb $0x1, %bpl
sete %cl
testb %cl, %al
jne 0x6f75
movzbl %al, %edx
movq %r15, %rdi
callq 0x57f2
incl %r13d
jmp 0x6f1a
movl %ebp, 0x4(%rsp)
xorl %ebp, %ebp
movl %ebp, %ebp
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
pushq $0xc
popq %rsi
idivq %rsi
cmpq %rbp, %rax
jbe 0x6ff1
imulq $0xc, %rbp, %rax
movq (%rcx,%rax), %r12
movb 0x8(%rcx,%rax), %al
cmpl %r14d, %r12d
jne 0x6fc9
movq %r12, %rcx
xorq %r14, %rcx
shrq $0x20, %rcx
jne 0x6fbe
movl %eax, %ecx
xorb 0x4(%rsp), %cl
jmp 0x6fc4
movl %eax, %ecx
andb 0x4(%rsp), %cl
testb $0x1, %cl
jne 0x6fed
movzbl %al, %r13d
movq %r15, %rsi
movq %r12, %rdx
movl %r13d, %ecx
callq 0x6ea6
testb %al, %al
jne 0x6fed
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x57f2
incl %ebp
jmp 0x6f80
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r15, %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::falsifies(Literal, Literal)
bool Formula::falsifies ( Literal literal, Literal decision ) {

	// true if literal falsifies decision

	if ( literal . VAR != decision . VAR ) return false;
	else if ( literal . VAL != decision . VAL && (!literal . EQUAL || !decision . EQUAL) ) return false;
	else if ( literal . VAL == decision . VAL && literal . EQUAL == decision . EQUAL ) return false;

	else return true;
}

// Assembly:
cmpl %ecx, %esi
jne 0x703a
xorq %rsi, %rcx
shrq $0x20, %rcx
jne 0x702c
xorb %dl, %r8b
jmp 0x7031
testb $0x1, %dl
je 0x703a
testb $0x1, %r8b
je 0x703a
movb $0x1, %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::backtrackLevel(Clause*)
int Formula::backtrackLevel ( Clause * learnedClause ) {

	/* returns the second highest level associated
	  with a literal in the learnedClause */


	if ( LOG ) cout << "Finding backtrack level..." << endl;

	int max = -1;
	int csize = learnedClause -> ATOM_LIST.size();
	/*
	 * Additional possibility: if learned clause has only one literal then backtrack to the level 0
    if ( csize == 1 )
    return 0;
	 */

	for ( int i = 0; i < csize; i++ ) {

		Literal atom = learnedClause -> ATOM_LIST[i];
		int atom_level = VARLIST[atom . VAR] -> ATOMLEVEL[atom . VAL];

		if ( LEVEL > atom_level && max < atom_level ) {
			max = atom_level;
		}

	}

	// cout << "INDEX: " << INDEX << endl;

	if ( max != -1 ) return max;
	else return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0xa4(%rdi)
jne 0x7360
movq 0x7c84(%rip), %rdi      # 0xefd0
leaq 0x39dc(%rip), %rsi      # 0xad2f
callq 0x2210
movq %rax, %rdi
callq 0x2140
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
pushq $0xc
popq %rsi
cqto
idivq %rsi
movq (%rbx), %rdx
movl 0x48(%rbx), %esi
xorl %edi, %edi
testl %eax, %eax
cmovlel %edi, %eax
imulq $0xc, %rax, %rax
pushq $-0x1
popq %r8
cmpq %rdi, %rax
je 0x73b8
movslq (%rcx,%rdi), %r9
movslq 0x4(%rcx,%rdi), %r10
movq (%rdx,%r9,8), %r9
movq 0x18(%r9), %r9
movl (%r9,%r10,4), %r9d
cmpl %r9d, %r8d
movl %r9d, %r10d
cmovgl %r8d, %r10d
cmpl %r9d, %esi
cmovgl %r10d, %r8d
addq $0xc, %rdi
jmp 0x7387
xorl %eax, %eax
cmpl $-0x1, %r8d
cmovnel %r8d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::undoTheory(int)
void Formula::undoTheory ( int level ) {

	// Undo theory to the level
	// for each variable v, for each domain d from dom(v): if this value has been assigned at level this or greater undo

	for ( unsigned int  i = 1; i < VARLIST.size(); i++ ) {

		for ( int j = 0; j < VARLIST[i] -> DOMAINSIZE; j++ ) {

			if ( VARLIST[i] -> ATOMLEVEL[j] > level ) {

				if ( VARLIST[i] -> ATOMASSIGN[j] == -1 )
					addLiteral ( i, true, j );
				else
					addLiteral ( i, false, j );
			}
		}
	}

	for ( unsigned int  i = 1; i < VARLIST.size(); i++ ) {

		for ( int j = 0; j < VARLIST[i] -> DOMAINSIZE; j++ ) {

			if ( VARLIST[i] -> ATOMLEVEL[j] > level ) {

				if ( VARLIST[i] -> ATOMASSIGN[j] == -1)
					unsatisfyClauses (i, false, j, level );
				else
					unsatisfyClauses ( i, true, j, level );

				VARLIST[i]->ATOMLEVEL[j] = -10;
				VARLIST[i]->ATOMASSIGN[j] = 0;
				VARLIST[i]->CLAUSEID[j] = -10;
				VARLIST[i] -> VAL = -1;
			}
		}
	}
	//undo the decision stack

	int decsize = DECSTACK.size();

	for ( int i = decsize-1; i > -1; i-- ) {
		if ( VARLIST[DECSTACK[i] . VAR] -> ATOMASSIGN[DECSTACK[i] . VAL] == 0 ) {
			DECSTACK.erase ( DECSTACK.begin() + i );
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
pushq $0x1
popq %r14
movl %r14d, %r14d
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
jbe 0x7437
xorl %r15d, %r15d
movq (%rax,%r14,8), %rcx
movslq 0x8(%rcx), %rdx
cmpq %rdx, %r15
jge 0x7432
movq 0x18(%rcx), %rax
cmpl %ebp, (%rax,%r15,4)
jle 0x742a
movq 0x20(%rcx), %rax
xorl %edx, %edx
cmpl $-0x1, (%rax,%r15,4)
sete %dl
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %ecx
callq 0x8d38
incq %r15
movq (%rbx), %rax
jmp 0x73f7
incl %r14d
jmp 0x73de
pushq $0x1
popq %r14
pushq $-0xa
popq %r12
movl %r14d, %r14d
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x74b9
xorl %r15d, %r15d
movq (%rax,%r14,8), %rcx
movslq 0x8(%rcx), %rdx
cmpq %rdx, %r15
jge 0x74b0
movq 0x18(%rcx), %rdx
cmpl %ebp, (%rdx,%r15,4)
jle 0x74ab
movq 0x20(%rcx), %rax
xorl %edx, %edx
cmpl $-0x1, (%rax,%r15,4)
setne %dl
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %ecx
movl %ebp, %r8d
callq 0x8d98
movq (%rbx), %rax
movq (%rax,%r14,8), %rcx
movq 0x18(%rcx), %rdx
movl %r12d, (%rdx,%r15,4)
movq 0x20(%rcx), %rdx
andl $0x0, (%rdx,%r15,4)
movq 0x48(%rcx), %rdx
movl %r12d, (%rdx,%r15,4)
orl $-0x1, 0x4(%rcx)
incq %r15
jmp 0x7451
incl %r14d
movq 0x8(%rbx), %rcx
jmp 0x743f
leaq 0x88(%rbx), %r14
movq 0x90(%rbx), %rax
subq 0x88(%rbx), %rax
pushq $0xc
popq %rcx
cqto
idivq %rcx
movq %rax, %r15
movl %r15d, %eax
imulq $0xc, %rax, %r12
addq $-0xc, %r12
testl %r15d, %r15d
jle 0x751a
movq (%rbx), %rax
movq 0x88(%rbx), %rsi
movslq (%rsi,%r12), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rax
movslq 0x4(%rsi,%r12), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x7515
addq %r12, %rsi
movq %r14, %rdi
callq 0x8e86
decl %r15d
jmp 0x74e0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::watchedUndoTheory(int)
void Formula::watchedUndoTheory ( int level ) { // FIXME  fixed ?

	for ( unsigned int  i = 1; i < VARLIST.size(); i++ ) {

		for ( int j = 0; j < VARLIST[i] -> DOMAINSIZE; j++ ) {
			//if this domain has been assigned at level this or greater undo
			if ( VARLIST[i]->ATOMLEVEL[j] > level ) {

				// cout << "unassign " << i << " " << j <<endl;
				VARLIST[i] -> VAL = -1;
				VARLIST[i]->ATOMASSIGN[j] = 0;
				VARLIST[i]->ATOMLEVEL[j] = -10;
				VARLIST[i]->CLAUSEID[j] = -10;

			}
		}
	}
	//undo the decision stack
	int decsize = DECSTACK.size();
	for ( int i = decsize - 1; i > -1; i-- ) {
		if ( VARLIST[DECSTACK[i] . VAR] -> ATOMASSIGN[DECSTACK[i] . VAL] == 0 ) {
			DECSTACK.erase ( DECSTACK.begin() + i );
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
pushq $0x1
popq %rdx
pushq $-0xa
popq %rdi
movl %edx, %edx
cmpq %rdx, %rcx
jbe 0x7587
movq (%rax,%rdx,8), %r8
xorl %r9d, %r9d
movslq 0x8(%r8), %r10
cmpq %r10, %r9
jge 0x7583
movq 0x18(%r8), %r10
cmpl %esi, (%r10,%r9,4)
jle 0x757e
orl $-0x1, 0x4(%r8)
movq 0x20(%r8), %r11
andl $0x0, (%r11,%r9,4)
movl %edi, (%r10,%r9,4)
movq 0x48(%r8), %r10
movl %edi, (%r10,%r9,4)
incq %r9
jmp 0x7551
incl %edx
jmp 0x7543
leaq 0x88(%rbx), %r14
movq 0x90(%rbx), %rax
subq 0x88(%rbx), %rax
pushq $0xc
popq %rcx
cqto
idivq %rcx
movq %rax, %r15
movl %r15d, %eax
imulq $0xc, %rax, %r12
addq $-0xc, %r12
testl %r15d, %r15d
jle 0x75e8
movq (%rbx), %rax
movq 0x88(%rbx), %rsi
movslq (%rsi,%r12), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rax
movslq 0x4(%rsi,%r12), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x75e3
addq %r12, %rsi
movq %r14, %rdi
callq 0x8e86
decl %r15d
jmp 0x75ae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::maxLit(Clause*)
int Formula::maxLit ( Clause* clause ) {


	int atom_index = 0;
	int decision_index = 0;
	int max_decision_index = 0;

	for ( int i = 0; i < clause -> ATOM_LIST.size(); i++ ) {

		Literal atom = clause -> ATOM_LIST[i];

		decision_index = VARLIST[atom . VAR] -> ATOMINDEX[atom . VAL];

		if ( max_decision_index < decision_index ) {

			max_decision_index = decision_index;
			atom_index = i;
		}

	}


	return  atom_index ;

}

// Assembly:
movq (%rsi), %r8
movq 0x8(%rsi), %rax
subq %r8, %rax
pushq $0xc
popq %rcx
cqto
idivq %rcx
movq (%rdi), %rdx
addq $0x4, %r8
xorl %esi, %esi
xorl %edi, %edi
xorl %ecx, %ecx
cmpq %rsi, %rax
je 0x7902
movslq -0x4(%r8), %r9
movslq (%r8), %r10
movq (%rdx,%r9,8), %r9
movq 0x10(%r9), %r9
movl (%r9,%r10,4), %r9d
cmpl %r9d, %edi
cmovlel %r9d, %edi
cmovll %esi, %ecx
incq %rsi
addq $0xc, %r8
jmp 0x78d7
movl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::assignWatched(Clause*)
void Formula::assignWatched( Clause* clause) {

	Literal w1;
	Literal w2;
	int decision_index = -1;
	int max_decision_index = -1;
	int second_max_decision_index = -1;

	for ( int i = 0; i < clause -> ATOM_LIST.size(); i++ ) {

		Literal atom = clause -> ATOM_LIST[i];

		decision_index = VARLIST[atom . VAR] -> ATOMINDEX[atom . VAL];

		if ( max_decision_index < decision_index ) {
			second_max_decision_index = max_decision_index;
			max_decision_index = decision_index;
			w2 = w1;
			w1 = atom;
		} else if (second_max_decision_index < decision_index) {
			second_max_decision_index = decision_index;
			w2 = atom;
		}
	}
	clause->WATCHED[0] = w1;
	clause->WATCHED[1] = w2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rsi), %rcx
movq %rsi, -0x8(%rsp)
movq 0x8(%rsi), %rax
subq %rcx, %rax
movabsq $0xc, %rsi
cqto
idivq %rsi
movq (%rdi), %rdx
addq $0x8, %rcx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rsp)
movl %ebp, %r8d
movl %ebp, %r15d
movl %ebp, %r9d
xorl %r10d, %r10d
movl %ebp, %ebx
movl %ebp, %r11d
subq $0x1, %rax
jb 0x79b5
movslq -0x8(%rcx), %r14
movslq -0x4(%rcx), %rdi
movb (%rcx), %sil
movq (%rdx,%r14,8), %r12
movq 0x10(%r12), %r12
movl (%r12,%rdi,4), %r13d
cmpl %r13d, %r11d
jge 0x7992
movl %r14d, %r12d
movl %r10d, -0xc(%rsp)
movl %r9d, %r8d
movl %ebp, %r14d
movl %edi, %r9d
movl %esi, %r10d
movl %r11d, %ebx
movl %r13d, %r11d
jmp 0x79a9
movl %ebp, %r12d
cmpl %r13d, %ebx
jge 0x79a6
movl %esi, -0xc(%rsp)
movl %edi, %r8d
movl %r13d, %ebx
jmp 0x79a9
movl %r15d, %r14d
addq $0xc, %rcx
movl %r12d, %ebp
movl %r14d, %r15d
jmp 0x7953
movq -0x8(%rsp), %rax
movl %ebp, 0x20(%rax)
movl %r9d, 0x24(%rax)
movb %r10b, 0x28(%rax)
movl %r15d, 0x2c(%rax)
movl %r8d, 0x30(%rax)
movl -0xc(%rsp), %ecx
movb %cl, 0x34(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::WatchedUnitPropagation()
void Formula::WatchedUnitPropagation()
{
	int unit_clause = -1;

	//while there is no conflict and there exists a unit clause
	//find the unit literal and satisfy it
	while( ! CONFLICT && ! UNITLIST.empty() ) {

		unit_clause = UNITLIST.front();
		UNITCLAUSE = unit_clause;
		//if (LOG) cout<<"unit c : "<<unit_clause<<endl;
		UNITLIST.pop_front();

		Clause* clause = CLAUSELIST[unit_clause];

		if ( sat ( clause -> WATCHED[0] ) == 2 ) {
			watchedReduceTheory(clause -> WATCHED[0]);
			UNITS++;
		}
		else if ( clause->ATOM_LIST.size() > 1 && sat ( clause -> WATCHED[1] ) == 2 ) {
			watchedReduceTheory(clause -> WATCHED[1]);
			UNITS++;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
pushq $0xc
popq %r12
cmpb $0x0, 0x7c(%rbx)
jne 0x7ab1
movq (%r14), %rax
cmpq %r14, %rax
je 0x7ab1
movslq 0x10(%rax), %r15
movl %r15d, 0x78(%rbx)
movq %r14, %rdi
callq 0x8ec0
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %r13
movq 0x20(%r13), %r15
movzbl 0x28(%r13), %ebp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x79e0
cmpl $0x2, %eax
jne 0x7a7d
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x7ac0
incl 0x54(%rbx)
jmp 0x7a26
movq 0x8(%r13), %rax
subq (%r13), %rax
cqto
idivq %r12
cmpq $0x2, %rax
jb 0x7a26
movq 0x2c(%r13), %r15
movzbl 0x34(%r13), %ebp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x79e0
cmpl $0x2, %eax
jne 0x7a26
jmp 0x7a6b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::lazyWatchedChooseLiteral()
Literal Formula::lazyWatchedChooseLiteral () {

	// Choose any unassigned first watched literal


	for ( unsigned int  i = 0; i < CLAUSELIST.size(); i++ ) {

		Literal watched1 = CLAUSELIST[i] -> WATCHED[0];

		if ( sat ( watched1 ) == 2) return  watched1;
	}
	return Literal();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r12
subq %r15, %r12
sarq $0x3, %r12
xorl %ecx, %ecx
movl %ecx, %r13d
cmpq %r13, %r12
jbe 0x7f7f
movq (%r15,%r13,8), %rax
movq 0x20(%rax), %r14
movb 0x28(%rax), %bpl
movzbl %bpl, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79e0
leal 0x1(%r13), %ecx
cmpl $0x2, %eax
jne 0x7f51
jmp 0x7f85
xorl %ebp, %ebp
pushq $-0x1
popq %r14
movq %r14, %rax
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::lazyChooseLiteral()
Literal Formula::lazyChooseLiteral() {

	for ( unsigned int  i = 0; i < CLAUSELIST.size(); i++ ) {

		Clause* clause = CLAUSELIST[i];

		for ( int j = 0 ; clause -> LEVEL == -1 && j < clause -> ATOM_LIST.size(); j++ ) {

			Literal literal = clause -> ATOM_LIST[j];

			if ( sat ( literal ) == 2 ) return literal;

		}
	}
	return Literal();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
movq %rax, 0x8(%rsp)
subq %rax, %rcx
sarq $0x3, %rcx
movq %rcx, 0x10(%rsp)
xorl %r12d, %r12d
movl %r12d, %r12d
cmpq %r12, 0x10(%rsp)
jbe 0x803c
movq 0x8(%rsp), %rax
movq (%rax,%r12,8), %rax
cmpl $-0x1, 0x1c(%rax)
je 0x7fe5
incl %r12d
jmp 0x7fc7
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
cqto
pushq $0xc
popq %rsi
idivq %rsi
movq %rax, %r14
incq %r14
addq $0x8, %rcx
decq %r14
je 0x7fe0
leaq 0xc(%rcx), %r13
movq -0x8(%rcx), %r15
movb (%rcx), %bpl
movzbl %bpl, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x79e0
movq %r13, %rcx
cmpl $0x2, %eax
jne 0x8001
movq %r15, %rax
movl %ebp, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
pushq $-0x1
popq %r15
jmp 0x8028
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::SwapPointer(VARRECORD*)
void Formula::SwapPointer ( VARRECORD * current ) {

	int clause_num = current->c_num;

    Clause* clause = CLAUSELIST[clause_num];

	Literal watched1 = clause -> WATCHED[0];
	Literal watched2 = clause -> WATCHED[1];

	bool unitClause = true;

	if ( clause->ATOM_LIST.size() > 1 && sat ( watched2 )  == 2 ) {

		// if watched2 unassigned, watched1 falsified

		for ( int i = 0; i < clause -> ATOM_LIST.size(); i++ ) {

			Literal literal = clause -> ATOM_LIST[i];

			if (  sat(literal) != 0 && literal != watched2  ) {

				VARLIST[watched1.VAR]->removeRecord(current, watched1.VAL, watched1.EQUAL);
				VARLIST[literal.VAR]->addRecord(clause_num, literal.VAL, literal.EQUAL);

				clause -> WATCHED[0] = literal;

				unitClause = false;
				break;
			}
		}
	} else {
		if ( LOG ) cout << "Conflict" << endl;
		CONFLICT = true;
		CONFLICTINGCLAUSE = clause_num;
		unitClause = false;
	}
	if (unitClause) {
		UNITLIST.push_front(clause_num);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movslq (%rsi), %r14
movl %r14d, 0x24(%rsp)
movq 0x18(%rdi), %rax
movq (%rax,%r14,8), %rbp
movslq 0x20(%rbp), %rax
movq %rax, 0x50(%rsp)
movl 0x24(%rbp), %eax
movl %eax, 0x20(%rsp)
movb 0x28(%rbp), %al
movb %al, 0xf(%rsp)
movl 0x34(%rbp), %eax
movl %eax, 0x30(%rsp)
movq 0x2c(%rbp), %rax
movq %rax, 0x28(%rsp)
movq (%rbp), %r12
movq 0x8(%rbp), %r13
movq %r13, %rax
subq %r12, %rax
pushq $0xc
popq %rcx
cqto
idivq %rcx
cmpq $0x2, %rax
jb 0x8137
movq %rsi, %r15
movq 0x28(%rsp), %rsi
movl 0x30(%rsp), %edx
movq %rbx, %rdi
callq 0x79e0
cmpl $0x2, %eax
jne 0x8137
movq %r15, 0x40(%rsp)
movq %r14, 0x48(%rsp)
leaq 0x20(%rbp), %rax
movq %rax, 0x38(%rsp)
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %r13, %rax
subq %r12, %rax
cqto
pushq $0xc
popq %rcx
idivq %rcx
cmpq %r15, %rax
jbe 0x8175
movl 0x8(%r12,%r14), %edx
movl %edx, 0x18(%rsp)
movq (%r12,%r14), %rsi
movq %rsi, 0x10(%rsp)
movq %rbx, %rdi
callq 0x79e0
testl %eax, %eax
je 0x812e
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x8ec8
testb %al, %al
jne 0x8188
movq (%rbp), %r12
movq 0x8(%rbp), %r13
incq %r15
addq $0xc, %r14
jmp 0x80de
cmpb $0x1, 0xa4(%rbx)
jne 0x815b
movq 0x6e89(%rip), %rdi      # 0xefd0
leaq 0x2c30(%rip), %rsi      # 0xad7e
callq 0x2210
movq %rax, %rdi
callq 0x2140
movb $0x1, 0x7c(%rbx)
movl %r14d, 0x80(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x60, %rbx
leaq 0x24(%rsp), %rsi
movq %rbx, %rdi
callq 0x8ed2
jmp 0x8166
movq (%rbx), %rax
movq 0x50(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movzbl 0xf(%rsp), %ecx
andl $0x1, %ecx
movq 0x40(%rsp), %rsi
movl 0x20(%rsp), %edx
callq 0x5e70
movslq 0x10(%rsp), %rax
movq (%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movl 0x14(%rsp), %edx
movzbl 0x18(%rsp), %ecx
movq 0x48(%rsp), %rsi
callq 0x5e1a
movb 0x18(%rsp), %al
movq 0x38(%rsp), %rcx
movb %al, 0x8(%rcx)
movq 0x10(%rsp), %rax
movq %rax, (%rcx)
jmp 0x8166
nop
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::unitPropagation()
void Formula::unitPropagation()
{
	int lit_var = -1;
	bool lit_equal = false;
	int lit_val = -1;
	int unit_clause = -1;

	//while there is no conflict and there exists a unit clause
	//find the unit literal and satisfy it
	while(!CONFLICT && !UNITLIST.empty())
	{
		unit_clause = UNITLIST.front();
		UNITCLAUSE = unit_clause;
		//if (LOG) cout<<"unit c : "<<unit_clause<<endl;
		UNITLIST.pop_front();
		if(CLAUSELIST[unit_clause]->LEVEL == -1)
		{
			for(int i=0; i<CLAUSELIST[unit_clause]->ATOM_LIST.size(); i++)
			{
				lit_var = CLAUSELIST[unit_clause]->ATOM_LIST[i].VAR;
				lit_equal = CLAUSELIST[unit_clause]->ATOM_LIST[i].EQUAL;
				lit_val = CLAUSELIST[unit_clause]->ATOM_LIST[i].VAL;
				if(VARLIST[lit_var]->ATOMASSIGN[lit_val] == 0)
				{
					UNITS++;
					reduceTheory(lit_var, lit_equal, lit_val);
					break;
				}
			}
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
pushq $0xc
popq %r15
cmpb $0x0, 0x7c(%rbx)
jne 0x886b
movq (%r14), %rax
cmpq %r14, %rax
je 0x886b
movslq 0x10(%rax), %r12
movl %r12d, 0x78(%rbx)
movq %r14, %rdi
callq 0x8ec0
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rax
cmpl $-0x1, 0x1c(%rax)
jne 0x87f7
movq (%rax), %rdi
movq 0x8(%rax), %rax
subq %rdi, %rax
cqto
idivq %r15
movq (%rbx), %rdx
incq %rax
leaq 0xc(%rdi), %r8
decq %rax
je 0x87f7
movslq (%rdi), %rsi
movslq 0x4(%rdi), %rcx
movq (%rdx,%rsi,8), %rdi
movq 0x20(%rdi), %rdi
cmpl $0x0, (%rdi,%rcx,4)
movq %r8, %rdi
jne 0x8838
movzbl -0x4(%r8), %edx
incl 0x54(%rbx)
movq %rbx, %rdi
callq 0x69ec
jmp 0x87f7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::satisfyClauses(int, bool, int)
inline void Formula::satisfyClauses ( int var, bool equals, int val ) {

	int lit_var = -1;
	bool lit_equal = false;
	int lit_val = -1;

	vector<int>::iterator current;
	vector<int>::iterator end;

	// Get clauses where the literal appears:
	if ( equals ) current = VARLIST[var] -> ATOMRECPOS[val].begin();
	else current = VARLIST[var] -> ATOMRECNEG[val].begin();
	if ( equals ) end = VARLIST[var] -> ATOMRECPOS[val].end();
	else end = VARLIST[var] -> ATOMRECNEG[val].end();

	while ( current != end ) {

		// For every clause that contains this literal, satisfy it

		if ( CLAUSELIST[*current] -> LEVEL == -1 ) {

			CLAUSELIST[*current]->LEVEL = LEVEL;
			CLAUSELIST[*current]->NumUnAss = 0;

			// and update the counts for other unassigned literals in the clause (corresponds to deleting the clause from the theory)

			if (heuristic==Heuristic::BK) {
				for (int i = 0; i < CLAUSELIST[*current]->ATOM_LIST.size(); i++) {

					lit_var = CLAUSELIST[*current]->ATOM_LIST[i].VAR;
					lit_equal = CLAUSELIST[*current]->ATOM_LIST[i].EQUAL;
					lit_val = CLAUSELIST[*current]->ATOM_LIST[i].VAL;

					if (VARLIST[lit_var]->ATOMASSIGN[lit_val] == 0) {

						if (lit_equal)
							VARLIST[lit_var]->ATOMCNTPOS[lit_val]--;
						else
							VARLIST[lit_var]->ATOMCNTNEG[lit_val]--;

					}
				}
			}
		}
		++current;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq %esi, %rax
movq (%rdi), %r8
movq 0x18(%rdi), %rsi
movq (%r8,%rax,8), %rax
movslq %ecx, %rcx
xorb $0x1, %dl
movzbl %dl, %edx
movq 0x60(%rax,%rdx,8), %rax
imulq $0x18, %rcx, %rdx
movq (%rax,%rdx), %rcx
movq 0x8(%rax,%rdx), %r8
movl 0xa8(%rdi), %r9d
movabsq $0x8, %r10
movabsq $0xc, %r11
cmpq %r8, %rcx
je 0x8c87
movslq (%rcx), %rax
movq (%rsi,%rax,8), %rax
cmpl $-0x1, 0x1c(%rax)
jne 0x8c29
movl 0x48(%rdi), %edx
movl %edx, 0x1c(%rax)
movslq (%rcx), %rax
movq (%rsi,%rax,8), %rax
andl $0x0, 0x18(%rax)
testl %r9d, %r9d
je 0x8c2f
addq $0x4, %rcx
jmp 0x8bfd
movq (%rdi), %rbx
movq %r10, %r14
xorl %r15d, %r15d
movslq (%rcx), %rax
movq (%rsi,%rax,8), %rax
movq (%rax), %r12
movq 0x8(%rax), %rax
subq %r12, %rax
cqto
idivq %r11
cmpq %r15, %rax
jbe 0x8c29
movslq -0x8(%r12,%r14), %rdx
movslq -0x4(%r12,%r14), %rax
movq (%rbx,%rdx,8), %rdx
movq 0x20(%rdx), %r13
cmpl $0x0, (%r13,%rax,4)
jne 0x8c7e
movzbl (%r12,%r14), %r12d
xorl $0x1, %r12d
movq 0x28(%rdx,%r12,8), %rdx
decl (%rdx,%rax,4)
incq %r15
addq $0xc, %r14
jmp 0x8c38
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::removeLiteral(int, bool, int)
inline void Formula::removeLiteral ( int var, bool equals, int val ) {

	vector<int>::iterator current;
	vector<int>::iterator end;

	// for every record of this literal reduce the number of unassigned literals in unsatisfied clauses
	// update counts

	if ( equals ) current = VARLIST[var] -> ATOMRECPOS[val].begin();
	else current = VARLIST[var] -> ATOMRECNEG[val].begin();
	if ( equals ) end = VARLIST[var] -> ATOMRECPOS[val].end();
	else end = VARLIST[var] -> ATOMRECNEG[val].end();

	while ( current != end ) {

		if( CLAUSELIST[*current] -> LEVEL == -1 ) {

			CLAUSELIST[*current]->NumUnAss--;

			//checking for units and conflicts right away:

			if ( CLAUSELIST[*current] -> NumUnAss == 1 ) {
				UNITLIST.push_front(*current);
			}

			if ( CLAUSELIST[*current] -> NumUnAss == 0 ) {

				CONFLICT = true;
				CONFLICTINGCLAUSE = *current;
			}
		}
		++current;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %rax
movq (%rdi), %rsi
movq (%rsi,%rax,8), %rax
movslq %ecx, %rcx
xorb $0x1, %dl
movzbl %dl, %edx
movq 0x60(%rax,%rdx,8), %rax
imulq $0x18, %rcx, %rcx
movq (%rax,%rcx), %r14
movq 0x8(%rax,%rcx), %r12
leaq 0x60(%rdi), %r15
cmpq %r12, %r14
je 0x8d1b
movslq (%r14), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rax
cmpl $-0x1, 0x1c(%rax)
jne 0x8d15
decl 0x18(%rax)
movslq (%r14), %rax
movq (%rcx,%rax,8), %rcx
movl 0x18(%rcx), %ecx
cmpl $0x1, %ecx
jne 0x8d07
movq %r15, %rdi
movq %r14, %rsi
callq 0x8ed2
movslq (%r14), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movl 0x18(%rcx), %ecx
testl %ecx, %ecx
jne 0x8d15
movb $0x1, 0x7c(%rbx)
movl %eax, 0x80(%rbx)
addq $0x4, %r14
jmp 0x8cc6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::addLiteral(int, bool, int)
inline void Formula::addLiteral ( int var, bool equals, int val ) {

	vector<int>::iterator current;
	vector<int>::iterator end;

	//for every record of this literal increase the number of
	//unassigned literals from unsatisfied clauses

	if ( equals ) current = VARLIST[var] -> ATOMRECPOS[val].begin();
	else current = VARLIST[var] -> ATOMRECNEG[val].begin();
	if ( equals ) end = VARLIST[var] -> ATOMRECPOS[val].end();
	else end = VARLIST[var] -> ATOMRECNEG[val].end();

	while ( current != end ) {
		if ( CLAUSELIST[*current] -> LEVEL == -1 ) {

			CLAUSELIST[*current] -> NumUnAss++;

			if (heuristic==Heuristic::BK) {
				if ( equals ) VARLIST[var] -> ATOMCNTPOS[val]++;
				else VARLIST[var] -> ATOMCNTNEG[val]++;
			}
		}
		++current;
	}
}

// Assembly:
movslq %esi, %rsi
movq (%rdi), %r8
movq 0x18(%rdi), %rax
movq (%r8,%rsi,8), %rsi
movslq %ecx, %rcx
xorb $0x1, %dl
movzbl %dl, %edx
shll $0x3, %edx
movq 0x60(%rsi,%rdx), %r9
imulq $0x18, %rcx, %r10
movq (%r9,%r10), %r8
movq 0x8(%r9,%r10), %r9
movl 0xa8(%rdi), %edi
addq $0x28, %rdx
cmpq %r9, %r8
je 0x8d97
movslq (%r8), %r10
movq (%rax,%r10,8), %r10
cmpl $-0x1, 0x1c(%r10)
jne 0x8d91
incl 0x18(%r10)
testl %edi, %edi
jne 0x8d91
movq (%rsi,%rdx), %r10
incl (%r10,%rcx,4)
addq $0x4, %r8
jmp 0x8d6e
retq
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::unsatisfyClauses(int, bool, int, int)
inline void Formula::unsatisfyClauses ( int var, bool equals, int val, int level ) {

	vector<int>::iterator current;
	vector<int>::iterator end;

	int lit_var = -1;
	bool lit_equal = false;
	int lit_val = -1;

	if ( equals ) current = VARLIST[var] -> ATOMRECPOS[val].begin();
	else current = VARLIST[var] -> ATOMRECNEG[val].begin();
	if ( equals ) end = VARLIST[var] -> ATOMRECPOS[val].end();
	else end = VARLIST[var] -> ATOMRECNEG[val].end();

	while ( current != end ) {

		if ( CLAUSELIST[*current] -> LEVEL > level ) {

			for ( int i = 0; i < CLAUSELIST[*current] -> ATOM_LIST.size(); i++ ) {

				lit_var = CLAUSELIST[*current]->ATOM_LIST[i].VAR;
				lit_equal = CLAUSELIST[*current]->ATOM_LIST[i].EQUAL;
				lit_val = CLAUSELIST[*current]->ATOM_LIST[i].VAL;

				if ( ( VARLIST[lit_var] -> ATOMLEVEL[lit_val] > level )
						|| ( VARLIST[lit_var] -> ATOMASSIGN[lit_val] == 0 ) ) {

					CLAUSELIST[*current] -> NumUnAss++;

					if (heuristic==Heuristic::BK) {
						if ( lit_equal )
							VARLIST[lit_var]->ATOMCNTPOS[lit_val]++;
						else
							VARLIST[lit_var]->ATOMCNTNEG[lit_val]++;
					}

				}
			}

			CLAUSELIST[*current]->LEVEL = -1;
		}
		++current;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq %esi, %rax
movq (%rdi), %r9
movq 0x18(%rdi), %rsi
movq (%r9,%rax,8), %rax
movslq %ecx, %rcx
xorb $0x1, %dl
movzbl %dl, %edx
movq 0x60(%rax,%rdx,8), %rax
imulq $0x18, %rcx, %rdx
movq (%rax,%rdx), %rcx
movq 0x8(%rax,%rdx), %r9
movabsq $0xc, %r11
cmpq %r9, %rcx
je 0x8e7b
movslq (%rcx), %rax
movq (%rsi,%rax,8), %r12
cmpl %r8d, 0x1c(%r12)
jle 0x8e72
movq (%rdi), %rbx
movl 0xa8(%rdi), %ebp
movabsq $0x8, %r14
xorl %r15d, %r15d
movq (%r12), %r10
movq 0x8(%r12), %rax
subq %r10, %rax
cqto
idivq %r11
cmpq %r15, %rax
jbe 0x8e6c
movslq -0x8(%r10,%r14), %rdx
movb (%r10,%r14), %r13b
movslq -0x4(%r10,%r14), %rax
movq (%rbx,%rdx,8), %rdx
movq 0x18(%rdx), %r10
cmpl %r8d, (%r10,%rax,4)
jg 0x8e43
movq 0x20(%rdx), %r10
cmpl $0x0, (%r10,%rax,4)
jne 0x8e5c
incl 0x18(%r12)
testl %ebp, %ebp
jne 0x8e5c
xorb $0x1, %r13b
movzbl %r13b, %r10d
movq 0x28(%rdx,%r10,8), %rdx
incl (%rdx,%rax,4)
incq %r15
movslq (%rcx), %rax
movq (%rsi,%rax,8), %r12
addq $0xc, %r14
jmp 0x8e06
orl $-0x1, 0x1c(%r12)
addq $0x4, %rcx
jmp 0x8dd5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::watchedFalsifyLiteral(Literal)
inline void Formula::watchedFalsifyLiteral ( Literal lit ) {

//	cout << "Falsifying " << var << ( equals ? "=" : "!" ) << val << endl;
	VARRECORD* current = NULL;
	VARRECORD* next = NULL;

	// Go through all occurrences of the literal in clauses and update watched literals

	if ( lit.EQUAL ) current = VARLIST[lit.VAR] -> ATOMWATCHPOS[lit.VAL];
	else current = VARLIST[lit.VAR] -> ATOMWATCHNEG[lit.VAL];

	while ( current &&!CONFLICT ) {

		next = current->next;

		// CLAUSELIST[current -> c_num] -> Print();

		Literal watched1 = CLAUSELIST[current -> c_num] -> WATCHED[0];
		Literal watched2 = CLAUSELIST[current -> c_num] -> WATCHED[1];

		if ( sat ( watched1 ) != 1 )  {

			/*
			 *if the clause is not sat, and literal = watched1 or literal = watched2,
			  it means that watched1 is falsified, need to replace it by a unassigned literal
			  if available
			 */

			if (CLAUSELIST[current->c_num]->ATOM_LIST.size() > 1 && sat(watched2) == 1) {

				CLAUSELIST[current->c_num]->WATCHED[0] = watched2;
				CLAUSELIST[current->c_num]->WATCHED[1] = watched1;

			} else {
				if (watched2 == lit) {
					CLAUSELIST[current->c_num]->WATCHED[0] = watched2;
					CLAUSELIST[current->c_num]->WATCHED[1] = watched1;
				}
				SwapPointer(current);
			}
		}
		current = next;
	}

	current = NULL;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
movq (%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
movq %rsi, 0x10(%rsp)
movq %rsi, %rcx
sarq $0x20, %rcx
movl %edx, 0xc(%rsp)
notb %dl
movzbl %dl, %edx
andl $0x1, %edx
movq 0x50(%rax,%rdx,8), %rax
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x901d
cmpb $0x0, 0x7c(%r15)
jne 0x901d
movq %r14, %r12
movq 0x8(%r14), %r14
movslq (%r12), %rax
movq 0x18(%r15), %rcx
movq (%rcx,%rax,8), %rbx
movq 0x20(%rbx), %rsi
movb 0x28(%rbx), %al
movq 0x2c(%rbx), %rbp
movb 0x34(%rbx), %r13b
movb %al, 0xb(%rsp)
movzbl %al, %edx
movq %r15, %rdi
movq %rsi, 0x20(%rsp)
callq 0x79e0
cmpl $0x1, %eax
je 0x8f1a
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
pushq $0xc
popq %rcx
idivq %rcx
cmpq $0x2, %rax
movq %r14, 0x18(%rsp)
jb 0x8fc5
movzbl %r13b, %edx
movq %r15, %rdi
movq %rbp, %rsi
callq 0x79e0
movq 0x18(%rsp), %r14
cmpl $0x1, %eax
jne 0x8fc5
movq %rbp, 0x20(%rbx)
movb %r13b, 0x28(%rbx)
movslq (%r12), %rax
movq 0x18(%r15), %rcx
movq (%rcx,%rax,8), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x2c(%rax)
movb 0xb(%rsp), %cl
movb %cl, 0x34(%rax)
jmp 0x8f1a
cmpq 0x10(%rsp), %rbp
sete %al
cmpb 0xc(%rsp), %r13b
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x9008
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rbx)
movl 0xc(%rsp), %eax
movb %al, 0x28(%rbx)
movslq (%r12), %rax
movq 0x18(%r15), %rcx
movq (%rcx,%rax,8), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x2c(%rax)
movb 0xb(%rsp), %cl
movb %cl, 0x34(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x8044
movq 0x18(%rsp), %r14
jmp 0x8f1a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/huffman_dec.c
// Function: main
int main(int argc, char *argv[])
{
	if (argc < 2)
	{
		printf("Usage: huffman_dec file.huff\r\n");
		return -1;
	}

	unsigned int size = 0;

	char *buffer = get_file(argv[1], &size);
	if (buffer == NULL)
	{
		printf("Unable to open %s\r\n", argv[1]);
		return -1;
	}

	unsigned char *decode = (unsigned char *)malloc(2 * size);
	if (decode == NULL)
	{
		perror("malloc failed");
		return -1;
	}
	memset(decode, 0, 2 * size);
	size_t length = 2 * size;


	unsigned int decompressed_size = huffman_decompress((unsigned char *)buffer, size, decode, length, huffbuf);
	char filename[256] = {0};

	snprintf(filename, 256, "%s.uncompressed", argv[1]);
	write_file(filename, (char *)decode, decompressed_size);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
cmpl $0x1, %edi
jg 0x135d
leaq 0xd25(%rip), %rdi       # 0x2078
callq 0x1040
jmp 0x140b
movq %rsi, %rbx
leaq -0x2c(%rbp), %rsi
andl $0x0, (%rsi)
movq 0x8(%rbx), %rdi
callq 0x120c
testq %rax, %rax
je 0x13f9
movq %rax, %r15
movl -0x2c(%rbp), %r12d
leal (%r12,%r12), %r13d
pushq $0x1
popq %rdi
movq %r13, %rsi
callq 0x10a0
testq %rax, %rax
je 0x1424
movq %rax, %r14
leaq 0x2d0e(%rip), %r8       # 0x40b0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r13, %rcx
callq 0x17ab
movq %rax, %r12
leaq -0x130(%rbp), %r13
xorl %r15d, %r15d
movl $0x100, %edx            # imm = 0x100
movq %r13, %rdi
xorl %esi, %esi
callq 0x1090
movq 0x8(%rbx), %rcx
leaq 0xc72(%rip), %rdx       # 0x204c
movl $0x100, %esi            # imm = 0x100
movq %r13, %rdi
xorl %eax, %eax
callq 0x1080
movq %r13, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x12ba
jmp 0x140f
movq 0x8(%rbx), %rsi
leaq 0xc26(%rip), %rdi       # 0x202a
xorl %eax, %eax
callq 0x1070
pushq $-0x1
popq %r15
movl %r15d, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc13(%rip), %rdi       # 0x203e
callq 0x10f0
jmp 0x140b
nop
// File: /workspace/github_cpp_makefile_star2_O2/stevedonovan[P]outstreams/./instream.h
// Function: stream::Reader& stream::Reader::getlines<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, unsigned long)
Reader& getlines(C& c, size_t lines=-1) {
      if (fail()) return *this;
      std::string tmp;
      size_t i = 0;
      while (i < lines && getline(tmp)) {
         c.push_back(tmp);
         ++i;
      }
      return *this;
   }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3936
testb %al, %al
jne 0x3391
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %r12
subq $0x1, %r14
jb 0x3387
movq %rbx, %rdi
movq %r12, %rsi
callq 0x41fe
movq %rax, %rdi
callq 0x393e
testb %al, %al
je 0x3387
movq %r15, %rdi
movq %r12, %rsi
callq 0x356a
jmp 0x335d
leaq 0x8(%rsp), %rdi
callq 0x2308
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2308
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/stevedonovan[P]outstreams/./outstream.h
// Function: stream::Writer& stream::Writer::operator()<__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>(stream::Range_<__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>> const&, char const*, char)
Writer& operator() (const Range_<It>& rr, const char *fmt=nullptr, char sepr=' ') {
        sep_out();
        char osep = reset_sep(sepr);
        It ii = rr.begin;
        for(;  ii != rr.end; ++ii) {
            (*this)(*ii,fmt);
        }
        return restore_sep(osep);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x4800
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4a5a
movl %eax, %ebp
movq (%r15), %r12
cmpq 0x8(%r15), %r12
je 0x33f7
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3304
addq $0x20, %r12
jmp 0x33dd
movsbl %bpl, %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4a66
nop
// File: /workspace/github_cpp_makefile_star2_O2/hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::Matrix(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>)
Matrix::Matrix( vector<vector<double> > input ){
  resize( input.size(), input[0].size() ); //Eeeehhh....
  _data = input;
  _error = 0;
  _det_up_to_date = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
subq %rcx, %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
shrq $0x3, %rdx
movl %eax, %esi
callq 0x239a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3bea
xorl %eax, %eax
movb %al, 0x31(%rbx)
movb %al, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3bc8
movq %r14, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::Matrix(std::vector<double, std::allocator<double>>)
Matrix::Matrix( vector<double> input ){
  resize( 1, input.size() );
  _data[0] = input;
  _error = 0;
  _det_up_to_date = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rdx
subq (%rsi), %rdx
shrq $0x3, %rdx
pushq $0x1
popq %rsi
callq 0x239a
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x3cc8
xorl %eax, %eax
movb %al, 0x31(%rbx)
movb %al, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3bc8
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::Matrix(Matrix const&, unsigned int)
Matrix::Matrix( const Matrix& m, uint row ){
  resize( 1, m._data[0].size() );
  _data[0] = m._data[row];
  _error = 0;
  _det_up_to_date = 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq 0x8(%rax), %rdx
subq (%rax), %rdx
shrq $0x3, %rdx
pushq $0x1
popq %rsi
callq 0x239a
movl %ebp, %eax
imulq $0x18, %rax, %rsi
addq (%r14), %rsi
movq (%rbx), %rdi
callq 0x3cc8
xorl %eax, %eax
movb %al, 0x31(%rbx)
movb %al, 0x38(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3bc8
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::operator==(Matrix const&)
bool Matrix::operator == ( const Matrix& rhs ){
  if( _m != rhs._m || _n != rhs._n || _error || rhs._error ){
    return 0;
  }
  bool result = 1;
  for( uint i = 0; i < m(); i++ ){
    for( uint j = 0; j < n(); j++ ){
      if( _data[i][j] != rhs._data[i][j] )
	result = false;
    }
  }
  return result;
}

// Assembly:
movl 0x18(%rdi), %ecx
cmpl 0x18(%rsi), %ecx
jne 0x275c
movl 0x1c(%rdi), %edx
cmpl 0x1c(%rsi), %edx
jne 0x275c
cmpb $0x0, 0x31(%rdi)
jne 0x275c
cmpb $0x0, 0x31(%rsi)
je 0x2761
xorl %eax, %eax
andb $0x1, %al
retq
pushq %rbp
pushq %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
movb $0x1, %al
xorl %r8d, %r8d
cmpq %rcx, %r8
je 0x27af
imulq $0x18, %r8, %r9
leaq (%rdi,%r9), %r10
addq %rsi, %r9
xorl %r11d, %r11d
cmpq %r11, %rdx
je 0x27aa
movq (%r10), %rbx
movsd (%rbx,%r11,8), %xmm0
movq (%r9), %rbx
ucomisd (%rbx,%r11,8), %xmm0
setnp %bl
sete %bpl
andb %bl, %bpl
andb %bpl, %al
incq %r11
jmp 0x2781
incq %r8
jmp 0x276e
popq %rbx
popq %rbp
jmp 0x275e
nop
// File: /workspace/github_cpp_makefile_star2_O2/hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::operator<<(double)
Matrix& Matrix::operator << ( double input ){
  //The IO iterators can be an issue here. Currently, resize() handles that.
  if( _m == 0 || _n == 0 || _error ){
    _print_error( "Attempting to input into an empty matrix." );
    _error = 1;
  }
  _data[_m_in][_n_in] = input;
  _n_in++;
  if( _n_in == _n ){
    _n_in = 0;
    _m_in++;
  }
  if( _m_in == _m ){
    _m_in = 0;
  }
  _det_up_to_date = 0;
  return *this;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
sete %cl
movl 0x1c(%rdi), %eax
testl %eax, %eax
sete %dl
orb %cl, %dl
jne 0x27e1
cmpb $0x1, 0x31(%rbx)
jne 0x2822
movsd %xmm0, 0x10(%rsp)
leaq 0x5832(%rip), %rsi      # 0x8020
leaq 0x18(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x3e56
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3e38
leaq 0x18(%rsp), %rdi
callq 0x2090
movb $0x1, 0x31(%rbx)
movl 0x1c(%rbx), %eax
movsd 0x10(%rsp), %xmm0
movl 0x20(%rbx), %ecx
movq (%rbx), %rdx
imulq $0x18, %rcx, %rsi
movl 0x24(%rbx), %edi
movq (%rdx,%rsi), %rdx
movsd %xmm0, (%rdx,%rdi,8)
leal 0x1(%rdi), %edx
movl %edx, 0x24(%rbx)
cmpl %eax, %edx
jne 0x284b
andl $0x0, 0x24(%rbx)
incl %ecx
movl %ecx, 0x20(%rbx)
cmpl 0x18(%rbx), %ecx
jne 0x2854
andl $0x0, 0x20(%rbx)
movb $0x0, 0x38(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::clear()
void Matrix::clear(){
  _m_in = _n_in = _m_out = _n_out = 0; //Reset all IO iterators.
  _error = 0;
  for( uint i = 0; i < _m; i++ ){
    for( uint j = 0; j < _n; j++ ){
      _data[i][j] = 0.0;
    }
  }
  _det_up_to_date = 0;
}

// Assembly:
movb $0x0, 0x31(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movl 0x18(%rdi), %eax
movl 0x1c(%rdi), %ecx
xorl %edx, %edx
cmpq %rax, %rdx
je 0x28b1
imulq $0x18, %rdx, %rsi
addq (%rdi), %rsi
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x28ac
movq (%rsi), %r9
andq $0x0, (%r9,%r8,8)
incq %r8
jmp 0x289a
incq %rdx
jmp 0x288b
movb $0x0, 0x38(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::print()
void Matrix::print(){
  for( uint i = 0; i < _m; i++ ){
    for( uint j = 0; j < _n; j++ ){
      cout << _data[i][j] << " ";  
    }
    cout << endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
movq 0x970a(%rip), %r14      # 0xbfd8
leaq 0x5895(%rip), %r15      # 0x816a
movl 0x18(%rbx), %eax
cmpq %rax, %r12
jae 0x291c
imulq $0x18, %r12, %r13
xorl %ebp, %ebp
movl 0x1c(%rbx), %eax
cmpq %rax, %rbp
jae 0x290f
movq (%rbx), %rax
movq (%rax,%r13), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r14, %rdi
callq 0x21a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2130
incq %rbp
jmp 0x28e3
movq %r14, %rdi
callq 0x20a0
incq %r12
jmp 0x28d5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::print_test[abi:cxx11]()
string Matrix::print_test(){
  std::stringstream ss;
  for( uint i = 0; i < _m; i++ ){
    for( uint j = 0; j < _n; j++ ){
      ss << _data[i][j] << " ";  
    }
  }
  string s = ss.str();
  return s.substr(0, s.size()-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x20c0
leaq 0x40(%rsp), %r15
xorl %r13d, %r13d
leaq 0x580c(%rip), %r12      # 0x816a
movl 0x18(%r14), %eax
cmpq %rax, %r13
jae 0x299f
imulq $0x18, %r13, %rbp
xorl %ebx, %ebx
movl 0x1c(%r14), %eax
cmpq %rax, %rbx
jae 0x299a
movq (%r14), %rax
movq (%rax,%rbp), %rax
movsd (%rax,%rbx,8), %xmm0
movq %r15, %rdi
callq 0x21a0
movq %rax, %rdi
movq %r12, %rsi
callq 0x2130
incq %rbx
jmp 0x296d
incq %r13
jmp 0x295e
leaq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x2190
leaq 0x10(%rsp), %rsi
movq 0x8(%rsi), %rcx
decq %rcx
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2160
leaq 0x10(%rsp), %rdi
callq 0x2090
leaq 0x30(%rsp), %rdi
callq 0x20e0
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2090
jmp 0x2a06
jmp 0x2a03
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::addToRow(Matrix const&, unsigned int)
Matrix Matrix::addToRow( const Matrix& rhs, const uint row ){
  if( (row > 0 && row <= _m) || rhs._m != 1 ){
    Matrix result = *this;
    for( uint i = 0; i < _n; i++ ){
      result._data[row-1][i] = result._data[row-1][i] + rhs._data[0][i];
    }
    return result;
  }
  else {
    _error = 1;
    return *this;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
decl %ebp
cmpl 0x18(%rsi), %ebp
jb 0x2ac0
cmpl $0x1, 0x18(%r14)
jne 0x2ac0
movb $0x1, 0x31(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2708
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2708
movl 0x1c(%r15), %eax
movl %ebp, %ecx
imulq $0x18, %rcx, %rcx
addq (%rbx), %rcx
movq (%r14), %rdx
xorl %esi, %esi
cmpq %rsi, %rax
je 0x2ab2
movq (%rcx), %rdi
movsd (%rdi,%rsi,8), %xmm0
movq (%rdx), %r8
addsd (%r8,%rsi,8), %xmm0
movsd %xmm0, (%rdi,%rsi,8)
incq %rsi
jmp 0x2add
nop
// File: /workspace/github_cpp_makefile_star2_O2/hitc8494[P]Matrix/matrix.cpp
// Function: Matrix::ADDToRow(Matrix const&, unsigned int)
Matrix& Matrix::ADDToRow( const Matrix& rhs, const uint row ){
  if( (row > 0 && row <= _m) || rhs._m != 1 ){
    for( uint i = 0; i < _n; i++ ){
      _data[row-1][i] = _data[row-1][i] + rhs._data[0][i];
    }
  }
  else {
    _error = 1;
  }
  return *this;
}

// Assembly:
movq %rdi, %rax
decl %edx
cmpl 0x18(%rdi), %edx
jb 0x2b13
cmpl $0x1, 0x18(%rsi)
jne 0x2b13
movb $0x1, 0x31(%rax)
retq
movl 0x1c(%rax), %ecx
movl %edx, %edx
imulq $0x18, %rdx, %rdx
addq (%rax), %rdx
movq (%rsi), %rsi
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x2b12
movq (%rdx), %r8
movsd (%r8,%rdi,8), %xmm0
movq (%rsi), %r9
addsd (%r9,%rdi,8), %xmm0
movsd %xmm0, (%r8,%rdi,8)
incq %rdi
jmp 0x2b24