LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: istellartech[P]OpenTsiolkovsky/src/coordinate_transform.cpp
// Function: velECI_init(Eigen::Matrix<double, 3, 1, 0, 3, 1>, Eigen::Matrix<double, 3, 1, 0, 3, 1>)
Vector3d velECI_init(Vector3d vel_ECEF_NEDframe_, Vector3d posLLH_){
    double second = 0.0;
    Matrix3d dcmECI2ECEF_;
    Matrix3d dcmECEF2NED_;
    Matrix3d dcmECI2NED_;
    Matrix3d dcmNED2ECI_;
    Vector3d posECI_init_;
    posECI_init_ = posECI_init(posLLH_);
    dcmECI2ECEF_ = dcmECI2ECEF(second);
    dcmECEF2NED_ = dcmECEF2NED(posLLH_);
    dcmECI2NED_ = dcmECI2NED(dcmECEF2NED_, dcmECI2ECEF_);
    dcmNED2ECI_ = dcmECI2NED_.transpose();
    return vel_ECI_ECIframe(dcmNED2ECI_, vel_ECEF_NEDframe_, posECI_init_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3b0, %rsp            # imm = 0x3B0
movq %rdx, -0x3a8(%rbp)
movq %rsi, -0x3a0(%rbp)
movq %rdi, -0x398(%rbp)
movq %rdi, %rax
movq %rax, -0x390(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1dbe0
leaq -0xb0(%rbp), %rdi
callq 0x1dbe0
leaq -0xf8(%rbp), %rdi
callq 0x1dbe0
leaq -0x140(%rbp), %rdi
callq 0x1dbe0
leaq -0x158(%rbp), %rdi
callq 0x1d670
movq -0x3a8(%rbp), %rsi
leaq -0x188(%rbp), %rdi
callq 0x1f0e0
leaq -0x170(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x4c8f0
leaq -0x158(%rbp), %rdi
leaq -0x170(%rbp), %rsi
callq 0x20420
movsd -0x20(%rbp), %xmm0
leaq -0x1d0(%rbp), %rdi
callq 0x4ab30
leaq -0x68(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x20370
movq -0x3a8(%rbp), %rsi
leaq -0x230(%rbp), %rdi
callq 0x1f0e0
leaq -0x218(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x4b180
leaq -0xb0(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x20370
leaq -0x2c0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x203a0
leaq -0x308(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x203a0
leaq -0x278(%rbp), %rdi
leaq -0x2c0(%rbp), %rsi
leaq -0x308(%rbp), %rdx
callq 0x4b460
leaq -0xf8(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x20370
leaq -0xf8(%rbp), %rdi
callq 0x20450
movq %rax, -0x310(%rbp)
leaq -0x140(%rbp), %rdi
leaq -0x310(%rbp), %rsi
callq 0x20480
leaq -0x358(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x203a0
movq -0x3a0(%rbp), %rsi
leaq -0x370(%rbp), %rdi
callq 0x1f0e0
leaq -0x388(%rbp), %rdi
leaq -0x158(%rbp), %rsi
callq 0x1f0e0
movq -0x398(%rbp), %rdi
leaq -0x358(%rbp), %rsi
leaq -0x370(%rbp), %rdx
leaq -0x388(%rbp), %rcx
callq 0x4c690
movq -0x390(%rbp), %rax
addq $0x3b0, %rsp            # imm = 0x3B0
popq %rbp
retq
nopw (%rax,%rax)
// File: istellartech[P]OpenTsiolkovsky/src/coordinate_transform.cpp
// Function: distance_surface(Eigen::Matrix<double, 3, 1, 0, 3, 1>, Eigen::Matrix<double, 3, 1, 0, 3, 1>)
double distance_surface(Vector3d pos0_LLH_, Vector3d pos1_LLH_){
    double const earth_radius = 6378137; // 地球半径 m
    Vector3d pos0_ECEF_ = posECEF(pos0_LLH_);
    Vector3d pos1_ECEF_ = posECEF(pos1_LLH_);
    double theta = acos(pos0_ECEF_.dot(pos1_ECEF_) /
                        pos0_ECEF_.norm() / pos1_ECEF_.norm()); // radius
    return earth_radius * theta;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rax, -0x98(%rbp)
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movsd 0xcba8(%rip), %xmm0     # 0x59750
movsd %xmm0, -0x18(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1f0e0
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4c340
movq -0x98(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x1f0e0
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x4c340
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4e2c0
movsd %xmm0, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x205d0
movaps %xmm0, %xmm1
movsd -0x90(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x88(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x205d0
movaps %xmm0, %xmm1
movsd -0x88(%rbp), %xmm0
divsd %xmm1, %xmm0
callq 0x6430
movsd %xmm0, -0x80(%rbp)
movsd 0xcb11(%rip), %xmm0     # 0x59750
mulsd -0x80(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Core/Redux.h
// Function: Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<double>, Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs2_op<double>, Eigen::Matrix<double, 2, 1, 0, 2, 1> const>, 3, 2>::run(Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs2_op<double>, Eigen::Matrix<double, 2, 1, 0, 2, 1> const> const&, Eigen::internal::scalar_sum_op<double> const&)
static EIGEN_STRONG_INLINE Scalar run(const Derived& mat, const Func& func)
  {
    eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix");
    Scalar res = func.predux(redux_vec_unroller<Func, Derived, 0, Size / PacketSize>::run(mat,func));
    if (VectorizedSize != Size)
      res = func(res,redux_novec_unroller<Func, Derived, VectorizedSize, Size-VectorizedSize>::run(mat,func));
    return res;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4f0d0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x31(%rbp)
jle 0x4f055
movq -0x8(%rbp), %rdi
callq 0x4f0f0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x31(%rbp)
jle 0x4f055
movb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x4f055
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x4f05e
jmp 0x4f060
jmp 0x4f07f
leaq 0xb1ce(%rip), %rdi      # 0x5a235
leaq 0xb207(%rip), %rsi      # 0x5a275
movl $0x12e, %edx            # imm = 0x12E
leaq 0xb21d(%rip), %rcx      # 0x5a297
callq 0x62f0
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4f130
movq -0x40(%rbp), %rdi
movapd %xmm0, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x4f110
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: akinanop[P]mvl-solver/src/QuadraticEncode.cc
// Function: Fact(int)
inline int Fact(int n)
{
  int temp = 1;
  for(int x=1; x<n+1; x++)
    temp *= x;
  return temp;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl $0x1, -0x8(%rsp)
movl $0x1, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl -0x4(%rsp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0xaa7d
movl -0xc(%rsp), %eax
imull -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xaa54
movl -0x8(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: akinanop[P]mvl-solver/src/Clause.cc
// Function: Clause::Print()
void Clause::Print()
{
  for(int i=0; i<ATOM_LIST.size(); i++)
    {
      ATOM_LIST[i].Print();
      // cout<<" ";
    }
  cout<<endl;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xb890
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xb660
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xb8b0
movq %rax, %rdi
callq 0xb8d0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xb61b
movq 0x12969(%rip), %rdi     # 0x1dfd0
movq 0x12952(%rip), %rsi     # 0x1dfc0
callq 0x2260
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: akinanop[P]mvl-solver/src/Variable.cc
// Function: Variable::Variable()
Variable::Variable()
{
	VAR = -1;
	VAL = -1;
	DOMAINSIZE = -1;
	ATOMLEVEL = NULL;
	ATOMASSIGN = NULL;
	ATOMCNTPOS = NULL;
	ATOMCNTNEG = NULL;
	VSIDS_SCORE = NULL;
	VSIDS_SCORE_NEG = NULL;
	ATOMWATCHPOS = NULL;
	ATOMWATCHNEG = NULL;
	ATOMRECPOS = NULL;
	ATOMRECNEG = NULL;
	ATOMINDEX = NULL;
	CLAUSEID = NULL;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x68(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x48(%rax)
retq
nop
// File: akinanop[P]mvl-solver/src/Variable.cc
// Function: Variable::~Variable()
Variable::~Variable()
{
	delete [] ATOMLEVEL;
	delete [] ATOMASSIGN;
	delete [] ATOMCNTPOS;
	delete [] ATOMCNTNEG;
	delete [] VSIDS_SCORE;
	delete [] VSIDS_SCORE_NEG;
	delete [] CLAUSEID;

	for(int i=0; i<DOMAINSIZE; i++)
	{
		VARRECORD * temp = ATOMWATCHPOS[i];
		VARRECORD * temp2;
		while(temp)
		{
			temp2 = temp;
			temp = temp->next;
			delete temp2;
		}
		temp = ATOMWATCHNEG[i];
		while(temp)
		{
			temp2 = temp;
			temp = temp->next;
			delete temp2;
		}
		delete ATOMWATCHPOS[i];
		delete ATOMWATCHNEG[i];
	}
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x60(%rsp)
cmpq $0x0, %rax
je 0xc915
movq 0x60(%rsp), %rdi
callq 0x2310
movq 0x58(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, %rax
je 0xc933
movq 0x50(%rsp), %rdi
callq 0x2310
movq 0x58(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x48(%rsp)
cmpq $0x0, %rax
je 0xc951
movq 0x48(%rsp), %rdi
callq 0x2310
movq 0x58(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, %rax
je 0xc96f
movq 0x40(%rsp), %rdi
callq 0x2310
movq 0x58(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
je 0xc98d
movq 0x38(%rsp), %rdi
callq 0x2310
movq 0x58(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0xc9ab
movq 0x30(%rsp), %rdi
callq 0x2310
movq 0x58(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0xc9c9
movq 0x28(%rsp), %rdi
callq 0x2310
movl $0x0, 0x7c(%rsp)
movq 0x58(%rsp), %rcx
movl 0x7c(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0xcafd
movq 0x58(%rsp), %rax
movq 0x50(%rax), %rax
movslq 0x7c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x70(%rsp)
je 0xca3b
movq 0x70(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0xca39
movq 0x20(%rsp), %rdi
movl $0x18, %esi
callq 0x2240
jmp 0xc9fa
movq 0x58(%rsp), %rax
movq 0x58(%rax), %rax
movslq 0x7c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x70(%rsp)
je 0xca93
movq 0x70(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0xca91
movq 0x18(%rsp), %rdi
movl $0x18, %esi
callq 0x2240
jmp 0xca52
movq 0x58(%rsp), %rax
movq 0x50(%rax), %rax
movslq 0x7c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xcabf
movq 0x10(%rsp), %rdi
movl $0x18, %esi
callq 0x2240
movq 0x58(%rsp), %rax
movq 0x58(%rax), %rax
movslq 0x7c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xcaeb
movq 0x8(%rsp), %rdi
movl $0x18, %esi
callq 0x2240
jmp 0xcaed
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0xc9d1
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: akinanop[P]mvl-solver/src/Variable.cc
// Function: Variable::addRecord(int, int, bool)
void Variable::addRecord ( int c_id, int d_id, bool flag )
{
	//local variable
	VARRECORD * temp = new VARRECORD;
	temp->c_num = c_id;

	//if memory allocated
	if(temp)
	{
		temp->prev = NULL;
		if (flag) {
			temp->next = ATOMWATCHPOS[d_id];
			if (ATOMWATCHPOS[d_id])
				temp->next->prev = temp;
			ATOMWATCHPOS[d_id] = temp;
		} else {
			temp->next = ATOMWATCHNEG[d_id];
			if (ATOMWATCHNEG[d_id])
				temp->next->prev = temp;
			ATOMWATCHNEG[d_id] = temp;
		}
	}
}

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0x18, %edi
callq 0x2230
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x8(%rsp)
je 0xcc14
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
testb $0x1, 0x17(%rsp)
je 0xcbc0
movq (%rsp), %rax
movq 0x50(%rax), %rcx
movslq 0x18(%rsp), %rdx
movq (%rcx,%rdx,8), %rdx
movq 0x8(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x50(%rax), %rax
movslq 0x18(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xcba8
movq 0x8(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
movq 0x50(%rax), %rax
movslq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xcc12
movq (%rsp), %rax
movq 0x58(%rax), %rcx
movslq 0x18(%rsp), %rdx
movq (%rcx,%rdx,8), %rdx
movq 0x8(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x58(%rax), %rax
movslq 0x18(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xcbfc
movq 0x8(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
movq 0x58(%rax), %rax
movslq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xcc14
addq $0x28, %rsp
retq
nopl (%rax)
// File: akinanop[P]mvl-solver/src/Variable.cc
// Function: Variable::removeRecord(VARRECORD*, int, bool)
void Variable::removeRecord ( VARRECORD* record, int d_id, bool flag )
{
	if (record->prev) {
		record->prev->next = record->next;
	} else {
		if (flag)
			ATOMWATCHPOS[d_id] = record->next;
		else
			ATOMWATCHNEG[d_id] = record->next;
	}
	if (record->next) {
		record->next->prev = record->prev;
	}

	delete record;
}

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
andb $0x1, %al
movb %al, 0x13(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0xcc68
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0xcca9
testb $0x1, 0x13(%rsp)
je 0xcc8c
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rdx
movq 0x50(%rax), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xcca7
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rdx
movq 0x58(%rax), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xcca9
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xcccb
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xcce8
movq (%rsp), %rdi
movl $0x18, %esi
callq 0x2240
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0xa9c0
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x10(%rsp)
callq 0x12b20
movq 0x28(%rsp), %rdi
addq $0x60, %rdi
movq %rdi, 0x18(%rsp)
callq 0x12b30
movq 0x28(%rsp), %rdi
addq $0x88, %rdi
movq %rdi, 0x20(%rsp)
callq 0xb680
movq 0x28(%rsp), %rdi
movl $0xa, %esi
callq 0x12b40
jmp 0xcdad
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movl $0xa, %esi
callq 0x12c50
jmp 0xcdc2
movq 0x8(%rsp), %rdi
movl $0xe10, 0x30(%rdi)      # imm = 0xE10
movq $0x0, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movl $0x0, 0x48(%rdi)
movl $0x0, 0x54(%rdi)
movl $0x0, 0x4c(%rdi)
movl $0x0, 0x50(%rdi)
movl $0x0, 0x58(%rdi)
movl $0xffffffff, 0x78(%rdi) # imm = 0xFFFFFFFF
movb $0x0, 0x7c(%rdi)
movl $0xffffffff, 0x80(%rdi) # imm = 0xFFFFFFFF
addq $0x88, %rdi
movl $0xa, %esi
callq 0xb690
jmp 0xce29
movq 0x8(%rsp), %rax
movl $0x0, 0xa0(%rax)
movb $0x0, 0xa4(%rax)
movb $0x0, 0xa5(%rax)
movl $0x0, 0xa8(%rax)
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0xb7a0
movq 0x18(%rsp), %rdi
callq 0x12d60
movq 0x10(%rsp), %rdi
callq 0x12d70
movq 0x28(%rsp), %rdi
callq 0xaad0
movq 0x38(%rsp), %rdi
callq 0x2410
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
callq 0xa9c0
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x8(%rsp)
callq 0x12b20
movq 0x20(%rsp), %rdi
addq $0x60, %rdi
movq %rdi, 0x10(%rsp)
callq 0x12b30
movq 0x20(%rsp), %rdi
addq $0x88, %rdi
movq %rdi, 0x18(%rsp)
callq 0xb680
movq 0x20(%rsp), %rdi
movl $0xa, %esi
callq 0x12b40
jmp 0xcf11
movq (%rsp), %rdi
addq $0x18, %rdi
movl $0xa, %esi
callq 0x12c50
jmp 0xcf25
movq (%rsp), %rdi
movq 0x38(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x30(%rdi)
movq $0x0, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movl $0x0, 0x48(%rdi)
movl $0x0, 0x54(%rdi)
movl $0x0, 0x4c(%rdi)
movl $0x0, 0x50(%rdi)
movl $0x0, 0x58(%rdi)
movl $0xffffffff, 0x78(%rdi) # imm = 0xFFFFFFFF
movb $0x0, 0x7c(%rdi)
movl $0xffffffff, 0x80(%rdi) # imm = 0xFFFFFFFF
addq $0x88, %rdi
movl $0xa, %esi
callq 0xb690
jmp 0xcf8f
movq (%rsp), %rax
movl $0x0, 0xa0(%rax)
movq 0x38(%rsp), %rcx
movb 0x2(%rcx), %cl
andb $0x1, %cl
movb %cl, 0xa4(%rax)
movq 0x38(%rsp), %rcx
movb 0x1(%rcx), %cl
andb $0x1, %cl
movb %cl, 0xa5(%rax)
movq 0x38(%rsp), %rcx
movl 0x38(%rcx), %ecx
movl %ecx, 0xa8(%rax)
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xb7a0
movq 0x10(%rsp), %rdi
callq 0x12d60
movq 0x8(%rsp), %rdi
callq 0x12d70
movq 0x20(%rsp), %rdi
callq 0xaad0
movq 0x30(%rsp), %rdi
callq 0x2410
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xa03d(%rip), %rdi      # 0x17bb7
movb $0x0, %al
callq 0x2050
movq 0x8(%rsp), %rax
movl 0x50(%rax), %esi
leaq 0xa088(%rip), %rdi      # 0x17c18
movb $0x0, %al
callq 0x2050
movq 0x8(%rsp), %rax
movl 0x54(%rax), %esi
leaq 0xa084(%rip), %rdi      # 0x17c2a
movb $0x0, %al
callq 0x2050
movq 0x8(%rsp), %rax
movl 0x4c(%rax), %esi
leaq 0xa080(%rip), %rdi      # 0x17c3c
movb $0x0, %al
callq 0x2050
movq 0x8(%rsp), %rax
movl 0x58(%rax), %esi
leaq 0xa07c(%rip), %rdi      # 0x17c4e
movb $0x0, %al
callq 0x2050
movq 0x8(%rsp), %rdi
callq 0xaa90
movq %rax, %rsi
subq $0x1, %rsi
leaq 0xa06f(%rip), %rdi      # 0x17c60
movb $0x0, %al
callq 0x2050
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x12f00
movq %rax, %rsi
leaq 0xa063(%rip), %rdi      # 0x17c73
movb $0x0, %al
callq 0x2050
movq 0x8(%rsp), %rax
movl 0xa0(%rax), %esi
leaq 0xa05d(%rip), %rdi      # 0x17c86
movb $0x0, %al
callq 0x2050
leaq 0x9f80(%rip), %rdi      # 0x17bb7
movb $0x0, %al
callq 0x2050
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x30(%rsp)
movq 0x18(%rsp), %rdi
movl 0x30(%rsp), %eax
movq %rax, 0x10(%rsp)
addq $0x18, %rdi
callq 0x12f00
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xdd94
movb $0x0, 0x37(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x2c(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
movl 0x30(%rsp), %eax
movl %eax, %esi
callq 0x12f20
movq (%rax), %rdi
callq 0xb890
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xdd74
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
movl 0x30(%rsp), %eax
movl %eax, %esi
callq 0x12f20
movq (%rax), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xb8b0
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x28(%rsp)
testb $0x1, 0x28(%rsp)
je 0xdd38
movq 0x18(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0xaab0
movq (%rax), %rax
movq 0x20(%rax), %rax
movslq 0x24(%rsp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0xdd36
movb $0x1, 0x37(%rsp)
jmp 0xdd74
jmp 0xdd62
movq 0x18(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0xaab0
movq (%rax), %rax
movq 0x20(%rax), %rax
movslq 0x24(%rsp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0xdd60
movb $0x1, 0x37(%rsp)
jmp 0xdd74
jmp 0xdd62
jmp 0xdd64
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xdca0
testb $0x1, 0x37(%rsp)
jne 0xdd82
movb $0x0, 0x47(%rsp)
jmp 0xdd99
jmp 0xdd84
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0xdc6b
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0xa4(%rax)
je 0xddee
movq 0x101fd(%rip), %rdi     # 0x1dfd0
leaq 0x9ebd(%rip), %rsi      # 0x17c97
callq 0x2220
movq %rax, %rdi
movq 0x101d7(%rip), %rsi     # 0x1dfc0
callq 0x2260
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x12f00
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0xde44
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movslq 0x10(%rsp), %rsi
callq 0x12f20
movq (%rax), %rax
cmpl $-0x1, 0x1c(%rax)
jne 0xde35
movb $0x0, 0x27(%rsp)
jmp 0xde49
jmp 0xde37
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xde08
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::checkEntail(int)
int Formula::checkEntail ( int var ) {

	// check if there is exactly one domain value is not assigned for var

	// if ( LOG ) cout << "Checking entailment..." << endl;

	int domainsize = 0;
	bool flag = false;
	int domainvalue = -1;

	domainsize = VARLIST[var] -> DOMAINSIZE;

	for ( int j = 0; j < domainsize; j++ ) {
		if ( VARLIST[var] -> ATOMASSIGN[j] == 0 ) {
			if( ! flag ) {

				domainvalue = j;
				flag = true;

			} else {

				flag = false;
				break;

			}
		}
	}

	// if found an entail literal then assign memory to variable and return true

	if ( flag ) {
		return domainvalue;
	}
	return -1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x0, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movl $0xffffffff, 0x18(%rsp) # imm = 0xFFFFFFFF
movslq 0x24(%rsp), %rsi
callq 0xaab0
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0x20(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0xdf01
movq 0x8(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xaab0
movq (%rax), %rax
movq 0x20(%rax), %rax
movslq 0x14(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0xdef2
testb $0x1, 0x1f(%rsp)
jne 0xdee9
movl 0x14(%rsp), %eax
movl %eax, 0x18(%rsp)
movb $0x1, 0x1f(%rsp)
jmp 0xdef0
movb $0x0, 0x1f(%rsp)
jmp 0xdf01
jmp 0xdef2
jmp 0xdef4
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xdea8
testb $0x1, 0x1f(%rsp)
je 0xdf12
movl 0x18(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0xdf1a
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x80000000, 0x3c(%rsp) # imm = 0x80000000
movl $0xffffffff, 0x38(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x30(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x78(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0x2c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movq %rax, 0x8(%rsp)
callq 0xaa90
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xe09d
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0xaab0
movq (%rax), %rax
cmpl $-0x1, 0x4(%rax)
jne 0xe08b
movl $0x0, 0x28(%rsp)
movq 0x10(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0xaab0
movq %rax, %rcx
movl 0x4(%rsp), %eax
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0xe089
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0xaab0
movq (%rax), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0xe077
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0xaab0
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movq 0x28(%rax), %rax
movslq 0x28(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, (%rsp)
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0xaab0
movq %rax, %rcx
movl (%rsp), %eax
movq (%rcx), %rcx
movq 0x30(%rcx), %rcx
movslq 0x28(%rsp), %rdx
subl (%rcx,%rdx,4), %eax
movl %eax, 0x38(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x38(%rsp), %eax
jge 0xe075
movl 0x38(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x30(%rsp)
jmp 0xe077
jmp 0xe079
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0xdfbb
jmp 0xe08b
jmp 0xe08d
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xdf72
movl 0x34(%rsp), %esi
movl 0x30(%rsp), %edx
leaq 0x4c(%rsp), %rdi
callq 0x12f40
movl 0x54(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x4c(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movb 0x20(%rsp), %dl
addq $0x58, %rsp
retq
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movsd 0x990d(%rip), %xmm0     # 0x17bf8
movsd %xmm0, 0x48(%rsp)
movsd 0x98ff(%rip), %xmm0     # 0x17bf8
movsd %xmm0, 0x40(%rsp)
movl $0xffffffff, 0x3c(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x38(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x78(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0x34(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x34(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xaa90
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xe42e
movq 0x18(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0xaab0
movq (%rax), %rax
cmpl $-0x1, 0x4(%rax)
jne 0xe41c
movl $0x0, 0x30(%rsp)
movq 0x18(%rsp), %rdi
movl 0x30(%rsp), %eax
movl %eax, 0xc(%rsp)
movslq 0x34(%rsp), %rsi
callq 0xaab0
movq %rax, %rcx
movl 0xc(%rsp), %eax
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0xe41a
movq 0x18(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0xaab0
movq (%rax), %rax
movq 0x20(%rax), %rax
movslq 0x30(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0xe408
movq 0x18(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0xaab0
movq (%rax), %rax
movq 0x38(%rax), %rax
movslq 0x30(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x48(%rsp), %xmm1
movsd 0x40(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xe406
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x38(%rsp)
jmp 0xe408
jmp 0xe40a
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0xe367
jmp 0xe41c
jmp 0xe41e
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0xe31e
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %ecx
leaq 0x5c(%rsp), %rdi
movl $0x1, %edx
callq 0x12f70
movl 0x64(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x5c(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movb 0x28(%rsp), %dl
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movb %cl, %al
movq %rdx, 0x28(%rsp)
movb %al, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x40(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movslq 0x14(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0xb890
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xef1b
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0xb8b0
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x13660
testb $0x1, %al
jne 0xef05
jmp 0xef0c
movb $0x1, 0x47(%rsp)
jmp 0xef20
jmp 0xef0e
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xeeb3
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: 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:
movb %r8b, %al
movq %rsi, -0x20(%rsp)
movb %dl, -0x18(%rsp)
movq -0x20(%rsp), %rdx
movq %rdx, -0x10(%rsp)
movl -0x18(%rsp), %edx
movl %edx, -0x8(%rsp)
movq %rcx, -0x3c(%rsp)
movb %al, -0x34(%rsp)
movq -0x3c(%rsp), %rax
movq %rax, -0x2c(%rsp)
movl -0x34(%rsp), %eax
movl %eax, -0x24(%rsp)
movq %rdi, -0x48(%rsp)
movl -0x10(%rsp), %eax
cmpl -0x2c(%rsp), %eax
je 0xf39f
movb $0x0, -0x1(%rsp)
jmp 0xf3eb
movl -0xc(%rsp), %eax
cmpl -0x28(%rsp), %eax
je 0xf3be
testb $0x1, -0x8(%rsp)
je 0xf3b7
testb $0x1, -0x24(%rsp)
jne 0xf3be
movb $0x0, -0x1(%rsp)
jmp 0xf3eb
movl -0xc(%rsp), %eax
cmpl -0x28(%rsp), %eax
jne 0xf3e6
movb -0x8(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x24(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0xf3e6
movb $0x0, -0x1(%rsp)
jmp 0xf3eb
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::potent(Clause*)
bool Formula::potent ( Clause* clause ) {

	// Check if there is exactly one atom falsified at the current level

	if (clause->ATOM_LIST.size() == 1) {
		return true;
	}

	if (WATCH) {
		Literal w2 = clause->WATCHED[1];
		if (VARLIST[w2.VAR]->ATOMLEVEL[w2.VAL] < LEVEL) {
			return true;
		}
		return false;
	} else {

		int index = 0;
		bool flag = false;

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

			Literal atom = clause -> ATOM_LIST[i];

			if ( VARLIST[atom . VAR] -> ATOMLEVEL[atom . VAL] == LEVEL ) {
				if (flag)
					return false;
				flag = true;
				index = i;
			}
		}

		if ( !flag ) return false;

		else {
			return true;
		}
	}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0xb890
cmpq $0x1, %rax
jne 0xf432
movb $0x1, 0x57(%rsp)
jmp 0xf54d
movq 0x10(%rsp), %rax
testb $0x1, 0xa5(%rax)
je 0xf491
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x2c(%rax), %rcx
movq %rcx, 0x34(%rsp)
movl 0x34(%rax), %eax
movl %eax, 0x3c(%rsp)
movslq 0x34(%rsp), %rsi
callq 0xaab0
movq 0x10(%rsp), %rcx
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq 0x38(%rsp), %rdx
movl (%rax,%rdx,4), %eax
cmpl 0x48(%rcx), %eax
jge 0xf487
movb $0x1, 0x57(%rsp)
jmp 0xf54d
movb $0x0, 0x57(%rsp)
jmp 0xf54d
movl $0x0, 0x30(%rsp)
movb $0x0, 0x2f(%rsp)
movl $0x0, 0x28(%rsp)
movslq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0xb890
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xf53a
movq 0x40(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0xb8b0
movq 0x10(%rsp), %rdi
movq (%rax), %rcx
movq %rcx, 0x1c(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x24(%rsp)
movslq 0x1c(%rsp), %rsi
callq 0xaab0
movq 0x10(%rsp), %rcx
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq 0x20(%rsp), %rdx
movl (%rax,%rdx,4), %eax
cmpl 0x48(%rcx), %eax
jne 0xf528
testb $0x1, 0x2f(%rsp)
je 0xf51b
movb $0x0, 0x57(%rsp)
jmp 0xf54d
movb $0x1, 0x2f(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x30(%rsp)
jmp 0xf52a
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0xf4a6
testb $0x1, 0x2f(%rsp)
jne 0xf548
movb $0x0, 0x57(%rsp)
jmp 0xf54d
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0xa4(%rax)
je 0xfa73
movq 0xe578(%rip), %rdi      # 0x1dfd0
leaq 0x82b0(%rip), %rsi      # 0x17d0f
callq 0x2220
movq %rax, %rdi
movq 0xe552(%rip), %rsi      # 0x1dfc0
callq 0x2260
movl $0xffffffff, 0x2c(%rsp) # imm = 0xFFFFFFFF
movq 0x30(%rsp), %rdi
callq 0xb890
movl %eax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0xfb0d
movq 0x30(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xb8b0
movq 0x8(%rsp), %rdi
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x20(%rsp)
movslq 0x18(%rsp), %rsi
callq 0xaab0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rcx
movq 0x18(%rcx), %rcx
movslq 0x1c(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x14(%rsp)
movl 0x48(%rax), %eax
cmpl 0x14(%rsp), %eax
jle 0xfafe
movl 0x2c(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0xfafe
movl 0x14(%rsp), %eax
movl %eax, 0x2c(%rsp)
jmp 0xfb00
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xfa91
cmpl $-0x1, 0x2c(%rsp)
je 0xfb1e
movl 0x2c(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0xfb26
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movslq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0xb890
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x10845
movq 0x38(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0xb8b0
movq 0x10(%rsp), %rdi
movq (%rax), %rcx
movq %rcx, 0x1c(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x24(%rsp)
movslq 0x1c(%rsp), %rsi
callq 0xaab0
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x30(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x10833
movl 0x30(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x10835
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x107b8
movl 0x34(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x3c(%rsp), %rdi
callq 0x59f0
leaq 0x30(%rsp), %rdi
callq 0x59f0
movl $0xffffffff, 0x2c(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x28(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0x20(%rsp)
movslq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
callq 0xb890
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x10977
movq 0x48(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0xb8b0
movq 0x8(%rsp), %rdi
movq (%rax), %rcx
movq %rcx, 0x14(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
movslq 0x14(%rsp), %rsi
callq 0xaab0
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x18(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x2c(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x1093f
movl 0x28(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x3c(%rsp), %rax
movq %rax, 0x30(%rsp)
movb 0x44(%rsp), %al
movb %al, 0x38(%rsp)
movq 0x14(%rsp), %rax
movq %rax, 0x3c(%rsp)
movb 0x1c(%rsp), %al
movb %al, 0x44(%rsp)
jmp 0x10965
movl 0x24(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x10963
movl 0x2c(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x14(%rsp), %rax
movq %rax, 0x30(%rsp)
movb 0x1c(%rsp), %al
movb %al, 0x38(%rsp)
jmp 0x10965
jmp 0x10967
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x1089c
movq 0x48(%rsp), %rax
movq 0x3c(%rsp), %rcx
movq %rcx, 0x20(%rax)
movb 0x44(%rsp), %cl
movb %cl, 0x28(%rax)
movq 0x48(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x2c(%rax)
movb 0x38(%rsp), %cl
movb %cl, 0x34(%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: akinanop[P]mvl-solver/src/Formula.cc
// Function: Formula::sat(Literal)
int Formula::sat ( Literal literal ) {

	// computes literal -> SAT
	// literal -> SAT == 2 unassigned, == 1 satisfied, == 0 falsified

	int equals = 0;

	if ( literal . EQUAL) equals = 1;
	else equals = -1;

	if ( VARLIST[literal . VAR] -> ATOMASSIGN[literal . VAL] == equals ) return 1; // literal is satisfied
	else if ( VARLIST[literal . VAR] -> ATOMASSIGN[literal . VAL] == 0 ) return 2; // unassigned
	else return 0; //  literal is falsified

}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rsi, 0x18(%rsp)
movb %al, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x30(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
testb $0x1, 0x30(%rsp)
je 0x109f8
movl $0x1, 0xc(%rsp)
jmp 0x10a00
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movq (%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0xaab0
movq (%rax), %rax
movq 0x20(%rax), %rax
movslq 0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0xc(%rsp), %eax
jne 0x10a2d
movl $0x1, 0x34(%rsp)
jmp 0x10a5f
movq (%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0xaab0
movq (%rax), %rax
movq 0x20(%rax), %rax
movslq 0x2c(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x10a57
movl $0x2, 0x34(%rsp)
jmp 0x10a5f
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xffffffff, 0x8c(%rsp) # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rcx
xorl %eax, %eax
testb $0x1, 0x7c(%rcx)
movb %al, 0x7(%rsp)
jne 0x10abc
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0x13e10
xorb $-0x1, %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x10ac9
jmp 0x10c5a
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0x13e30
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x8c(%rsp)
movl 0x8c(%rsp), %eax
movl %eax, 0x78(%rdi)
addq $0x60, %rdi
callq 0x13e60
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movslq 0x8c(%rsp), %rsi
callq 0x12f20
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x74(%rsp)
movl 0x28(%rax), %eax
movl %eax, 0x7c(%rsp)
movq 0x74(%rsp), %rax
movq %rax, 0x64(%rsp)
movl 0x7c(%rsp), %eax
movl %eax, 0x6c(%rsp)
movq 0x64(%rsp), %rsi
movzbl 0x6c(%rsp), %edx
callq 0x109b0
cmpl $0x2, %eax
jne 0x10bad
movq 0x8(%rsp), %rdi
movq 0x80(%rsp), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x58(%rsp)
movl 0x28(%rax), %eax
movl %eax, 0x60(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movl 0x60(%rsp), %eax
movl %eax, 0x50(%rsp)
movq 0x48(%rsp), %rsi
movzbl 0x50(%rsp), %edx
callq 0x10c70
movq 0x8(%rsp), %rax
movl 0x54(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x54(%rax)
jmp 0x10c55
movq 0x80(%rsp), %rdi
callq 0xb890
cmpq $0x1, %rax
jbe 0x10c53
movq 0x8(%rsp), %rdi
movq 0x80(%rsp), %rax
movq 0x2c(%rax), %rcx
movq %rcx, 0x3c(%rsp)
movl 0x34(%rax), %eax
movl %eax, 0x44(%rsp)
movq 0x3c(%rsp), %rax
movq %rax, 0x2c(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x34(%rsp)
movq 0x2c(%rsp), %rsi
movzbl 0x34(%rsp), %edx
callq 0x109b0
cmpl $0x2, %eax
jne 0x10c53
movq 0x8(%rsp), %rdi
movq 0x80(%rsp), %rax
movq 0x2c(%rax), %rcx
movq %rcx, 0x20(%rsp)
movl 0x34(%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x10(%rsp), %rsi
movzbl 0x18(%rsp), %edx
callq 0x10c70
movq 0x8(%rsp), %rax
movl 0x54(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x54(%rax)
jmp 0x10c55
jmp 0x10a97
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x3c(%rsp), %eax
movq %rax, (%rsp)
addq $0x18, %rdi
callq 0x12f00
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x116b5
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x12f20
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x4c(%rsp)
movl 0x28(%rax), %eax
movl %eax, 0x54(%rsp)
movq 0x4c(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x38(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x20(%rsp), %rsi
movzbl 0x28(%rsp), %edx
callq 0x109b0
cmpl $0x2, %eax
jne 0x116a3
jmp 0x116bf
jmp 0x116a5
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x1161b
leaq 0x4c(%rsp), %rdi
callq 0x59f0
movl 0x54(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x4c(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movb 0x18(%rsp), %dl
addq $0x58, %rsp
retq
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x5c(%rsp)
movq 0x18(%rsp), %rdi
movl 0x5c(%rsp), %eax
movq %rax, 0x10(%rsp)
addq $0x18, %rdi
callq 0x12f00
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x11807
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x12f20
movq (%rax), %rax
movq %rax, 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
movq 0x50(%rsp), %rcx
xorl %eax, %eax
cmpl $-0x1, 0x1c(%rcx)
movb %al, 0xf(%rsp)
jne 0x1177c
movslq 0x4c(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
callq 0xb890
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
setb %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x11786
jmp 0x117f5
movq 0x50(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0xb8b0
movq 0x18(%rsp), %rdi
movq (%rax), %rcx
movq %rcx, 0x6c(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x74(%rsp)
movq 0x6c(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x74(%rsp), %eax
movl %eax, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x38(%rsp)
movq 0x30(%rsp), %rsi
movzbl 0x38(%rsp), %edx
callq 0x109b0
cmpl $0x2, %eax
jne 0x117e3
jmp 0x11811
jmp 0x117e5
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x11747
jmp 0x117f7
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x116fb
leaq 0x6c(%rsp), %rdi
callq 0x59f0
movl 0x74(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x6c(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movb 0x28(%rsp), %dl
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)