LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::Formula()
Formula::Formula () {
	//Default values - 10 atoms per clause, 10 variables per problem
	VARLIST.reserve(10);
	CLAUSELIST.reserve(10);
	TIMELIMIT = 3600; //1hour = 60mins * 60secs
	TIME_S = 0;
	TIME_E = 0;
	LEVEL = 0;
	UNITS = 0;
	BACKTRACKS = 0;
	DECISIONS = 0;
	ENTAILS = 0;
	UNITCLAUSE = -1;
	CONFLICT = false;
	CONFLICTINGCLAUSE = -1;
	DECSTACK.reserve(10);
	RESTARTS = 0;
	LOG = false;
	WATCH = false;
	heuristic = Heuristic::BK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x60(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %r15, 0x68(%rdi)
movq %r15, 0x60(%rdi)
xorl %eax, %eax
movq %rax, 0x70(%rdi)
leaq 0x88(%rdi), %r12
movups %xmm0, 0x88(%rdi)
movq %rax, 0x98(%rdi)
movl $0xa, %esi
callq 0xb6de
movl $0xa, %esi
movq %r14, %rdi
callq 0xb774
movl $0xe10, 0x30(%rbx)      # imm = 0xE10
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movl $0x0, 0x58(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x78(%rbx)
movb $0x0, 0x7c(%rbx)
movl %eax, 0x80(%rbx)
movl $0xa, %esi
movq %r12, %rdi
callq 0x7034
xorl %eax, %eax
movl %eax, 0xa0(%rbx)
movw $0x0, 0xa4(%rbx)
movl %eax, 0xa8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r13
movq (%r12), %rdi
testq %rdi, %rdi
je 0x77e0
movq 0x98(%rbx), %rsi
subq %rdi, %rsi
callq 0x2240
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2436
movq %r13, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::Formula(CommandLine*)
Formula::Formula ( CommandLine * cline ) {
	//Setting appropriate values and
	VARLIST.reserve(10);
	CLAUSELIST.reserve(10);
	TIMELIMIT = cline->TIME;
	TIME_S = 0;
	TIME_E = 0;
	LEVEL = 0;
	UNITS = 0;
	BACKTRACKS = 0;
	DECISIONS = 0;
	ENTAILS = 0;
	UNITCLAUSE = -1;
	CONFLICT = false;
	CONFLICTINGCLAUSE = -1;
	DECSTACK.reserve(10);
	RESTARTS = 0;
	LOG = cline->LOG;
	WATCH = cline->WATCH;
	heuristic = cline->heuristic;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x60(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %r15, 0x68(%rdi)
movq %r15, 0x60(%rdi)
xorl %eax, %eax
movq %rax, 0x70(%rdi)
leaq 0x88(%rdi), %r13
movups %xmm0, 0x88(%rdi)
movq %rax, 0x98(%rdi)
movl $0xa, %esi
callq 0xb6de
movl $0xa, %esi
movq %r14, %rdi
callq 0xb774
movl 0x30(%r12), %eax
movl %eax, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movl $0x0, 0x58(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x78(%rbx)
movb $0x0, 0x7c(%rbx)
movl %eax, 0x80(%rbx)
movl $0xa, %esi
movq %r13, %rdi
callq 0x7034
movl $0x0, 0xa0(%rbx)
movb 0x2(%r12), %al
movb %al, 0xa4(%rbx)
movb 0x1(%r12), %al
movb %al, 0xa5(%rbx)
movl 0x38(%r12), %eax
movl %eax, 0xa8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r12
movq (%r13), %rdi
testq %rdi, %rdi
je 0x78de
movq 0x98(%rbx), %rsi
subq %rdi, %rsi
callq 0x2240
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x24a2
movq %r12, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::PrintInfo()
void Formula::PrintInfo()
{
	printf("\n");
	printf("Decisions   : %d\n", DECISIONS);
	printf("Units       : %d\n", UNITS);
	printf("Backtracks  : %d\n", BACKTRACKS);
	printf("Entails     : %d\n", ENTAILS);
	//  printf("Number of Levels      : %d\n", LEVEL);
	printf( "Variables   : %zu\n", VARLIST.size()-1 );
	printf( "Clauses     : %zu\n", CLAUSELIST.size() );
	printf("Restarts   : %d\n", RESTARTS);

	printf("\n");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xa, %edi
callq 0x22d0
movl 0x50(%rbx), %esi
leaq 0x4cde(%rip), %rdi      # 0xccc8
xorl %eax, %eax
callq 0x2050
movl 0x54(%rbx), %esi
leaq 0x4cdf(%rip), %rdi      # 0xccda
xorl %eax, %eax
callq 0x2050
movl 0x4c(%rbx), %esi
leaq 0x4ce0(%rip), %rdi      # 0xccec
xorl %eax, %eax
callq 0x2050
movl 0x58(%rbx), %esi
leaq 0x4ce1(%rip), %rdi      # 0xccfe
xorl %eax, %eax
callq 0x2050
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x3, %rsi
decq %rsi
leaq 0x4cd7(%rip), %rdi      # 0xcd10
xorl %eax, %eax
callq 0x2050
movq 0x20(%rbx), %rsi
subq 0x18(%rbx), %rsi
sarq $0x3, %rsi
leaq 0x4cd0(%rip), %rdi      # 0xcd23
xorl %eax, %eax
callq 0x2050
movl 0xa0(%rbx), %esi
leaq 0x4ccf(%rip), %rdi      # 0xcd36
xorl %eax, %eax
callq 0x2050
movl $0xa, %edi
popq %rbx
jmp 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::verifyModel()
bool Formula::verifyModel() {
	bool sat;
	//for every clause check whether at least one literal is satisfied
	for(unsigned int  i=0; i<CLAUSELIST.size(); i++) {
		sat=false;
		for (int j=0;j<CLAUSELIST[i]->ATOM_LIST.size();j++) {
			Literal atom = CLAUSELIST[i]->ATOM_LIST[j];
			if (atom.EQUAL) {
				if (VARLIST[atom.VAR]->ATOMASSIGN[atom.VAL] == 1) {
					sat=true;
					break;
				}
			} else {
				if (VARLIST[atom.VAR]->ATOMASSIGN[atom.VAL] == -1) {
					sat=true;
					break;
				}
			}
		}
		if (!sat)
			return false;
	}
	return true;
}

// Assembly:
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rdx
subq %rcx, %rdx
sete %al
je 0x8135
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq (%rcx), %rsi
movq (%rsi), %r9
movq 0x8(%rsi), %r10
subq %r9, %r10
je 0x812f
sarq $0x3, %rdx
movq (%rdi), %rsi
xorl %edi, %edi
movabsq $-0x5555555555555555, %r8 # imm = 0xAAAAAAAAAAAAAAAB
sarq $0x2, %r10
imulq %r8, %r10
addq $0x8, %r9
movl $0x1, %r11d
xorl %ebx, %ebx
movslq -0x8(%r9), %r14
movslq -0x4(%r9), %r15
movq (%rsi,%r14,8), %r14
movq 0x20(%r14), %r14
movl (%r14,%r15,4), %ebp
testb $0x1, (%r9)
je 0x80f3
cmpl $0x1, %ebp
jne 0x80f8
movb $0x1, %bl
xorl %ebp, %ebp
jmp 0x80fb
cmpl $-0x1, %ebp
je 0x80ed
movb $0x1, %bpl
testb %bpl, %bpl
je 0x8110
addq $0xc, %r9
leaq 0x1(%r11), %r14
cmpq %r11, %r10
movq %r14, %r11
ja 0x80ce
testb $0x1, %bl
je 0x812f
incl %edi
cmpq %rdi, %rdx
setbe %al
jbe 0x812f
movq (%rcx,%rdi,8), %r10
movq (%r10), %r9
movq 0x8(%r10), %r10
subq %r9, %r10
jne 0x80ba
popq %rbx
popq %r14
popq %r15
popq %rbp
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::checkSat()
bool Formula::checkSat () {

	// if some clause in the formula is not satisfied return false

	if ( LOG ) cout << "Checking satisfiability..." << endl;

	int size = CLAUSELIST.size();

	for ( int i = 0; i < size; i++ ) {
		if ( CLAUSELIST[i] -> LEVEL == -1 ) {
			return false;
		}
	}
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0xa4(%rdi)
jne 0x818a
movq 0x7e81(%rip), %r14      # 0xffd0
leaq 0x4bf1(%rip), %rsi      # 0xcd47
movl $0x1a, %edx
movq %r14, %rdi
callq 0x2270
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2180
movq 0x18(%rbx), %rdx
movq 0x20(%rbx), %rcx
subq %rdx, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
setle %al
jle 0x81d0
movq (%rdx), %rsi
cmpl $-0x1, 0x1c(%rsi)
je 0x81d0
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl $0x1, %esi
movq %rsi, %rax
cmpq %rsi, %rcx
je 0x81ca
movq (%rdx,%rax,8), %rdi
leaq 0x1(%rax), %rsi
cmpl $-0x1, 0x1c(%rdi)
jne 0x81b4
cmpq %rcx, %rax
setae %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::chooseLiteral()
Literal Formula::chooseLiteral () {

	/*  Pick a literal which is not yet satisfied, and which satisfies more clauses and removes less literals,
	 *  use literal counts for this. Other heuristics are possible.
	 */

	int max = INT_MIN;
	int tmax = -1;
	int tvar = -1;
	int tval = -1;
	UNITCLAUSE = -1;

	for ( unsigned int i = 0; i < VARLIST.size(); i++ ) {
		if ( VARLIST[i] -> VAL == -1 ) {
			for ( int j = 0; j < VARLIST[i] -> DOMAINSIZE; j++ ) {
				if ( VARLIST[i] -> ATOMASSIGN[j] == 0 ) {
					tmax = VARLIST[i] -> ATOMCNTPOS[j] - VARLIST[i] -> ATOMCNTNEG[j];
					if ( max < tmax ) {
						max = tmax;
						tvar = i;
						tval = j;
					}
				}
			}
		}
	}
	return Literal ( tvar, tval );
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movl $0xffffffff, 0x78(%rdi) # imm = 0xFFFFFFFF
subq %rax, %rcx
je 0x82b4
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
sarq $0x3, %rcx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x80000000, %r8d       # imm = 0x80000000
xorl %esi, %esi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq (%rax,%rsi,8), %r9
cmpl $-0x1, 0x4(%r9)
jne 0x8298
movslq 0x8(%r9), %r10
testq %r10, %r10
jle 0x8298
movq 0x20(%r9), %r11
xorl %ebx, %ebx
cmpl $0x0, (%r11,%rbx,4)
jne 0x8290
movq 0x28(%r9), %r14
movq 0x30(%r9), %r15
movl (%r14,%rbx,4), %ebp
subl (%r15,%rbx,4), %ebp
cmpl %ebp, %r8d
jge 0x8290
movl %esi, %edi
movl %ebx, %edx
movl %ebp, %r8d
incq %rbx
cmpq %rbx, %r10
jne 0x826d
incq %rsi
movl %esi, %r9d
cmpq %r9, %rcx
ja 0x8253
shlq $0x20, %rdx
movl %edi, %eax
orq %rdx, %rax
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x82bb
movq $-0x1, %rax
movb $0x1, %dl
retq
// File: /workspace/github_cpp_makefile_star2_O1/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::chooseLiteralVSIDS()
Literal Formula::chooseLiteralVSIDS () {

	/*  Pick a literal which is not yet satisfied, and which has a maximal vsids counter
	 *
	 *  Positive and negative literals have separate scores
	 */


	double max = -1;
	double tmax = -1;
	int tvar = -1;
	int tval = -1;
	UNITCLAUSE = -1;
	bool equals = false;

	for ( int i = 0; i < VARLIST.size(); i++ ) {
		if ( VARLIST[i] -> VAL == -1 ) {
			for ( int j = 0; j < VARLIST[i] -> DOMAINSIZE; j++ ) {
				if ( VARLIST[i] -> ATOMASSIGN[j] == 0 ) {
					// get score for i=j
					tmax = VARLIST[i]->VSIDS_SCORE[j];
					if (max < tmax) {
						max = tmax;
						tvar = i;
						tval = j;
						equals = true;
					}
					//get score for i!=j
					tmax = VARLIST[i]->VSIDS_SCORE_NEG[j];
					if (max < tmax) {
						max = tmax;
						tvar = i;
						tval = j;
						equals = false;
					}
				}
			}
		}
	}
	return Literal ( tvar, equals, tval );
}

// Assembly:
movl $0xffffffff, 0x78(%rdi) # imm = 0xFFFFFFFF
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x8373
pushq %r14
pushq %rbx
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movsd 0x49b7(%rip), %xmm0     # 0xcca8
xorl %edi, %edi
xorl %edx, %edx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq (%rax,%rdi,8), %r9
cmpl $-0x1, 0x4(%r9)
jne 0x835a
movslq 0x8(%r9), %r10
testq %r10, %r10
jle 0x835a
movq 0x20(%r9), %r11
xorl %ebx, %ebx
cmpl $0x0, (%r11,%rbx,4)
jne 0x8352
movq 0x38(%r9), %r14
movsd (%r14,%rbx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x8337
movb $0x1, %dl
movl %edi, %r8d
movl %ebx, %esi
movapd %xmm1, %xmm0
movq 0x40(%r9), %r14
movsd (%r14,%rbx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x8352
xorl %edx, %edx
movl %edi, %r8d
movl %ebx, %esi
movapd %xmm1, %xmm0
incq %rbx
cmpq %rbx, %r10
jne 0x8315
incq %rdi
cmpq %rcx, %rdi
jne 0x82fb
andb $0x1, %dl
shlq $0x20, %rsi
movl %r8d, %eax
orq %rsi, %rax
popq %rbx
popq %r14
retq
movq $-0x1, %rax
xorl %edx, %edx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::chooseLiteralVSIDS_allPos()
Literal Formula::chooseLiteralVSIDS_allPos () {

	/*  Pick a literal which is not yet satisfied, and which has a maximal vsids counter
	 *
	 *  Negative literals are counted as disjunctions of positive literals
	 */


	double max = -1;
	double tmax = -1;
	int tvar = -1;
	int tval = -1;
	UNITCLAUSE = -1;

	for ( int i = 0; i < VARLIST.size(); i++ ) {
		if ( VARLIST[i] -> VAL == -1 ) {
			for ( int j = 0; j < VARLIST[i] -> DOMAINSIZE; j++ ) {
				if ( VARLIST[i] -> ATOMASSIGN[j] == 0 ) {
					tmax = VARLIST[i]->VSIDS_SCORE[j];
					if (max < tmax) {
						max = tmax;
						tvar = i;
						tval = j;
					}
				}
			}
		}
	}
	return Literal ( tvar, true, tval );
}

// Assembly:
movl $0xffffffff, 0x78(%rdi) # imm = 0xFFFFFFFF
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x8409
pushq %rbx
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movsd 0x48fd(%rip), %xmm0     # 0xcca8
xorl %esi, %esi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq (%rax,%rsi,8), %r8
cmpl $-0x1, 0x4(%r8)
jne 0x83f5
movslq 0x8(%r8), %r9
testq %r9, %r9
jle 0x83f5
movq 0x20(%r8), %r10
xorl %r11d, %r11d
cmpl $0x0, (%r10,%r11,4)
jne 0x83ed
movq 0x38(%r8), %rbx
movsd (%rbx,%r11,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x83ed
movl %esi, %edi
movl %r11d, %edx
movapd %xmm1, %xmm0
incq %r11
cmpq %r11, %r9
jne 0x83cd
incq %rsi
cmpq %rcx, %rsi
jne 0x83b2
shlq $0x20, %rdx
movl %edi, %eax
orq %rdx, %rax
popq %rbx
jmp 0x8410
movq $-0x1, %rax
movb $0x1, %dl
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::hasAtom(Clause*, Literal)
bool Formula::hasAtom ( Clause* clause, Literal atom ) {

	// true if clause contains the atom

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

		Literal c_atom = clause -> ATOM_LIST[i];

		if ( atom == c_atom )
			return true;
	}
	return false;
}

// Assembly:
movq (%rsi), %rdi
movq 0x8(%rsi), %r9
subq %rdi, %r9
setne %al
je 0x9022
movq %rdx, %rsi
shrq $0x20, %rsi
sarq $0x2, %r9
movabsq $-0x5555555555555555, %r8 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r9, %r8
xorl %r9d, %r9d
cmpq $0x1, %r8
sbbq %r8, %r9
addq $0x8, %rdi
movl $0x1, %r10d
cmpl %edx, -0x8(%rdi)
jne 0x9008
cmpl %esi, -0x4(%rdi)
jne 0x9008
cmpb %cl, (%rdi)
je 0x9022
cmpq %r10, %r8
seta %al
addq $0xc, %rdi
leaq (%r9,%r10), %r11
incq %r11
incq %r10
cmpq $0x1, %r11
jne 0x8ffa
andb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r13d
movq %rdx, %r15
movq %rsi, %r12
movl $0x38, %edi
callq 0x2230
movq %rax, %r14
movq %rax, %rdi
callq 0x6e64
movq (%r12), %rax
cmpq %rax, 0x8(%r12)
je 0x90ca
movl $0x1, %ebp
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,4), %rsi
movb 0x8(%rax,%rcx,4), %al
cmpl %r15d, %esi
jne 0x9098
movq %rsi, %rcx
xorq %r15, %rcx
shrq $0x20, %rcx
jne 0x908d
movl %eax, %ecx
xorb %r13b, %cl
testb $0x1, %cl
jne 0x9098
jmp 0x90a3
testb $0x1, %r13b
sete %cl
testb %cl, %al
jne 0x90a3
movzbl %al, %edx
movq %r14, %rdi
callq 0x6f6c
movl %ebp, %ecx
movq (%r12), %rax
movq 0x8(%r12), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x9064
movl %r13d, 0x4(%rsp)
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x915c
movl $0x1, %ebp
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,4), %r12
movb 0x8(%rax,%rcx,4), %al
cmpl %r15d, %r12d
jne 0x9113
movq %r12, %rcx
xorq %r15, %rcx
shrq $0x20, %rcx
jne 0x9108
movl %eax, %ecx
xorb 0x4(%rsp), %cl
jmp 0x910e
movl %eax, %ecx
andb 0x4(%rsp), %cl
testb $0x1, %cl
jne 0x9137
movzbl %al, %r13d
movq %r14, %rsi
movq %r12, %rdx
movl %r13d, %ecx
callq 0x8fbe
testb %al, %al
jne 0x9137
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x6f6c
movl %ebp, %ecx
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x90e3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x38, %esi
movq %r14, %rdi
callq 0x2240
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x91b1
xorq %rsi, %rcx
shrq $0x20, %rcx
jne 0x919f
xorb %dl, %r8b
testb $0x1, %r8b
je 0x91b1
movb $0x1, %al
retq
testb $0x1, %dl
je 0x91b1
testb $0x1, %r8b
je 0x91b1
testq %rcx, %rcx
je 0x9193
jmp 0x919c
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0xa4(%rdi)
jne 0x95d0
movq 0x6a3b(%rip), %r15      # 0xffd0
leaq 0x3823(%rip), %rsi      # 0xcdbf
movl $0x1a, %edx
movq %r15, %rdi
callq 0x2270
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2180
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rsi
testl %esi, %esi
jle 0x9640
movq (%rbx), %rcx
movl 0x48(%rbx), %edx
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
shlq $0x2, %rsi
leaq (%rsi,%rsi,2), %rsi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %edi, %edi
movslq (%rax,%rdi), %r9
movslq 0x4(%rax,%rdi), %r10
movq (%rcx,%r9,8), %r9
movq 0x18(%r9), %r9
movl (%r9,%r10,4), %r10d
cmpl %r10d, %r8d
movl %r10d, %r9d
cmovgl %r8d, %r9d
cmpl %r10d, %edx
cmovlel %r8d, %r9d
addq $0xc, %rdi
movl %r9d, %r8d
cmpq %rdi, %rsi
jne 0x960c
jmp 0x9646
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
xorl %eax, %eax
cmpl $-0x1, %r9d
cmovnel %r9d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x2, %rcx
jb 0x9b47
movl $0x1, %edx
movl $0x1, %r8d
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
movq (%rax,%r8,8), %r8
cmpl $0x0, 0x8(%r8)
jle 0x9b3d
movq 0x18(%r8), %r9
xorl %r10d, %r10d
cmpl %esi, (%r9,%r10,4)
jle 0x9b31
movl $0xffffffff, 0x4(%r8)   # imm = 0xFFFFFFFF
movq 0x20(%r8), %r11
movl $0x0, (%r11,%r10,4)
movl %edi, (%r9,%r10,4)
movq 0x48(%r8), %r11
movl %edi, (%r11,%r10,4)
incq %r10
movslq 0x8(%r8), %r11
cmpq %r11, %r10
jl 0x9b0b
incl %edx
movq %rdx, %r8
cmpq %rdx, %rcx
ja 0x9af9
movq 0x90(%rbx), %rcx
subq 0x88(%rbx), %rcx
sarq $0x2, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
testl %eax, %eax
jle 0x9be0
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq 0x1(%rax), %r14
shlq $0x2, %rax
leaq (%rax,%rax,2), %r15
movq %r15, %r12
negq %r12
movq (%rbx), %rcx
movq 0x88(%rbx), %rax
movslq -0xc(%rax,%r15), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x20(%rcx), %rcx
movslq -0x8(%rax,%r15), %rdx
cmpl $0x0, (%rcx,%rdx,4)
jne 0x9bcf
leaq (%rax,%r15), %rsi
movq 0x90(%rbx), %rdx
cmpq %rdx, %rsi
je 0x9bc7
leaq (%rax,%r15), %rdi
addq $-0xc, %rdi
subq %rax, %rdx
addq %r12, %rdx
callq 0x2350
addq $-0xc, 0x90(%rbx)
decq %r14
addq $-0xc, %r15
addq $0xc, %r12
cmpq $0x1, %r14
jg 0x9b82
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rcx
movq 0x8(%rsi), %rax
subq %rcx, %rax
je 0x9fb0
sarq $0x2, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
movq (%rdi), %rsi
cmpq $0x1, %rdx
adcq $0x0, %rdx
addq $0x4, %rcx
xorl %edi, %edi
xorl %eax, %eax
xorl %r8d, %r8d
movslq -0x4(%rcx), %r9
movslq (%rcx), %r10
movq (%rsi,%r9,8), %r9
movq 0x10(%r9), %r9
movl (%r9,%r10,4), %r9d
cmpl %r9d, %r8d
cmovlel %r9d, %r8d
cmovll %edi, %eax
incq %rdi
addq $0xc, %rcx
cmpq %rdi, %rdx
jne 0x9f86
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
movq %rsi, -0x8(%rsp)
movq 0x8(%rsi), %rdx
subq %rax, %rdx
je 0xa07f
sarq $0x2, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
movq (%rdi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x8, %rax
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
xorl %edi, %edi
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rsp)
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movslq -0x8(%rax), %rbx
movslq -0x4(%rax), %r8
movb (%rax), %sil
movq (%rdx,%rbx,8), %r14
movq 0x10(%r14), %r14
movl (%r14,%r8,4), %r13d
cmpl %r13d, %r11d
jge 0xa057
movl %ebx, %r14d
movl %edi, -0xc(%rsp)
movl %r9d, %r10d
movl %r12d, %ebx
movl %r8d, %r9d
movl %esi, %edi
movl %r11d, %ebp
movl %r13d, %r11d
jmp 0xa06e
movl %r12d, %r14d
cmpl %r13d, %ebp
jge 0xa06b
movl %esi, -0xc(%rsp)
movl %r8d, %r10d
movl %r13d, %ebp
jmp 0xa06e
movl %r15d, %ebx
addq $0xc, %rax
movl %ebx, %r15d
movl %r14d, %r12d
decq %rcx
jne 0xa021
jmp 0xa0a0
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rsp)
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
xorl %edi, %edi
movq -0x8(%rsp), %rax
movl %r14d, 0x20(%rax)
movl %r9d, 0x24(%rax)
movb %dil, 0x28(%rax)
movl %ebx, 0x2c(%rax)
movl %r10d, 0x30(%rax)
movl -0xc(%rsp), %ecx
movb %cl, 0x34(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpb $0x0, 0x7c(%rdi)
jne 0xa1cb
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x60(%rdi), %r15
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
movq (%r15), %r14
cmpq %r15, %r14
je 0xa1c2
movslq 0x10(%r14), %r13
movl %r13d, 0x78(%rbx)
decq 0x70(%rbx)
movq %r14, %rdi
callq 0x2360
movl $0x18, %esi
movq %r14, %rdi
callq 0x2240
movq (%rbx), %rcx
movq 0x18(%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0x20(%rax), %rsi
movslq %esi, %rdx
movq (%rcx,%rdx,8), %rdx
movq 0x20(%rdx), %rdx
movq %rsi, %rdi
sarq $0x20, %rdi
cmpl $0x0, (%rdx,%rdi,4)
je 0xa1aa
movq 0x8(%rax), %rdx
subq (%rax), %rdx
sarq $0x2, %rdx
imulq %r12, %rdx
cmpq $0x2, %rdx
jb 0xa1b8
movq 0x2c(%rax), %rsi
movslq %esi, %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x20(%rcx), %rcx
movq %rsi, %rdx
sarq $0x20, %rdx
cmpl $0x0, (%rcx,%rdx,4)
jne 0xa1b8
movl 0x34(%rax), %edx
jmp 0xa1ad
movl 0x28(%rax), %edx
movq %rbx, %rdi
callq 0xa1cc
incl 0x54(%rbx)
cmpb $0x1, 0x7c(%rbx)
jne 0xa120
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %rsi
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subq %rdx, %rsi
je 0xa835
pushq %rbx
sarq $0x3, %rsi
movq (%rdi), %rdi
movl $0x1, %r8d
xorl %r9d, %r9d
movq (%rdx,%r9,8), %r10
movq 0x20(%r10), %r9
movslq %r9d, %r11
movq (%rdi,%r11,8), %r11
movq 0x20(%r11), %r11
movq %r9, %rbx
sarq $0x20, %rbx
cmpl $0x0, (%r11,%rbx,4)
je 0xa839
movl %r8d, %r9d
incl %r8d
cmpq %r9, %rsi
ja 0xa805
xorl %edx, %edx
jmp 0xa843
xorl %edx, %edx
jmp 0xa844
andq %r9, %rcx
movb 0x28(%r10), %dl
movl %r9d, %eax
popq %rbx
orq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
xorl %esi, %esi
subq %rax, %rcx
je 0xa908
pushq %r15
pushq %r14
pushq %rbx
sarq $0x3, %rcx
movq (%rdi), %rdi
movabsq $-0x5555555555555555, %r8 # imm = 0xAAAAAAAAAAAAAAAB
movq (%rax,%rsi,8), %r14
movl 0x1c(%r14), %r11d
movb $0x1, %bl
cmpl $-0x1, %r11d
jne 0xa8df
movq (%r14), %r15
movq 0x8(%r14), %r14
subq %r15, %r14
je 0xa8df
sarq $0x2, %r14
imulq %r8, %r14
decq %r14
addq $0x8, %r15
movq %r15, %rdx
movq -0x8(%r15), %r9
movslq %r9d, %r10
movq (%rdi,%r10,8), %r10
movq 0x20(%r10), %r10
movq %r9, %rbx
sarq $0x20, %rbx
cmpl $0x0, (%r10,%rbx,4)
setne %bl
je 0xa8d6
subq $0x1, %r14
setb %r10b
cmpl $-0x1, %r11d
jne 0xa8d6
leaq 0xc(%rdx), %r15
testb %r10b, %r10b
je 0xa89c
movq %r9, %r10
shrq $0x20, %r10
movb (%rdx), %dl
testb %bl, %bl
je 0xa8f8
incl %esi
cmpq %rsi, %rcx
ja 0xa871
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
shlq $0x20, %r10
movl %r9d, %eax
orq %r10, %rax
popq %rbx
popq %r14
popq %r15
retq
movq $-0x1, %rax
xorl %edx, %edx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpb $0x0, 0x7c(%rdi)
jne 0xb493
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x60(%rdi), %r15
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
movq (%r15), %r14
cmpq %r15, %r14
je 0xb48a
movslq 0x10(%r14), %r13
movl %r13d, 0x78(%rbx)
decq 0x70(%rbx)
movq %r14, %rdi
callq 0x2360
movl $0x18, %esi
movq %r14, %rdi
callq 0x2240
movq 0x18(%rbx), %rax
movq (%rax,%r13,8), %rcx
cmpl $-0x1, 0x1c(%rcx)
je 0xb435
cmpb $0x1, 0x7c(%rbx)
jne 0xb3f2
jmp 0xb48a
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
je 0xb42d
sarq $0x2, %rdx
imulq %r12, %rdx
movq (%rbx), %rdi
cmpq $0x1, %rdx
adcq $0x0, %rdx
addq $0x8, %rax
movslq -0x8(%rax), %rsi
movslq -0x4(%rax), %rcx
movq (%rdi,%rsi,8), %r8
movq 0x20(%r8), %r8
cmpl $0x0, (%r8,%rcx,4)
je 0xb47a
addq $0xc, %rax
decq %rdx
jne 0xb458
jmp 0xb42d
movzbl (%rax), %edx
incl 0x54(%rbx)
movq %rbx, %rdi
callq 0x8414
jmp 0xb42d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq (%rdi), %rax
movslq %r14d, %rcx
movq (%rax,%rcx,8), %rax
movq %rsi, %rcx
sarq $0x20, %rcx
notb %dl
movzbl %dl, %edx
andl $0x1, %edx
movq 0x50(%rax,%rdx,8), %rax
movq (%rax,%rcx,8), %r13
testq %r13, %r13
je 0xb944
movq %rdi, %r15
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
cmpb $0x0, 0x7c(%r15)
jne 0xb944
movq %r13, %rsi
movq 0x8(%r13), %r13
movslq (%rsi), %rax
movq (%r15), %rdi
movq 0x18(%r15), %rcx
movq (%rcx,%rax,8), %rdx
movq 0x20(%rdx), %rcx
movzbl 0x28(%rdx), %eax
movl %eax, %r8d
andl $0x1, %r8d
decl %r8d
orl $0x1, %r8d
movslq %ecx, %r9
movq (%rdi,%r9,8), %r9
movq 0x20(%r9), %r9
movq %rcx, %r10
sarq $0x20, %r10
cmpl %r8d, (%r9,%r10,4)
je 0xb93b
movq 0x2c(%rdx), %r8
movq 0x8(%rdx), %r10
subq (%rdx), %r10
movb 0x34(%rdx), %r9b
sarq $0x2, %r10
imulq %r12, %r10
cmpq $0x2, %r10
jb 0xb902
movzbl %r9b, %r10d
andl $0x1, %r10d
decl %r10d
orl $0x1, %r10d
movslq %r8d, %r11
movq (%rdi,%r11,8), %rdi
movq 0x20(%rdi), %rdi
movq %r8, %r11
sarq $0x20, %r11
cmpl %r10d, (%rdi,%r11,4)
jne 0xb902
movq %r8, 0x20(%rdx)
movb %r9b, 0x28(%rdx)
movslq (%rsi), %rdx
movq 0x18(%r15), %rsi
movq (%rsi,%rdx,8), %rdx
movq %rcx, 0x2c(%rdx)
movb %al, 0x34(%rdx)
jmp 0xb93b
cmpq %r14, %r8
sete %dil
cmpb %bl, %r9b
sete %r10b
andb %dil, %r10b
cmpb $0x1, %r10b
jne 0xb933
movq %r8, 0x20(%rdx)
movb %r9b, 0x28(%rdx)
movslq (%rsi), %rdx
movq 0x18(%r15), %rdi
movq (%rdi,%rdx,8), %rdx
movq %rcx, 0x2c(%rdx)
movb %al, 0x34(%rdx)
movq %r15, %rdi
callq 0xa912
testq %r13, %r13
jne 0xb850
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x118, %rsp            # imm = 0x118
cmpl $0x1, %edi
jg 0x1355
leaq 0xd2d(%rip), %rdi       # 0x2078
callq 0x1040
jmp 0x1415
movq %rsi, %rbx
leaq -0x2c(%rbp), %rsi
movl $0x0, (%rsi)
movq 0x8(%rbx), %rdi
callq 0x11fc
testq %rax, %rax
je 0x1403
movq %rax, %r12
movl -0x2c(%rbp), %r14d
leal (%r14,%r14), %r13d
movq %r13, %rdi
callq 0x10b0
testq %rax, %rax
je 0x1430
movq %rax, %r15
movq %r14, -0x38(%rbp)
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x1090
leaq 0x2cf2(%rip), %r8       # 0x40a0
movq %r12, %rdi
movq -0x38(%rbp), %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x17f5
movq %rax, %r12
leaq -0x140(%rbp), %r13
movl $0x100, %edx            # imm = 0x100
movq %r13, %rdi
xorl %esi, %esi
callq 0x1090
movq 0x8(%rbx), %rcx
leaq 0xc68(%rip), %rdx       # 0x204c
movl $0x100, %esi            # imm = 0x100
movq %r13, %rdi
xorl %eax, %eax
callq 0x1080
movq %r13, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x12ae
jmp 0x141b
movq 0x8(%rbx), %rsi
leaq 0xc1c(%rip), %rdi       # 0x202a
xorl %eax, %eax
callq 0x1070
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc07(%rip), %rdi       # 0x203e
callq 0x10e0
jmp 0x1415
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x411c
testb %al, %al
jne 0x3a5e
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
testq %r14, %r14
je 0x3a48
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4fca
movq %rax, %rdi
callq 0x4124
testb %al, %al
je 0x3a48
movq %r15, %rdi
movq %r12, %rsi
callq 0x3c86
decq %r14
jne 0x3a21
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3a5e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3a88
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x5650
movq %rbx, %rdi
movl %ebp, %esi
callq 0x58e8
movl %eax, %ebp
movq (%r15), %r13
cmpq %r13, 0x8(%r15)
je 0x3ae5
leaq 0x2703(%rip), %r12      # 0x61ca
movq (%r13), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x5686
addq $0x20, %r13
cmpq 0x8(%r15), %r13
jne 0x3ac7
movsbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x58f4
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %esi # imm = 0xAAAAAAAB
movq 0x8(%rax), %rdx
subq (%rax), %rdx
shrq $0x3, %rdx
callq 0x240e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4154
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 0x4106
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rdx
subq (%rsi), %rdx
shrq $0x3, %rdx
movl $0x1, %esi
callq 0x240e
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x42cc
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 0x4106
movq %r14, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq 0x8(%rax), %rdx
subq (%rax), %rdx
shrq $0x3, %rdx
movl $0x1, %esi
callq 0x240e
movl %ebp, %eax
leaq (%rax,%rax,2), %rsi
shlq $0x3, %rsi
addq (%r14), %rsi
movq (%rbx), %rdi
callq 0x42cc
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 0x4106
movq %r14, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28e4
movl 0x1c(%rdi), %edx
cmpl 0x1c(%rsi), %edx
jne 0x28e4
cmpb $0x0, 0x31(%rdi)
jne 0x28e4
cmpb $0x0, 0x31(%rsi)
je 0x28e9
xorl %eax, %eax
andb $0x1, %al
retq
testq %rcx, %rcx
je 0x2942
pushq %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
movb $0x1, %al
xorl %r8d, %r8d
xorl %r9d, %r9d
testq %rdx, %rdx
je 0x2937
leaq (,%r9,8), %r10
leaq (%r10,%r10,2), %r11
movq (%rdi,%r11), %r10
movq (%rsi,%r11), %r11
xorl %ebx, %ebx
movsd (%r10,%rbx,8), %xmm0
ucomisd (%r11,%rbx,8), %xmm0
movzbl %al, %eax
cmovnel %r8d, %eax
cmovpl %r8d, %eax
incq %rbx
cmpq %rbx, %rdx
jne 0x2918
incq %r9
cmpq %rcx, %r9
jne 0x28fd
popq %rbx
jmp 0x28e6
movb $0x1, %al
jmp 0x28e6
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
je 0x296e
cmpl $0x0, 0x1c(%rbx)
je 0x296e
cmpb $0x1, 0x31(%rbx)
jne 0x29c4
movsd %xmm0, 0x8(%rsp)
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x66ac(%rip), %rsi      # 0x9030
leaq 0x66ce(%rip), %rdx      # 0x9059
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x4c6c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4424
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x29ba
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2140
movb $0x1, 0x31(%rbx)
movsd 0x8(%rsp), %xmm0
movl 0x20(%rbx), %eax
movq (%rbx), %rcx
leaq (%rax,%rax,2), %rdx
movl 0x24(%rbx), %esi
movq (%rcx,%rdx,8), %rcx
movsd %xmm0, (%rcx,%rsi,8)
leal 0x1(%rsi), %ecx
movl %ecx, 0x24(%rbx)
cmpl 0x1c(%rbx), %ecx
jne 0x29f1
movl $0x0, 0x24(%rbx)
incl %eax
movl %eax, 0x20(%rbx)
movl 0x20(%rbx), %eax
cmpl 0x18(%rbx), %eax
jne 0x2a00
movl $0x0, 0x20(%rbx)
movb $0x0, 0x38(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2a2b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x31(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movl 0x18(%rdi), %eax
testq %rax, %rax
je 0x2a89
movl 0x1c(%rbx), %r15d
movq (%rbx), %r12
movq %r15, %r14
shlq $0x3, %r14
shlq $0x3, %rax
leaq (%rax,%rax,2), %r13
xorl %ebp, %ebp
testl %r15d, %r15d
je 0x2a80
movq (%r12,%rbp), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x20a0
addq $0x18, %rbp
cmpq %rbp, %r13
jne 0x2a6d
movb $0x0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0x18(%rdi)
je 0x2b40
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
movq 0xa51a(%rip), %r14      # 0xcfd8
leaq 0x66b5(%rip), %r15      # 0x917a
cmpl $0x0, 0x1c(%rbx)
je 0x2b00
leaq (%r12,%r12,2), %r13
xorl %ebp, %ebp
movq (%rbx), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r14, %rdi
callq 0x21b0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
incq %rbp
movl 0x1c(%rbx), %eax
cmpq %rax, %rbp
jb 0x2ad1
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
incq %r12
movl 0x18(%rbx), %eax
cmpq %rax, %r12
jb 0x2ac5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop