LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/coordinate_transform.cpp
// Function: azimuth_elevation_roll(Eigen::Matrix<double, 3, 3, 0, 3, 3>)
Vector3d azimuth_elevation_roll(Matrix3d dcmNED2BODY_){
    Vector3d azelro = dcmNED2BODY_.transpose().eulerAngles(2, 1, 0);
    double az_rad = azelro[0];
    double el_rad = azelro[1];
    double ro_rad = azelro[2];

    if (el_rad > deg2rad(90.0)) {
        ro_rad += deg2rad(180.0);
        az_rad += deg2rad(180.0);
        el_rad = deg2rad(180.0) - el_rad;
    } else if (el_rad < deg2rad(-90.0)) {
        ro_rad += deg2rad(180.0);
        az_rad += deg2rad(180.0);
        el_rad = deg2rad(-180.0) - el_rad;
    }

    if (ro_rad > deg2rad(180.0)){
        ro_rad -= deg2rad(360.0);
    }

    return  Vector3d(az_rad, el_rad, ro_rad);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rsi), %xmm1
movsd 0x18(%rsi), %xmm0
callq 0x50a0
movapd %xmm0, %xmm2
movupd 0x38(%r14), %xmm0
mulpd %xmm0, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
sqrtsd %xmm1, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm2, %xmm0
jbe 0x2378d
addsd 0x25a8(%rip), %xmm2     # 0x25d18
movapd %xmm2, (%rsp)
movsd 0x30(%r14), %xmm0
movapd 0x27cd(%rip), %xmm2     # 0x25f50
xorpd %xmm2, %xmm0
xorpd %xmm2, %xmm1
jmp 0x237a0
movsd 0x30(%r14), %xmm0
xorpd 0x27b5(%rip), %xmm0     # 0x25f50
movapd %xmm2, (%rsp)
callq 0x50a0
movsd %xmm0, 0x18(%rsp)
movaps (%rsp), %xmm0
callq 0x50f0
movsd %xmm0, 0x20(%rsp)
movapd (%rsp), %xmm0
callq 0x5690
movapd %xmm0, %xmm1
movsd 0x28(%r14), %xmm2
mulsd %xmm0, %xmm2
movsd 0x10(%r14), %xmm0
movsd 0x20(%rsp), %xmm3
mulsd %xmm3, %xmm0
mulsd 0x8(%r14), %xmm3
subsd %xmm2, %xmm0
mulsd 0x20(%r14), %xmm1
subsd %xmm3, %xmm1
callq 0x50a0
movsd 0x18(%rsp), %xmm4
ucomisd 0x2547(%rip), %xmm4     # 0x25d50
jbe 0x23826
movapd (%rsp), %xmm3
unpcklpd %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0]
addpd 0x2794(%rip), %xmm3     # 0x25fb0
movsd 0x24f4(%rip), %xmm0     # 0x25d18
jmp 0x2384d
movsd 0x4b9a(%rip), %xmm1     # 0x283c8
ucomisd %xmm4, %xmm1
movapd (%rsp), %xmm3
unpcklpd %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0]
jbe 0x23855
addpd 0x276b(%rip), %xmm3     # 0x25fb0
movsd 0x4b83(%rip), %xmm0     # 0x283d0
subsd %xmm4, %xmm0
movapd %xmm0, %xmm4
movapd %xmm3, %xmm0
unpckhpd %xmm3, %xmm0            # xmm0 = xmm0[1],xmm3[1]
movsd 0x4b73(%rip), %xmm1     # 0x283d8
addsd %xmm0, %xmm1
movsd 0x24a7(%rip), %xmm2     # 0x25d18
cmpltsd %xmm0, %xmm2
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
movlpd %xmm3, (%rbx)
movsd %xmm4, 0x8(%rbx)
movlpd %xmm2, 0x10(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/coordinate_transform.cpp
// Function: posECEF(Eigen::Matrix<double, 3, 1, 0, 3, 1>)
Vector3d posECEF(Vector3d posLLH_){
    Vector3d pos;
    double lat = deg2rad(posLLH_[0]); //degree
    double lon = deg2rad(posLLH_[1]);
    double alt = posLLH_[2];
    double a = 6378137; // 長半径a [m]
    double f = 1.0 / 298.257223563; // 扁平率
    double e = sqrt(2*f - f*f); // 離心率 e
    double e2 = e * e;
    double W = sqrt(1.0 - e2 * sin(lat) * sin(lat));
    double N = a / W; // 卯酉線曲率半径
    pos[0] = (N + alt) * cos(lat) * cos(lon);
    pos[1] = (N + alt) * cos(lat) * sin(lon);
    pos[2] = (N * (1 - e2) + alt) * sin(lat);
    return pos;
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movsd (%rsi), %xmm3
movsd 0x8(%rsi), %xmm2
movsd 0x22de(%rip), %xmm0     # 0x25d10
divsd %xmm0, %xmm3
movsd 0x22da(%rip), %xmm1     # 0x25d18
mulsd %xmm1, %xmm3
movsd %xmm3, 0x8(%rsp)
divsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rsp)
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x18(%rsp)
movapd %xmm3, %xmm0
callq 0x50f0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x50f0
movsd (%rsp), %xmm1
mulsd 0x4959(%rip), %xmm1     # 0x283e0
mulsd %xmm0, %xmm1
addsd 0x15dd(%rip), %xmm1     # 0x25070
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movapd %xmm1, %xmm0
jb 0x23aa7
sqrtsd %xmm0, %xmm0
jmp 0x23aac
callq 0x52e0
movsd 0x4754(%rip), %xmm1     # 0x28208
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd 0x18(%rsp), %xmm0
addsd %xmm1, %xmm0
movapd %xmm0, 0x50(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x5690
movaps %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x5690
movaps %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x5690
movaps %xmm0, 0x20(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x50f0
movapd 0x30(%rsp), %xmm2
unpcklpd 0x20(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
movapd 0x50(%rsp), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm2, %xmm1
movapd 0x40(%rsp), %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm1, %xmm2
movupd %xmm2, (%rbx)
movsd (%rsp), %xmm0
mulsd 0x48a7(%rip), %xmm0     # 0x283e8
addsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x50f0
mulsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/coordinate_transform.cpp
// Function: posECI_init(Eigen::Matrix<double, 3, 1, 0, 3, 1>)
Vector3d posECI_init(Vector3d posLLH_){
    Vector3d posECEF_;
    double second = 0.0;
    posECEF_ = posECEF(posLLH_);
    return posECI(posECEF_, second);
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movsd (%rsi), %xmm3
movsd 0x8(%rsi), %xmm2
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x1e88(%rip), %xmm0     # 0x25d10
divsd %xmm0, %xmm3
movsd 0x1e84(%rip), %xmm1     # 0x25d18
mulsd %xmm1, %xmm3
movsd %xmm3, 0x10(%rsp)
divsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, 0x20(%rsp)
movapd %xmm3, %xmm0
callq 0x50f0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x50f0
movsd 0x8(%rsp), %xmm1
mulsd 0x450c(%rip), %xmm1     # 0x283e0
mulsd %xmm0, %xmm1
addsd 0x1190(%rip), %xmm1     # 0x25070
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movapd %xmm1, %xmm0
jb 0x23ef4
sqrtsd %xmm0, %xmm0
jmp 0x23ef9
callq 0x52e0
movsd 0x4307(%rip), %xmm1     # 0x28208
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
addsd %xmm1, %xmm0
movapd %xmm0, 0x60(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x5690
movaps %xmm0, 0x40(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x5690
movaps %xmm0, 0x50(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x5690
movaps %xmm0, 0x30(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x50f0
movaps %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x447f(%rip), %xmm0     # 0x283e8
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x50f0
mulsd 0x8(%rsp), %xmm0
movapd 0x40(%rsp), %xmm2
unpcklpd 0x30(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
movapd 0x60(%rsp), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm2, %xmm1
movapd 0x50(%rsp), %xmm2
unpcklpd 0x20(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
mulpd %xmm1, %xmm2
leaq 0x70(%rsp), %rsi
movapd %xmm2, (%rsi)
movsd %xmm0, 0x10(%rsi)
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x23b6a
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movups (%rdx), %xmm0
leaq 0x110(%rsp), %rsi
movaps %xmm0, (%rsi)
movsd 0x10(%rdx), %xmm0
movsd %xmm0, 0x10(%rsi)
leaq 0x60(%rsp), %r12
movq %r12, %rdi
callq 0x23e61
movsd 0x10(%r12), %xmm0
movsd %xmm0, 0x8(%rsp)
movaps (%r12), %xmm0
movaps %xmm0, 0x50(%rsp)
leaq 0x60(%rsp), %r12
xorps %xmm0, %xmm0
movq %r12, %rdi
callq 0x226c0
movsd 0x40(%r12), %xmm0
movsd %xmm0, (%rsp)
movaps (%r12), %xmm0
movaps %xmm0, 0x40(%rsp)
movaps 0x10(%r12), %xmm0
movaps %xmm0, 0x30(%rsp)
movaps 0x20(%r12), %xmm0
movaps %xmm0, 0x20(%rsp)
movaps 0x30(%r12), %xmm0
movaps %xmm0, 0x10(%rsp)
movups (%r15), %xmm0
leaq 0xf0(%rsp), %rsi
movaps %xmm0, (%rsi)
movsd 0x10(%r15), %xmm0
movsd %xmm0, 0x10(%rsi)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x22aad
movsd 0x40(%r15), %xmm0
movaps (%r15), %xmm1
movaps 0x10(%r15), %xmm2
movaps 0x20(%r15), %xmm3
movaps 0x30(%r15), %xmm4
leaq 0x180(%rsp), %rsi
movaps %xmm1, (%rsi)
movaps %xmm2, 0x10(%rsi)
movaps %xmm3, 0x20(%rsi)
movaps %xmm4, 0x30(%rsi)
movsd %xmm0, 0x40(%rsi)
leaq 0x130(%rsp), %rdx
movaps 0x40(%rsp), %xmm0
movaps %xmm0, (%rdx)
movaps 0x30(%rsp), %xmm0
movaps %xmm0, 0x10(%rdx)
movaps 0x20(%rsp), %xmm0
movaps %xmm0, 0x20(%rdx)
movaps 0x10(%rsp), %xmm0
movaps %xmm0, 0x30(%rdx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x40(%rdx)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x22cf4
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
movsd 0x10(%r15), %xmm2
movsd 0x18(%r15), %xmm3
movsd 0x20(%r15), %xmm4
movsd 0x28(%r15), %xmm5
movsd 0x30(%r15), %xmm6
movsd 0x38(%r15), %xmm7
movsd 0x40(%r15), %xmm8
leaq 0x1d0(%rsp), %rsi
movsd %xmm0, (%rsi)
movsd %xmm3, 0x8(%rsi)
movsd %xmm6, 0x10(%rsi)
movsd %xmm1, 0x18(%rsi)
movsd %xmm4, 0x20(%rsi)
movsd %xmm7, 0x28(%rsi)
movsd %xmm2, 0x30(%rsi)
movsd %xmm5, 0x38(%rsi)
movsd %xmm8, 0x40(%rsi)
movups (%r14), %xmm0
leaq 0xd0(%rsp), %rdx
movaps %xmm0, (%rdx)
movsd 0x10(%r14), %xmm0
movsd %xmm0, 0x10(%rdx)
leaq 0xb0(%rsp), %rcx
movaps 0x50(%rsp), %xmm0
movaps %xmm0, (%rcx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rcx)
movq %rbx, %rdi
callq 0x23c14
movq %rbx, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
cmpq %rdi, 0x8(%rbx)
je 0x6f56
xorl %r14d, %r14d
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r12d, %r12d
addq %r14, %rdi
callq 0x7052
incq %r12
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
sarq $0x2, %rax
imulq %r15, %rax
addq $0xc, %r14
cmpq %r12, %rax
ja 0x6f30
movq 0xa073(%rip), %rbx      # 0x10fd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x747e
callq 0x22a0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x748c
callq 0x22a0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x749a
callq 0x22a0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x74a8
callq 0x22a0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x74b6
callq 0x22a0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x74c4
callq 0x22a0
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x74d2
callq 0x22a0
cmpl $0x0, 0x8(%rbx)
jle 0x7551
xorl %r14d, %r14d
movq 0x50(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x74fe
movq 0x8(%rdi), %r15
movl $0x18, %esi
callq 0x2240
movq %r15, %rdi
testq %r15, %r15
jne 0x74e8
movq 0x58(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x7521
movq 0x8(%rdi), %r15
movl $0x18, %esi
callq 0x2240
movq %r15, %rdi
testq %r15, %r15
jne 0x750b
movq 0x50(%rbx), %rax
movq (%rax,%r14,8), %rdi
movl $0x18, %esi
callq 0x2240
movq 0x58(%rbx), %rax
movq (%rax,%r14,8), %rdi
movl $0x18, %esi
callq 0x2240
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x74db
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl $0x18, %edi
callq 0x2230
movl %r15d, (%rax)
movq $0x0, 0x10(%rax)
movslq %r14d, %rcx
testl %ebp, %ebp
je 0x758c
movq 0x50(%rbx), %rdx
jmp 0x7590
movq 0x58(%rbx), %rdx
leaq (%rdx,%rcx,8), %rcx
movq (%rcx), %rdx
movq %rdx, 0x8(%rax)
testq %rdx, %rdx
je 0x75a4
movq %rax, 0x10(%rdx)
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rsi, %rax
movq 0x8(%rsi), %rsi
movq 0x10(%rax), %r8
testq %r8, %r8
je 0x75c8
addq $0x8, %r8
jmp 0x75dd
movslq %edx, %r8
shlq $0x3, %r8
testb %cl, %cl
je 0x75d9
addq 0x50(%rdi), %r8
jmp 0x75dd
addq 0x58(%rdi), %r8
movq %rsi, (%r8)
testq %rsi, %rsi
je 0x75ed
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsi)
movl $0x18, %esi
movq %rax, %rdi
jmp 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb97a
movl $0xa, %esi
movq %r14, %rdi
callq 0xba16
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 0x6f90
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 0x7728
movq 0x98(%rbx), %rsi
subq %rdi, %rsi
callq 0x2240
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x244e
movq %r13, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5d88(%rip), %rdi      # 0xdcc8
xorl %eax, %eax
callq 0x2050
movl 0x54(%rbx), %esi
leaq 0x5d89(%rip), %rdi      # 0xdcda
xorl %eax, %eax
callq 0x2050
movl 0x4c(%rbx), %esi
leaq 0x5d8a(%rip), %rdi      # 0xdcec
xorl %eax, %eax
callq 0x2050
movl 0x58(%rbx), %esi
leaq 0x5d8b(%rip), %rdi      # 0xdcfe
xorl %eax, %eax
callq 0x2050
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x3, %rsi
decq %rsi
leaq 0x5d81(%rip), %rdi      # 0xdd10
xorl %eax, %eax
callq 0x2050
movq 0x20(%rbx), %rsi
subq 0x18(%rbx), %rsi
sarq $0x3, %rsi
leaq 0x5d7a(%rip), %rdi      # 0xdd23
xorl %eax, %eax
callq 0x2050
movl 0xa0(%rbx), %esi
leaq 0x5d79(%rip), %rdi      # 0xdd36
xorl %eax, %eax
callq 0x2050
movl $0xa, %edi
popq %rbx
jmp 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
je 0x8058
pushq %rbx
sarq $0x3, %rdx
movq (%rdi), %rsi
xorl %edi, %edi
movabsq $-0x5555555555555555, %r8 # imm = 0xAAAAAAAAAAAAAAAB
movq (%rcx,%rdi,8), %rax
movq (%rax), %r9
movq 0x8(%rax), %r10
subq %r9, %r10
setne %al
je 0x8054
sarq $0x2, %r10
imulq %r8, %r10
cmpq $0x1, %r10
adcq $0x0, %r10
addq $0x8, %r9
movslq -0x8(%r9), %r11
movslq -0x4(%r9), %rbx
movq (%rsi,%r11,8), %r11
movq 0x20(%r11), %r11
movl (%r11,%rbx,4), %r11d
testb $0x1, (%r9)
je 0x803a
cmpl $0x1, %r11d
jne 0x8040
jmp 0x804b
cmpl $-0x1, %r11d
je 0x804b
addq $0xc, %r9
decq %r10
jne 0x8018
jmp 0x8054
incl %edi
cmpq %rdi, %rdx
ja 0x7ff1
jmp 0x8056
xorl %eax, %eax
popq %rbx
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x80ae
movq 0x8f5d(%rip), %r14      # 0x10fd0
leaq 0x5ccd(%rip), %rsi      # 0xdd47
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), %rcx
movq 0x20(%rbx), %rax
subq %rcx, %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0x80f2
movq (%rcx), %rdx
cmpl $-0x1, 0x1c(%rdx)
je 0x80f6
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl $0x1, %esi
movq %rsi, %rdx
cmpq %rsi, %rax
je 0x80ea
movq (%rcx,%rdx,8), %rdi
leaq 0x1(%rdx), %rsi
cmpl $-0x1, 0x1c(%rdi)
jne 0x80d4
cmpq %rax, %rdx
setae %al
jmp 0x80f8
movb $0x1, %al
jmp 0x80f8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x81dc
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 0x81c0
movslq 0x8(%r9), %r10
testq %r10, %r10
jle 0x81c0
movq 0x20(%r9), %r11
xorl %ebx, %ebx
cmpl $0x0, (%r11,%rbx,4)
jne 0x81b8
movq 0x28(%r9), %r14
movq 0x30(%r9), %r15
movl (%r14,%rbx,4), %ebp
subl (%r15,%rbx,4), %ebp
cmpl %ebp, %r8d
jge 0x81b8
movl %esi, %edi
movl %ebx, %edx
movl %ebp, %r8d
incq %rbx
cmpq %rbx, %r10
jne 0x8195
incq %rsi
movl %esi, %r9d
cmpq %r9, %rcx
ja 0x817b
shlq $0x20, %rdx
movl %edi, %eax
orq %rdx, %rax
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x81e3
movq $-0x1, %rax
movb $0x1, %dl
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x829b
pushq %r14
pushq %rbx
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movsd 0x5a8f(%rip), %xmm0     # 0xdca8
xorl %edi, %edi
xorl %edx, %edx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq (%rax,%rdi,8), %r9
cmpl $-0x1, 0x4(%r9)
jne 0x8282
movslq 0x8(%r9), %r10
testq %r10, %r10
jle 0x8282
movq 0x20(%r9), %r11
xorl %ebx, %ebx
cmpl $0x0, (%r11,%rbx,4)
jne 0x827a
movq 0x38(%r9), %r14
movsd (%r14,%rbx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x825f
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 0x827a
xorl %edx, %edx
movl %edi, %r8d
movl %ebx, %esi
movapd %xmm1, %xmm0
incq %rbx
cmpq %rbx, %r10
jne 0x823d
incq %rdi
cmpq %rcx, %rdi
jne 0x8223
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_O3/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 0x8331
pushq %rbx
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movsd 0x59d5(%rip), %xmm0     # 0xdca8
xorl %esi, %esi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq (%rax,%rsi,8), %r8
cmpl $-0x1, 0x4(%r8)
jne 0x831d
movslq 0x8(%r8), %r9
testq %r9, %r9
jle 0x831d
movq 0x20(%r8), %r10
xorl %r11d, %r11d
cmpl $0x0, (%r10,%r11,4)
jne 0x8315
movq 0x38(%r8), %rbx
movsd (%rbx,%r11,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x8315
movl %esi, %edi
movl %r11d, %edx
movapd %xmm1, %xmm0
incq %r11
cmpq %r11, %r9
jne 0x82f5
incq %rsi
cmpq %rcx, %rsi
jne 0x82da
shlq $0x20, %rdx
movl %edi, %eax
orq %rdx, %rax
popq %rbx
jmp 0x8338
movq $-0x1, %rax
movb $0x1, %dl
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
subq %rdi, %rax
je 0x8f9f
movq %rdx, %rsi
shrq $0x20, %rsi
sarq $0x2, %rax
movabsq $-0x5555555555555555, %r8 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r8
xorl %r9d, %r9d
cmpq $0x1, %r8
sbbq %r8, %r9
addq $0x8, %rdi
movb $0x1, %al
movl $0x1, %r10d
cmpl %edx, -0x8(%rdi)
jne 0x8f83
cmpl %esi, -0x4(%rdi)
jne 0x8f83
cmpb %cl, (%rdi)
je 0x8fa1
cmpq %r10, %r8
seta %al
addq $0xc, %rdi
leaq (%r9,%r10), %r11
incq %r11
incq %r10
cmpq $0x1, %r11
jne 0x8f75
jmp 0x8fa1
xorl %eax, %eax
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x28, %rsp
movq %r8, 0x18(%rsp)
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movl $0x38, %edi
callq 0x2230
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0x6dc0
movq (%r12), %rax
movq 0x8(%r12), %rcx
movabsq $-0x5555555555555555, %r14 # imm = 0xAAAAAAAAAAAAAAAB
cmpq %rax, %rcx
je 0x9059
movl $0x1, %ebx
xorl %edx, %edx
leaq (%rdx,%rdx,2), %rdx
movq (%rax,%rdx,4), %rsi
movb 0x8(%rax,%rdx,4), %dl
cmpl %r15d, %esi
jne 0x902c
movq %rsi, %rdi
xorq %r15, %rdi
shrq $0x20, %rdi
jne 0x901f
movl %edx, %edi
xorb %bpl, %dil
testb $0x1, %dil
jne 0x902c
jmp 0x9042
testb $0x1, %bpl
sete %dil
testb %dil, %dl
jne 0x9042
movzbl %dl, %edx
movq 0x8(%rsp), %rdi
callq 0x6ec8
movq (%r12), %rax
movq 0x8(%r12), %rcx
movl %ebx, %edx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x2, %rsi
imulq %r14, %rsi
incl %ebx
cmpq %rdx, %rsi
ja 0x8ff5
movl %ebp, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rbx
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq %rbx, %rax
je 0x9104
movl $0x1, %ebp
xorl %eax, %eax
leaq (%rax,%rax,2), %rax
movq (%rbx,%rax,4), %r12
movb 0x8(%rbx,%rax,4), %al
cmpl %r15d, %r12d
jne 0x90ae
movq %r12, %rcx
xorq %r15, %rcx
shrq $0x20, %rcx
jne 0x90a3
movl %eax, %ecx
xorb 0x14(%rsp), %cl
jmp 0x90a9
movl %eax, %ecx
andb 0x14(%rsp), %cl
testb $0x1, %cl
jne 0x90e7
movzbl %al, %r13d
movq 0x8(%rsp), %rsi
movq %r12, %rdx
movl %r13d, %ecx
callq 0x8f3a
testb %al, %al
jne 0x90e7
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x6ec8
movq 0x18(%rsp), %rax
movq (%rax), %rbx
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movl %ebp, %eax
movq 0x20(%rsp), %rcx
subq %rbx, %rcx
sarq $0x2, %rcx
imulq %r14, %rcx
incl %ebp
cmpq %rax, %rcx
ja 0x907e
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x38, %esi
movq 0x8(%rsp), %rdi
callq 0x2240
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9152
xorq %rsi, %rcx
shrq $0x20, %rcx
jne 0x9144
xorb %dl, %r8b
jmp 0x9149
testb $0x1, %dl
je 0x9152
testb $0x1, %r8b
je 0x9152
movb $0x1, %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9530
movq 0x7adb(%rip), %r15      # 0x10fd0
leaq 0x48c3(%rip), %rsi      # 0xddbf
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), %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rax
testl %eax, %eax
jle 0x95a2
movq (%rbx), %rdx
movl 0x48(%rbx), %esi
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %r8d, %r8d
movl %eax, %r9d
movslq (%rcx,%r8), %rax
movslq 0x4(%rcx,%r8), %r10
movq (%rdx,%rax,8), %rax
movq 0x18(%rax), %rax
movl (%rax,%r10,4), %r10d
cmpl %r10d, %r9d
movl %r10d, %eax
cmovgl %r9d, %eax
cmpl %r10d, %esi
cmovlel %r9d, %eax
addq $0xc, %r8
cmpq %r8, %rdi
jne 0x956b
cmpl $-0x1, %eax
jne 0x95a4
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9a56
movl $0x1, %edx
movl $0x1, %r8d
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
movq (%rax,%r8,8), %r8
movl 0x8(%r8), %r10d
testl %r10d, %r10d
jle 0x9a4c
movq 0x18(%r8), %r9
xorl %r11d, %r11d
cmpl %esi, (%r9,%r11,4)
jle 0x9a41
movl $0xffffffff, 0x4(%r8)   # imm = 0xFFFFFFFF
movq 0x20(%r8), %r10
movl $0x0, (%r10,%r11,4)
movl %edi, (%r9,%r11,4)
movq 0x48(%r8), %r10
movl %edi, (%r10,%r11,4)
movl 0x8(%r8), %r10d
incq %r11
movslq %r10d, %r14
cmpq %r14, %r11
jl 0x9a17
incl %edx
movq %rdx, %r8
cmpq %rdx, %rcx
ja 0x9a03
movq 0x90(%rbx), %rdx
movq %rdx, %rcx
subq 0x88(%rbx), %rcx
sarq $0x2, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
testl %eax, %eax
jle 0x9af5
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), %rsi
movq (%rcx,%rsi,8), %rcx
movq 0x20(%rcx), %rcx
movslq -0x8(%rax,%r15), %rsi
cmpl $0x0, (%rcx,%rsi,4)
jne 0x9ae4
leaq (%rax,%r15), %rsi
cmpq %rdx, %rsi
je 0x9ad9
leaq (%rax,%r15), %rdi
addq $-0xc, %rdi
subq %rax, %rdx
addq %r12, %rdx
callq 0x2350
movq 0x90(%rbx), %rdx
addq $-0xc, %rdx
movq %rdx, 0x90(%rbx)
decq %r14
addq $-0xc, %r15
addq $0xc, %r12
cmpq $0x1, %r14
ja 0x9a94
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9eb2
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 0x9e88
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa0cd
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 0xa0c4
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 0xa0ac
movq 0x8(%rax), %rdx
subq (%rax), %rdx
sarq $0x2, %rdx
imulq %r12, %rdx
cmpq $0x2, %rdx
jb 0xa0ba
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 0xa0ba
movl 0x34(%rax), %edx
jmp 0xa0af
movl 0x28(%rax), %edx
movq %rbx, %rdi
callq 0xa0ce
incl 0x54(%rbx)
cmpb $0x1, 0x7c(%rbx)
jne 0xa022
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %rcx
movq 0x20(%rdi), %rdx
movq $-0x1, %rax
subq %rcx, %rdx
je 0xab74
sarq $0x3, %rdx
movq (%rdi), %rsi
movl $0x1, %edi
xorl %r8d, %r8d
movq (%rcx,%r8,8), %r9
movq 0x20(%r9), %r8
movslq %r8d, %r10
movq (%rsi,%r10,8), %r10
movq 0x20(%r10), %r10
movq %r8, %r11
sarq $0x20, %r11
cmpl $0x0, (%r10,%r11,4)
je 0xab77
movl %edi, %r8d
incl %edi
cmpq %r8, %rdx
ja 0xab49
xorl %edx, %edx
retq
movb 0x28(%r9), %dl
movq %r8, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rcx
movq 0x20(%rdi), %rsi
xorl %edx, %edx
movq $-0x1, %rax
subq %rcx, %rsi
je 0xac07
pushq %r14
pushq %rbx
sarq $0x3, %rsi
movq (%rdi), %rdi
movabsq $-0x5555555555555555, %r8 # imm = 0xAAAAAAAAAAAAAAAB
movq (%rcx,%rdx,8), %r10
cmpl $-0x1, 0x1c(%r10)
je 0xabbe
incl %edx
cmpq %rdx, %rsi
ja 0xabaa
jmp 0xac08
movq (%r10), %r9
movq 0x8(%r10), %r10
subq %r9, %r10
je 0xabb5
sarq $0x2, %r10
imulq %r8, %r10
addq $0x8, %r9
movq -0x8(%r9), %r11
movslq %r11d, %rbx
movq (%rdi,%rbx,8), %rbx
movq 0x20(%rbx), %rbx
movq %r11, %r14
sarq $0x20, %r14
cmpl $0x0, (%rbx,%r14,4)
je 0xabfe
addq $0xc, %r9
decq %r10
jne 0xabd6
jmp 0xabb5
movb (%r9), %dl
movq %r11, %rax
popq %rbx
popq %r14
retq
xorl %edx, %edx
jmp 0xac04
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb733
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 0xb72a
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 0xb6d5
cmpb $0x1, 0x7c(%rbx)
jne 0xb692
jmp 0xb72a
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
je 0xb6cd
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 0xb71a
addq $0xc, %rax
decq %rdx
jne 0xb6f8
jmp 0xb6cd
movzbl (%rax), %edx
incl 0x54(%rbx)
movq %rbx, %rdi
callq 0x833c
jmp 0xb6cd
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/huffman_dec.c
// Function: main
int main(int argc, char *argv[])
{
	if (argc < 2)
	{
		printf("Usage: huffman_dec file.huff\r\n");
		return -1;
	}

	unsigned int size = 0;

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

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


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

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
cmpl $0x1, %edi
jg 0x1365
leaq 0xd1d(%rip), %rdi       # 0x2078
callq 0x1040
jmp 0x1418
movq %rsi, %rbx
leaq -0x2c(%rbp), %rsi
movl $0x0, (%rsi)
movq 0x8(%rbx), %rdi
callq 0x120c
testq %rax, %rax
je 0x1406
movq %rax, %r15
movl -0x2c(%rbp), %r12d
leal (%r12,%r12), %r13d
movl $0x1, %edi
movq %r13, %rsi
callq 0x10a0
testq %rax, %rax
je 0x1433
movq %rax, %r14
leaq 0x2d01(%rip), %r8       # 0x40b0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r13, %rcx
callq 0x182a
movq %rax, %r12
leaq -0x130(%rbp), %r13
xorl %r15d, %r15d
movl $0x100, %edx            # imm = 0x100
movq %r13, %rdi
xorl %esi, %esi
callq 0x1090
movq 0x8(%rbx), %rcx
leaq 0xc65(%rip), %rdx       # 0x204c
movl $0x100, %esi            # imm = 0x100
movq %r13, %rdi
xorl %eax, %eax
callq 0x1080
movq %r13, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x12be
jmp 0x141e
movq 0x8(%rbx), %rsi
leaq 0xc19(%rip), %rdi       # 0x202a
xorl %eax, %eax
callq 0x1070
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc04(%rip), %rdi       # 0x203e
callq 0x10f0
jmp 0x1418
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40de
testb %al, %al
jne 0x3a46
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
testq %r14, %r14
je 0x3a46
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4f84
movq %rax, %rdi
callq 0x40e6
testb %al, %al
je 0x3a30
movq %r15, %rdi
movq %r12, %rsi
callq 0x3c7e
decq %r14
jne 0x3a09
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3a46
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 0x3a70
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5608
movq %rbx, %rdi
movl %ebp, %esi
callq 0x58a0
movl %eax, %ebp
movq (%r15), %r13
cmpq %r13, 0x8(%r15)
je 0x3acd
leaq 0x271b(%rip), %r12      # 0x61ca
movq (%r13), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x563e
addq $0x20, %r13
cmpq 0x8(%r15), %r13
jne 0x3aaf
movsbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x58ac
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x42fc
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 0x410a
movq %r14, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x42fc
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 0x410a
movq %r14, %rdi
callq 0x21f0
nop