LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Level.cpp
// Function: DNest4::Level::read(std::istream&)
void Level::read(istream& in)
{
	log_likelihood.read(in);
	in>>log_X;
	in>>visits;
	in>>exceeds;
	in>>accepts;
	in>>tries;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x390ea
leaq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x62c0
leaq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x6500
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x6500
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x6500
addq $0x30, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6500
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/LikelihoodType.cpp
// Function: DNest4::LikelihoodType::LikelihoodType(double, double)
LikelihoodType::LikelihoodType(double value, double tiebreaker)
{
	assert(tiebreaker > 0. && tiebreaker < 1.);
    if(std::isinf(value) || std::isnan(value))
        value = -1E300;
    this->value = value;
    this->tiebreaker = tiebreaker;
}

// Assembly:
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jbe 0x3901b
movsd 0x4046(%rip), %xmm2     # 0x3d030
ucomisd %xmm1, %xmm2
jbe 0x3901b
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0x39011
movq 0x41c7(%rip), %xmm0     # 0x3d1d8
movq %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
retq
pushq %rax
leaq 0xbfbd(%rip), %rdi      # 0x44fe0
leaq 0xbfd9(%rip), %rsi      # 0x45003
leaq 0xbfe5(%rip), %rcx      # 0x45016
movl $0x13, %edx
callq 0x62b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/LikelihoodType.cpp
// Function: DNest4::LikelihoodType::operator<(DNest4::LikelihoodType const&) const
bool LikelihoodType::operator < (const LikelihoodType& other) const
{
	if(value < other.value)
		return true;
	if((value == other.value) &&
		(tiebreaker < other.tiebreaker))
		return true;
	return false;
}

// Assembly:
movsd (%rdi), %xmm0
movsd (%rsi), %xmm1
movb $0x1, %al
ucomisd %xmm0, %xmm1
ja 0x39094
ucomisd %xmm1, %xmm0
jne 0x39092
jp 0x39092
movsd 0x8(%rsi), %xmm0
ucomisd 0x8(%rdi), %xmm0
ja 0x39094
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Utils.cpp
// Function: DNest4::mod(int, int)
int mod(int y, int x)
{
    assert(x > 0);
    if(y >= 0)
        return y - (y/x)*x;
    else
        return (x-1) - DNest4::mod(-y-1, x);
}

// Assembly:
pushq %rbx
testl %esi, %esi
jle 0x3a0e7
movl %esi, %ebx
testl %edi, %edi
js 0x3a0d8
movl %edi, %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
jmp 0x3a0e5
notl %edi
movl %ebx, %esi
callq 0x3a0c3
notl %eax
addl %ebx, %eax
popq %rbx
retq
leaq 0xb1d6(%rip), %rdi      # 0x452c4
leaq 0xb1a2(%rip), %rsi      # 0x45297
leaq 0xb1ce(%rip), %rcx      # 0x452ca
movl $0x13, %edx
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Utils.cpp
// Function: DNest4::logsumexp(double*, int)
double logsumexp(double* logv, int n)
{
    assert(n > 1);
    double max = logv[0];
    for(int i=1; i<n; i++)
        if(logv[i] > max)
            max = logv[i];
    double answer = 0;
    // log(sum(exp(logf))   = log(sum(exp(logf - max(logf) + max(logf)))
    //          = max(logf) + log(sum(exp(logf - max(logf)))
    for(int i=0; i<n; i++)
        answer += exp(logv[i] - max);
    answer = max + log(answer);
    return answer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x1, %esi
jle 0x3a18b
movq %rdi, %rbx
movsd (%rdi), %xmm1
movl %esi, %r14d
movl $0x1, %eax
movapd %xmm1, %xmm0
movsd (%rbx,%rax,8), %xmm1
maxsd %xmm0, %xmm1
incq %rax
cmpq %rax, %r14
jne 0x3a123
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movsd (%rbx,%r15,8), %xmm0
subsd 0x8(%rsp), %xmm0
callq 0x6730
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r15
cmpq %r15, %r14
jne 0x3a145
callq 0x63c0
addsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb152(%rip), %rdi      # 0x452e4
leaq 0xb0fe(%rip), %rsi      # 0x45297
leaq 0xb14a(%rip), %rcx      # 0x452ea
movl $0x1c, %edx
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Utils.cpp
// Function: DNest4::logsumexp(std::vector<double, std::allocator<double>> const&)
double logsumexp(const std::vector<double>& logv)
{
    int n = static_cast<int>(logv.size());
    //if(n<=1)
    //  cout<<"Warning in logsumexp"<<endl;
    double max = *max_element(logv.begin(), logv.end());
    double answer = 0;
    // log(sum(exp(logf))   = log(sum(exp(logf - max(logf) + max(logf)))
    //          = max(logf) + log(sum(exp(logf - max(logf)))
    for(int i=0; i<n; i++)
        answer += exp(logv[i] - max);
    answer = max + log(answer);
    return answer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, %r14
subq %rax, %r14
sete %sil
shrq $0x3, %r14
movq %rax, %rdx
addq $0x8, %rdx
cmpq %rcx, %rdx
sete %dil
orb %sil, %dil
jne 0x3a1ff
movsd (%rax), %xmm0
movsd (%rdx), %xmm1
ucomisd %xmm0, %xmm1
cmovaq %rdx, %rax
maxsd %xmm0, %xmm1
addq $0x8, %rdx
movapd %xmm1, %xmm0
cmpq %rcx, %rdx
jne 0x3a1e2
movsd (%rax), %xmm0
testl %r14d, %r14d
movsd %xmm0, (%rsp)
jle 0x3a248
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorpd %xmm1, %xmm1
xorl %r15d, %r15d
movsd %xmm1, 0x8(%rsp)
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm0
subsd (%rsp), %xmm0
callq 0x6730
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
incq %r15
cmpq %r15, %r14
jne 0x3a21b
jmp 0x3a24c
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
callq 0x63c0
addsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Utils.cpp
// Function: DNest4::logdiffexp(double, double)
double logdiffexp(double a, double b)
{
    assert(a > b);
    double biggest = a;
    a -= biggest;
    b -= biggest;
    return log(exp(a) - exp(b)) + biggest;
}

// Assembly:
subq $0x18, %rsp
ucomisd %xmm1, %xmm0
jbe 0x3a2d7
movapd %xmm0, %xmm2
movsd %xmm0, 0x10(%rsp)
subsd %xmm0, %xmm0
subsd %xmm2, %xmm1
movsd %xmm1, (%rsp)
callq 0x6730
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x6730
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x63c0
addsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
leaq 0xb034(%rip), %rdi      # 0x45312
leaq 0xafb2(%rip), %rsi      # 0x45297
leaq 0xb02c(%rip), %rcx      # 0x45318
movl $0x41, %edx
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Utils.cpp
// Function: DNest4::r8poly_value(int, double*, double)
double r8poly_value(int n, double a[], double x)
{
    int i;
    double value = 0.0;
    for (i=n-1; 0<=i; i--)
        value = value * x + a[i];
    return value;
}

// Assembly:
testl %edi, %edi
jle 0x3a579
movl %edi, %eax
incq %rax
xorpd %xmm1, %xmm1
mulsd %xmm0, %xmm1
addsd -0x10(%rsi,%rax,8), %xmm1
decq %rax
cmpq $0x1, %rax
ja 0x3a564
jmp 0x3a57d
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Utils.cpp
// Function: DNest4::perturb_ns(std::vector<double, std::allocator<double>>&, DNest4::RNG&)
double perturb_ns(std::vector<double>& ns, RNG& rng)
{
    double logH = 0.0;

    if(rng.rand() <= 0.5)
    {
        // Perturb a single n
        int k = rng.rand_int(ns.size());
        logH -= -0.5*pow(ns[k], 2);
        ns[k] += rng.randh();
        logH += -0.5*pow(ns[k], 2);
    }
    else
    {
        // Resample several ns
        int reps = static_cast<int>(pow(ns.size(), rng.rand()));
        for(int i=0; i<reps; ++i)
        {
            int k = rng.rand_int(ns.size());
            ns[k] = rng.randn();
        }
    }
    return logH;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x39a4e
movq 0x8(%rbx), %rsi
movsd 0x2bf2(%rip), %xmm1     # 0x3d198
subq (%rbx), %rsi
ucomisd %xmm0, %xmm1
jae 0x3a633
sarq $0x3, %rsi
movq %rsi, %xmm0
punpckldq 0x2a4c(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2a54(%rip), %xmm0     # 0x3d020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
movq %r14, %rdi
callq 0x39a4e
movapd %xmm0, %xmm1
movapd (%rsp), %xmm0
callq 0x66f0
cvttsd2si %xmm0, %r15d
testl %r15d, %r15d
jle 0x3a62d
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
subq %rax, %rsi
shrq $0x3, %rsi
movq %r14, %rdi
callq 0x39bf8
movl %eax, %ebp
movq %r14, %rdi
callq 0x39a76
movslq %ebp, %rcx
movq (%rbx), %rax
movsd %xmm0, (%rax,%rcx,8)
decl %r15d
jne 0x3a600
xorpd %xmm0, %xmm0
jmp 0x3a68c
shrq $0x3, %rsi
movq %r14, %rdi
callq 0x39bf8
movslq %eax, %r15
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm0
mulsd %xmm0, %xmm0
mulsd 0x2b41(%rip), %xmm0     # 0x3d198
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq %r14, %rdi
callq 0x39b0e
movq (%rbx), %rax
addsd (%rax,%r15,8), %xmm0
movsd %xmm0, (%rax,%r15,8)
mulsd %xmm0, %xmm0
mulsd 0x29b1(%rip), %xmm0     # 0x3d038
addsd (%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Distributions/Cauchy.cpp
// Function: DNest4::TruncatedCauchy::TruncatedCauchy(double, double, double, double)
TruncatedCauchy::TruncatedCauchy(double center, double width,
                                 double lower, double upper)
:center(center), width(width)
,lower(lower), upper(upper)
{
    if(width <= 0.0)
        throw std::domain_error("TruncatedCauchy distribution must have positive width.");
    if(lower >= upper)
        throw std::domain_error("TruncatedCauchy: lower bound should be less than upper bound.");
    // the original, untruncated, Cauchy distribution
    unC = Cauchy(center, width);
    c = unC.cdf(upper) - unC.cdf(lower);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x1515a(%rip), %rax     # 0x4f998
movq %rax, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
movsd %xmm2, 0x18(%rdi)
movsd %xmm3, 0x20(%rdi)
leaq 0x150fc(%rip), %rax     # 0x4f958
movq %rax, 0x28(%rdi)
xorpd %xmm4, %xmm4
movhpd 0x27c4(%rip), %xmm4     # xmm4 = xmm4[0],mem[0]
movupd %xmm4, 0x30(%rdi)
xorpd %xmm4, %xmm4
ucomisd %xmm1, %xmm4
jae 0x3a913
movsd %xmm2, 0x10(%rsp)
movsd %xmm3, (%rsp)
ucomisd %xmm3, %xmm2
jae 0x3a931
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x3a698
movups 0x8(%r14), %xmm0
movups %xmm0, (%r15)
movsd (%rsp), %xmm0
subsd 0x30(%rbx), %xmm0
divsd 0x38(%rbx), %xmm0
callq 0x63e0
movapd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
subsd 0x30(%rbx), %xmm0
divsd 0x38(%rbx), %xmm0
callq 0x63e0
movapd (%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
divpd 0xac10(%rip), %xmm1     # 0x45500
addpd 0xac18(%rip), %xmm1     # 0x45510
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
subsd %xmm0, %xmm1
movsd %xmm1, 0x40(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xabf9(%rip), %rsi      # 0x45520
movq %rax, %rdi
callq 0x6280
jmp 0x3a94d
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xac12(%rip), %rsi      # 0x45557
movq %rax, %rdi
callq 0x6280
movq 0x155ec(%rip), %rsi     # 0x4ff40
movq 0x15605(%rip), %rdx     # 0x4ff60
movq %rbx, %rdi
callq 0x66c0
jmp 0x3a965
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Distributions/Cauchy.cpp
// Function: DNest4::TruncatedCauchy::cdf_inverse(double) const
double TruncatedCauchy::cdf_inverse(double x) const
{
    if(x < 0.0 || x > 1.0)
        throw std::domain_error("Input to cdf_inverse must be in [0, 1].");
    double xx = unC.cdf(lower) + x * c;
    return unC.cdf_inverse(xx);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x3aa5b
ucomisd 0x2624(%rip), %xmm1     # 0x3d030
ja 0x3aa5b
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movsd 0x18(%rdi), %xmm0
subsd 0x30(%rdi), %xmm0
divsd 0x38(%rdi), %xmm0
movsd %xmm1, (%rsp)
callq 0x63e0
divsd 0x2caa(%rip), %xmm0     # 0x3d6e0
addsd 0x275a(%rip), %xmm0     # 0x3d198
movsd (%rsp), %xmm1
mulsd 0x40(%rbx), %xmm1
addsd %xmm1, %xmm0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3a72a
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0x25d1(%rip), %rsi      # 0x3d040
movq %rax, %rdi
callq 0x6280
movq 0x154c2(%rip), %rsi     # 0x4ff40
movq 0x154db(%rip), %rdx     # 0x4ff60
movq %rbx, %rdi
callq 0x66c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Distributions/ContinuousDistribution.cpp
// Function: DNest4::ContinuousDistribution::perturb(double&, DNest4::RNG&) const
double ContinuousDistribution::perturb(double& x, RNG& rng) const
{
    x = cdf(x);
    x += rng.randh();
    wrap(x, 0.0, 1.0);
    x = cdf_inverse(x);

    return 0.0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movsd (%rsi), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
movsd %xmm0, (%rbx)
movq %r14, %rdi
callq 0x39b0e
addsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
movsd 0x23c6(%rip), %xmm1     # 0x3d030
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x3a047
movsd (%rbx), %xmm0
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movsd %xmm0, (%rbx)
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Distributions/Exponential.cpp
// Function: DNest4::TruncatedExponential::TruncatedExponential(double, double, double)
TruncatedExponential::TruncatedExponential(double scale, double lower, double upper)
:scale(scale)
,lower(lower), upper(upper)
{
    if(scale <= 0.0)
        throw std::domain_error("TruncatedExponential distribution must have positive scale.");
    if(lower >= upper)
        throw std::domain_error("TruncatedExponential: lower bound should be less than upper bound.");
    // the original, untruncated, Exponential distribution
    unE = Exponential(scale);
    c = unE.cdf(upper) - unE.cdf(lower);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x14bdc(%rip), %rax     # 0x4fa48
movq %rax, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
movsd %xmm2, 0x18(%rdi)
leaq 0x14b83(%rip), %rax     # 0x4fa08
movq %rax, 0x20(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x28(%rdi)
xorpd %xmm3, %xmm3
ucomisd %xmm0, %xmm3
jae 0x3af2e
movapd %xmm1, 0x10(%rsp)
movapd %xmm2, (%rsp)
ucomisd %xmm2, %xmm1
jae 0x3af4c
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x3ac90
movsd 0x8(%r14), %xmm1
movsd %xmm1, 0x28(%rbx)
movapd (%rsp), %xmm0
xorpd 0x287e(%rip), %xmm0     # 0x3d760
divsd %xmm1, %xmm0
callq 0x6730
movsd 0x213d(%rip), %xmm1     # 0x3d030
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movapd 0x10(%rsp), %xmm0
xorpd 0x2856(%rip), %xmm0     # 0x3d760
divsd 0x28(%rbx), %xmm0
callq 0x6730
addsd 0x280c(%rip), %xmm0     # 0x3d728
addsd (%rsp), %xmm0
movsd %xmm0, 0x30(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xa69b(%rip), %rsi      # 0x455dd
movq %rax, %rdi
callq 0x6280
jmp 0x3af68
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xa6b9(%rip), %rsi      # 0x45619
movq %rax, %rdi
callq 0x6280
movq 0x14fd1(%rip), %rsi     # 0x4ff40
movq 0x14fea(%rip), %rdx     # 0x4ff60
movq %rbx, %rdi
callq 0x66c0
jmp 0x3af80
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Distributions/Exponential.cpp
// Function: DNest4::TruncatedExponential::cdf_inverse(double) const
double TruncatedExponential::cdf_inverse(double x) const
{
    if(x < 0.0 || x > 1.0)
        throw std::domain_error("Input to cdf_inverse must be in [0, 1].");
    double xx = unE.cdf(lower) + x * c;
    return unE.cdf_inverse(xx);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x3b0d2
ucomisd 0x1fb0(%rip), %xmm1     # 0x3d030
ja 0x3b0d2
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movsd 0x10(%rdi), %xmm0
xorpd 0x26ca(%rip), %xmm0     # 0x3d760
divsd 0x28(%rdi), %xmm0
movsd %xmm1, (%rsp)
callq 0x6730
movsd 0x1f83(%rip), %xmm1     # 0x3d030
movsd (%rsp), %xmm2
mulsd 0x30(%rbx), %xmm2
subsd %xmm0, %xmm1
addsd %xmm1, %xmm2
movapd %xmm2, %xmm0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3ad80
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0x1f5a(%rip), %rsi      # 0x3d040
movq %rax, %rdi
callq 0x6280
movq 0x14e4b(%rip), %rsi     # 0x4ff40
movq 0x14e64(%rip), %rdx     # 0x4ff60
movq %rbx, %rdi
callq 0x66c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Distributions/Gaussian.cpp
// Function: DNest4::Gaussian::cdf_inverse(double) const
double Gaussian::cdf_inverse(double x) const
{
    if(x < 0.0 || x > 1.0)
        throw std::domain_error("Input to cdf_inverse must be in [0, 1].");
    return center + width*normal_inverse_cdf(x);
    //return center + width * sqrt(2) * boost::math::erf_inv(2*x - 1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x3b354
ucomisd 0x1d0d(%rip), %xmm0     # 0x3d030
ja 0x3b354
movsd 0x8(%rdi), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x10(%rdi), %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0x3a316
mulsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0x1cd8(%rip), %rsi      # 0x3d040
movq %rax, %rdi
callq 0x6280
movq 0x14bc9(%rip), %rsi     # 0x4ff40
movq 0x14be2(%rip), %rdx     # 0x4ff60
movq %rbx, %rdi
callq 0x66c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Distributions/Gaussian.cpp
// Function: DNest4::TruncatedGaussian::TruncatedGaussian(double, double, double, double)
TruncatedGaussian::TruncatedGaussian(double center, double width, double lower, double upper)
:center(center)
,width(width)
,lower(lower)
,upper(upper)
{
    if(width <= 0.0)
        throw std::domain_error("TruncatedGaussian distribution must have positive width.");
    if(lower >= upper)
        throw std::domain_error("TruncatedGaussian: lower bound should be less than upper bound.");
    // the original, untruncated, Gaussian distribution
    unG = Gaussian(center, width);
    c = unG.cdf(upper) - unG.cdf(lower);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x1472e(%rip), %rax     # 0x4faf8
movq %rax, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
movsd %xmm2, 0x18(%rdi)
movsd %xmm3, 0x20(%rdi)
leaq 0x146d0(%rip), %rax     # 0x4fab8
movq %rax, 0x28(%rdi)
xorps %xmm4, %xmm4
movhps 0x1c3a(%rip), %xmm4     # xmm4 = xmm4[0,1],mem[0,1]
movups %xmm4, 0x30(%rdi)
movapd 0xa2ae(%rip), %xmm4     # 0x456b0
movupd %xmm4, 0x40(%rdi)
xorpd %xmm4, %xmm4
ucomisd %xmm1, %xmm4
jae 0x3b495
movsd %xmm2, 0x8(%rsp)
movsd %xmm3, (%rsp)
ucomisd %xmm3, %xmm2
jae 0x3b4b3
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x3b27c
movq 0x18(%r14), %rax
movq %rax, 0x10(%r15)
movups 0x8(%r14), %xmm0
movups %xmm0, (%r15)
movsd (%rsp), %xmm0
subsd 0x30(%rbx), %xmm0
divsd 0x38(%rbx), %xmm0
callq 0x3a2f6
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
subsd 0x30(%rbx), %xmm0
divsd 0x38(%rbx), %xmm0
callq 0x3a2f6
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x50(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xa217(%rip), %rsi      # 0x456c0
movq %rax, %rdi
callq 0x6280
jmp 0x3b4cf
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xa232(%rip), %rsi      # 0x456f9
movq %rax, %rdi
callq 0x6280
movq 0x14a6a(%rip), %rsi     # 0x4ff40
movq 0x14a83(%rip), %rdx     # 0x4ff60
movq %rbx, %rdi
callq 0x66c0
jmp 0x3b4e7
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Distributions/Gaussian.cpp
// Function: DNest4::TruncatedGaussian::cdf_inverse(double) const
double TruncatedGaussian::cdf_inverse(double x) const
{
    if(x < 0.0 || x > 1.0)
        throw std::domain_error("Input to cdf_inverse must be in [0, 1].");
    double xx = unG.cdf(lower) + x * c;
    return unG.cdf_inverse(xx);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x3b5b3
ucomisd 0x1abc(%rip), %xmm1     # 0x3d030
ja 0x3b5b3
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movsd 0x18(%rdi), %xmm0
subsd 0x30(%rdi), %xmm0
divsd 0x38(%rdi), %xmm0
movsd %xmm1, (%rsp)
callq 0x3a2f6
movsd (%rsp), %xmm1
mulsd 0x50(%rbx), %xmm1
addsd %xmm1, %xmm0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3b30a
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0x1a79(%rip), %rsi      # 0x3d040
movq %rax, %rdi
callq 0x6280
movq 0x1496a(%rip), %rsi     # 0x4ff40
movq 0x14983(%rip), %rdx     # 0x4ff60
movq %rbx, %rdi
callq 0x66c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Distributions/Laplace.cpp
// Function: DNest4::Laplace::setpars(double, double)
void Laplace::setpars(double c, double w)
{
    if(w <= 0.0)
        throw std::domain_error("Laplace distribution must have positive width.");
    center = c;
    width = w;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
jae 0x3b810
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0x9f7c(%rip), %rsi      # 0x457a0
movq %rax, %rdi
callq 0x6280
movq 0x1470d(%rip), %rsi     # 0x4ff40
movq 0x14726(%rip), %rdx     # 0x4ff60
movq %rbx, %rdi
callq 0x66c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Distributions/LogUniform.cpp
// Function: DNest4::LogUniform::LogUniform(double, double)
LogUniform::LogUniform(double _lower, double _upper)
:lower(_lower)
,upper(_upper)
{
    if(lower <= 0.0)
        throw std::domain_error("LogUniform distribution must have positive lower limit.");
    if (upper <= lower)
        throw std::domain_error("LogUniform distribution must have lower < upper limits");

    d = log(upper / lower);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x14149(%rip), %rax     # 0x4fbc0
movq %rax, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jae 0x3bab1
ucomisd %xmm1, %xmm0
jae 0x3bacf
movq %rdi, %rbx
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x63c0
movsd %xmm0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0x9d25(%rip), %rsi      # 0x457ea
movq %rax, %rdi
callq 0x6280
jmp 0x3baeb
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0x9d3f(%rip), %rsi      # 0x45822
movq %rax, %rdi
callq 0x6280
movq 0x1444e(%rip), %rsi     # 0x4ff40
movq 0x14467(%rip), %rdx     # 0x4ff60
movq %rbx, %rdi
callq 0x66c0
jmp 0x3bb03
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Distributions/LogUniform.cpp
// Function: DNest4::LogUniform::cdf(double) const
double LogUniform::cdf(double x) const
{
    if(x < lower)
        return 0.0;
    if(x > upper)
        return 1.0;
    return (log(x) - log(lower)) / d;
}

// Assembly:
movsd 0x8(%rdi), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm1
ja 0x3bb67
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
ucomisd 0x10(%rdi), %xmm0
jbe 0x3bb3e
movsd 0x14f4(%rip), %xmm2     # 0x3d030
jmp 0x3bb62
callq 0x63c0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rbx), %xmm0
callq 0x63c0
movsd 0x8(%rsp), %xmm2
subsd %xmm0, %xmm2
divsd 0x18(%rbx), %xmm2
addq $0x10, %rsp
popq %rbx
movapd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Distributions/LogUniform.cpp
// Function: DNest4::ModifiedLogUniform::ModifiedLogUniform(double, double)
ModifiedLogUniform::ModifiedLogUniform(double _knee, double _upper)
:knee(_knee)
,upper(_upper)
{
    if(knee <= 0.0)
        throw std::domain_error("ModifiedLogUniform distribution must have positive knee.");
    if (upper <= knee)
        throw std::domain_error("ModifiedLogUniform distribution must have knee < upper limit");

    d = 1.0 / log(1.0 + upper / knee);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x13fb1(%rip), %rax     # 0x4fc00
movq %rax, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jae 0x3bc9d
ucomisd %xmm1, %xmm0
jae 0x3bcbb
movq %rdi, %rbx
divsd %xmm0, %xmm1
addsd 0x13b5(%rip), %xmm1     # 0x3d030
movapd %xmm1, %xmm0
callq 0x63c0
movsd 0x13a4(%rip), %xmm1     # 0x3d030
divsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0x9ba8(%rip), %rsi      # 0x45859
movq %rax, %rdi
callq 0x6280
jmp 0x3bcd7
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0x9bc3(%rip), %rsi      # 0x45892
movq %rax, %rdi
callq 0x6280
movq 0x14262(%rip), %rsi     # 0x4ff40
movq 0x1427b(%rip), %rdx     # 0x4ff60
movq %rbx, %rdi
callq 0x66c0
jmp 0x3bcef
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/RJObject/ConditionalPriors/ConditionalPrior.cpp
// Function: DNest4::ConditionalPrior::perturb1(DNest4::RNG&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
double ConditionalPrior::perturb1(RNG& rng, const vector< vector<double> >& components,
				vector< vector<double> >& u_components)
{
	double logH = 0.;

	// 1/(old density)
	for(size_t i=0; i<components.size(); i++)
		logH -= log_pdf(components[i]);

	logH += perturb_hyperparameters(rng);

	// (new density)
	for(size_t i=0; i<components.size(); i++)
	{
		logH += log_pdf(components[i]);
		u_components[i] = components[i];
		to_uniform(u_components[i]);

        for(size_t j=0; j<components[i].size(); ++j)
            if(u_components[i][j] <= 0.0 || u_components[i][j] >= 1.0)
                logH = -1E300;
	}

	return logH;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movq (%rdx), %rsi
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
cmpq %rsi, 0x8(%rdx)
je 0x3c127
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %ebp, %ebp
xorl %r12d, %r12d
addq %rbp, %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incq %r12
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %r13, %rax
addq $0x18, %rbp
cmpq %rax, %r12
jb 0x3c0ed
jmp 0x3c130
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq (%r15), %rax
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq *(%rax)
addsd (%rsp), %xmm0
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0x3c232
xorl %r12d, %r12d
movapd %xmm0, (%rsp)
leaq (,%r12,8), %rax
leaq (%rax,%rax,2), %rbp
addq %rbp, %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
addsd (%rsp), %xmm0
movapd %xmm0, (%rsp)
movq (%r14), %rsi
addq %rbp, %rsi
movq (%rbx), %rdi
addq %rbp, %rdi
callq 0x739c
movq (%rbx), %rsi
addq %rbp, %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x30(%rax)
movq (%r14), %rsi
movq 0x8(%rsi,%rbp), %rax
subq (%rsi,%rbp), %rax
je 0x3c212
sarq $0x3, %rax
movq (%rbx), %rcx
leaq (%r12,%r12,2), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $0x1, %rax
adcq $0x0, %rax
xorl %edx, %edx
movsd 0xe68(%rip), %xmm1      # 0x3d030
movsd 0x1008(%rip), %xmm2     # 0x3d1d8
xorpd %xmm3, %xmm3
movapd (%rsp), %xmm5
movsd (%rcx,%rdx,8), %xmm0
movapd %xmm1, %xmm4
cmpnlesd %xmm0, %xmm4
andpd %xmm4, %xmm5
andnpd %xmm2, %xmm4
orpd %xmm5, %xmm4
cmpnlesd %xmm3, %xmm0
andpd %xmm0, %xmm4
andnpd %xmm2, %xmm0
orpd %xmm4, %xmm0
incq %rdx
movapd %xmm0, %xmm5
cmpq %rdx, %rax
jne 0x3c1d9
jmp 0x3c217
movapd (%rsp), %xmm0
incq %r12
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %r13, %rax
cmpq %rax, %r12
jb 0x3c152
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/RJObject/ConditionalPriors/ConditionalPrior.cpp
// Function: DNest4::ConditionalPrior::perturb2(DNest4::RNG&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&)
double ConditionalPrior::perturb2(RNG& rng, vector< vector<double> >& components,
				const vector< vector<double> >& u_components)
{
	double logH = 0.;

	logH += perturb_hyperparameters(rng);

	// Find new positions
	for(size_t i=0; i<components.size(); i++)
	{
		components[i] = u_components[i];
		from_uniform(components[i]);
	}

	return logH;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *(%rax)
movsd %xmm0, (%rsp)
movq (%r14), %rdi
cmpq %rdi, 0x8(%r14)
je 0x3c2b3
xorl %r12d, %r12d
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
xorl %ebp, %ebp
movq (%rbx), %rsi
addq %r12, %rsi
addq %r12, %rdi
callq 0x739c
movq (%r14), %rsi
addq %r12, %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
incq %rbp
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r13, %rax
addq $0x18, %r12
cmpq %rax, %rbp
jb 0x3c278
xorpd %xmm1, %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/tests/autotest.cpp
// Function: showTimeElapsed()
void showTimeElapsed() {
  long long curtime = getVa();
  
  if(curtime - lasttime < 100000) 
    cout << "time elapsed: " << (curtime-lasttime) << " \u03bcs" << endl;

  else
    printf("time elapsed: %.6f s\n", (curtime-lasttime)/1000000.0);

  lasttime = curtime;
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x73b0
imulq $0xf4240, (%rbx), %r14  # imm = 0xF4240
addq 0x8(%rbx), %r14
movq %r14, %rax
subq 0x4a3be(%rip), %rax     # 0x522b8
cmpq $0x1869f, %rax          # imm = 0x1869F
jg 0x7f6f
movq 0x4a0c7(%rip), %rbx     # 0x51fd0
leaq 0x37110(%rip), %rsi     # 0x3f020
movl $0xe, %edx
movq %rbx, %rdi
callq 0x72c0
movq %r14, %rsi
subq 0x4a391(%rip), %rsi     # 0x522b8
movq %rbx, %rdi
callq 0x7100
movq %rax, %rbx
leaq 0x370f6(%rip), %rsi     # 0x3f02f
movl $0x4, %edx
movq %rax, %rdi
callq 0x72c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7250
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7030
movq %rax, %rdi
callq 0x7190
jmp 0x7f8a
cvtsi2sd %rax, %xmm0
divsd 0x3708c(%rip), %xmm0    # 0x3f008
leaq 0x370b1(%rip), %rdi     # 0x3f034
movb $0x1, %al
callq 0x7050
movq %r14, 0x4a327(%rip)     # 0x522b8
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/tests/../include/lois.h
// Function: lois::lsetof<lois::term>::lsetof(lois::lsetof<lois::term> const&)
lsetof<T>(const lsetof<T> &x) : ain(currentcontext) {
    if(in_substitution) {
      ain = x.ain;
      elts = x.elts;
      return;
      }
    if(debuglois) std::cout << ido << "copying " << x << " ain = " << emptycontext << std::endl;
    autoindenter i2;
    (*this) |= x;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x41f96(%rip), %rax     # 0x52770
movq (%rax), %rcx
movq %rcx, (%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x10802
movq 0x417d4(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x107fe
incl 0x8(%rax)
jmp 0x10802
lock
incl 0x8(%rax)
leaq 0x8(%r12), %rbx
leaq 0x10(%r12), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movq $0x0, 0x20(%r12)
leaq 0x423c3(%rip), %rax     # 0x52be8
cmpb $0x1, (%rax)
jne 0x10851
movq (%r15), %rax
movq %rax, (%r12)
leaq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x1615e
addq $0x10, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1d476
jmp 0x10941
leaq 0x42340(%rip), %rax     # 0x52b98
cmpb $0x1, (%rax)
jne 0x10925
leaq 0x41a00(%rip), %rax     # 0x52268
movq (%rax), %rsi
movq 0x4175e(%rip), %rdi     # 0x51fd0
callq 0x3ab44
movq %rax, %r13
leaq 0x2ea5a(%rip), %rsi     # 0x3f2db
movl $0x8, %edx
movq %rax, %rdi
callq 0x72c0
movq %r15, %rdi
movq %r13, %rsi
callq 0x20106
movq %rax, %r13
leaq 0x2ea41(%rip), %rsi     # 0x3f2e4
movl $0x7, %edx
movq %rax, %rdi
callq 0x72c0
leaq 0x41ea9(%rip), %rax     # 0x52760
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, (%rsp)
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x108e1
movq 0x416f5(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x108dd
incl 0x8(%rax)
jmp 0x108e1
lock
incl 0x8(%rax)
movq %rsp, %rsi
movq %r13, %rdi
callq 0x161a7
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x7250
movsbl %al, %esi
movq %r13, %rdi
callq 0x7030
movq %rax, %rdi
callq 0x7190
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x10925
callq 0x133fc
leaq 0x41fbc(%rip), %r13     # 0x528e8
addl $0x2, (%r13)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1d638
addl $-0x2, (%r13)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
addl $-0x2, (%r13)
jmp 0x10970
movq %rax, %r15
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x10970
callq 0x133fc
jmp 0x10970
movq %rax, %r15
movq %r14, %rdi
callq 0x138d0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x10985
callq 0x133fc
movq %r15, %rdi
callq 0x7430
nop
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/tests/../include/lois.h
// Function: lois::lsetof<lois::term> lois::newSet<lois::term>(lois::term, lois::term)
lsetof<T> newSet(T x, T y) {
  lsetof<T> res; 
  res.insert(x, currentcontext); 
  res.insert(y, currentcontext); 
  return res;   
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x8, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
leaq 0x411a6(%rip), %r12     # 0x52770
movq (%r12), %rax
movq %rax, (%rbx)
leaq 0x8(%r12), %rsi
callq 0x1615e
movq (%r15), %rax
movq %rax, 0x58(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x60(%rsp)
testq %rax, %rax
je 0x11606
movq 0x409d0(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x11602
incl 0x8(%rax)
jmp 0x11606
lock
incl 0x8(%rax)
movq (%r12), %rdx
movq 0x8(%r12), %rax
movq %rdx, 0x48(%rsp)
movq %rax, 0x50(%rsp)
testq %rax, %rax
je 0x11639
movq 0x409a3(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x11649
incl 0x8(%rax)
movq %rdx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
jmp 0x11665
movq %rdx, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
jmp 0x11673
lock
incl 0x8(%rax)
movq (%r12), %rdx
movq 0x8(%r12), %rax
movq %rdx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x11673
cmpb $0x0, (%rcx)
je 0x1166f
incl 0x8(%rax)
jmp 0x11673
lock
incl 0x8(%rax)
leaq 0x58(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x18(%rsp), %rcx
movq %rbx, %rdi
callq 0x1d8ac
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x11699
callq 0x133fc
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x116a8
callq 0x133fc
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x116b7
callq 0x133fc
movq (%r14), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x116e2
movq 0x408f4(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x116de
incl 0x8(%rax)
jmp 0x116e2
lock
incl 0x8(%rax)
movq (%r12), %rdx
movq 0x8(%r12), %rax
movq %rdx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x11715
movq 0x408c7(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x11725
incl 0x8(%rax)
movq %rdx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x11741
movq %rdx, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
jmp 0x1174f
lock
incl 0x8(%rax)
movq (%r12), %rdx
movq 0x8(%r12), %rax
movq %rdx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x1174f
cmpb $0x0, (%rcx)
je 0x1174b
incl 0x8(%rax)
jmp 0x1174f
lock
incl 0x8(%rax)
leaq 0x38(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x1d8ac
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x11775
callq 0x133fc
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x11784
callq 0x133fc
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x11793
callq 0x133fc
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x117b4
callq 0x133fc
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x117c3
callq 0x133fc
movq 0x40(%rsp), %rdi
jmp 0x117f0
movq %rax, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x117dc
callq 0x133fc
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x117eb
callq 0x133fc
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x117fa
callq 0x133fc
movq %rbx, %rdi
callq 0x10a0c
movq %r14, %rdi
callq 0x7430
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/tests/../include/loisextra.h
// Function: std::ostream& lois::operator<<<lois::term>(std::ostream&, lois::lvector<lois::term> const&)
std::ostream& operator << (std::ostream& os, const lvector<T>& p) { 
    bool first = true;
    os << "[";    
    for(auto& t: p) { if(!first) os << ","; first = false; os << t; }
    os << "]";
    return os;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28cf4(%rip), %rsi     # 0x4098f
movl $0x1, %edx
callq 0x72c0
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r13, %r12
je 0x17d04
movb $0x1, %al
leaq 0x27439(%rip), %r14     # 0x3f0f3
leaq 0x27618(%rip), %r15     # 0x3f2d9
testb $0x1, %al
jne 0x17cd5
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x72c0
movq (%r12), %rdi
testq %rdi, %rdi
je 0x17ce9
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
jmp 0x17cf9
movl $0xb, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72c0
addq $0x10, %r12
xorl %eax, %eax
cmpq %r13, %r12
jne 0x17cc1
leaq 0x29592(%rip), %rsi     # 0x4129d
movl $0x1, %edx
movq %rbx, %rdi
callq 0x72c0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/tests/../include/loisextra.h
// Function: lois::rbool lois::operator==<lois::term>(lois::lvector<lois::term> const&, lois::lvector<lois::term> const&)
rbool operator == (const lvector<T>& a, const lvector<T>& b) { 
    lbool res = ftrue;
    if(a.size() != b.size()) { res = ffalse; return res;}
    for(int i=0; i<(int) a.size(); i++)
      res &= (a[i] == b[i]);
    return res; 
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x39eeb(%rip), %rax     # 0x527b0
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x188f0
movq 0x396e6(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x188ec
incl 0x8(%rax)
jmp 0x188f0
lock
incl 0x8(%rax)
movq %rsp, %rdi
leaq 0x38(%rsp), %r12
movq %r12, %rsi
callq 0x1391e
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x1890f
callq 0x133fc
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
movq 0x8(%r14), %rcx
subq (%r14), %rcx
cmpq %rcx, %rax
jne 0x18991
movq %rbx, 0x20(%rsp)
shrq $0x4, %rax
testl %eax, %eax
jle 0x18985
xorl %ebp, %ebp
leaq 0x28(%rsp), %r12
movq %rsp, %r13
xorl %ebx, %ebx
addq %rbp, %rsi
movq (%r14), %rdx
addq %rbp, %rdx
movq %r12, %rdi
callq 0x2bf46
movq %r13, %rdi
movq %r12, %rsi
callq 0x13976
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x18969
callq 0x133fc
incq %rbx
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
shrq $0x4, %rax
cltq
addq $0x10, %rbp
cmpq %rax, %rbx
jl 0x1893e
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rbx
jmp 0x189a5
leaq 0x39e28(%rip), %rsi     # 0x527c0
movq %rsp, %rdi
callq 0x12f56
movq 0x10(%rsp), %rax
movq %rax, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x189cb
movq 0x3960b(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x189c7
incl 0x8(%rax)
jmp 0x189cb
lock
incl 0x8(%rax)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x189da
callq 0x133fc
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x189e9
callq 0x133fc
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x189fd
movq %rax, %rbx
jmp 0x18a14
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x18a14
callq 0x133fc
movq %rsp, %rdi
callq 0x133d8
movq %rbx, %rdi
callq 0x7430
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/tests/../include/lois.h
// Function: bool lois::usesenv<lois::rbool>(lois::rbool const&, std::shared_ptr<lois::Context>, std::shared_ptr<lois::Context>)
bool usesenv(const T& obj, contextptr anccontext = emptycontext, contextptr nowcontext = currentcontext) {
  contextptr e = nowcontext;
  while(e != anccontext) {
    if(!e) throw env_exception();
    for(auto w: e->var) if(isused(w, obj)) return true;
    e = e->parent;
    }
  return false;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r8
movq %rdi, %r14
movq (%rdx), %rsi
movq %rsi, 0x10(%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x1c595
movq 0x35a46(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x1c58c
incl 0x8(%rax)
jmp 0x1c595
lock
incl 0x8(%rax)
movq 0x10(%rsp), %rsi
cmpq (%r8), %rsi
je 0x1c6b0
movq 0x35a23(%rip), %rbx     # 0x51fc8
movq %r8, 0x30(%rsp)
testq %rsi, %rsi
je 0x1c6d6
movq 0x20(%rsi), %r12
movq 0x28(%rsi), %r13
cmpq %r13, %r12
je 0x1c687
movq (%r12), %rax
movq 0x8(%r12), %rbp
testq %rbp, %rbp
je 0x1c5e5
cmpb $0x0, (%rbx)
je 0x1c5f4
incl 0x8(%rbp)
movq %rax, (%rsp)
movq %rbp, 0x8(%rsp)
jmp 0x1c606
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
jmp 0x1c609
lock
incl 0x8(%rbp)
cmpb $0x0, (%rbx)
movq %rax, (%rsp)
movq %rbp, 0x8(%rsp)
je 0x1c67c
incl 0x8(%rbp)
movq (%r14), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x1c62d
cmpb $0x0, (%rbx)
je 0x1c629
incl 0x8(%rax)
jmp 0x1c62d
lock
incl 0x8(%rax)
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x297ef
movl %eax, %r15d
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1c64c
callq 0x133fc
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1c65b
callq 0x133fc
testq %rbp, %rbp
je 0x1c668
movq %rbp, %rdi
callq 0x133fc
testb %r15b, %r15b
jne 0x1c6b4
addq $0x10, %r12
cmpq %r13, %r12
jne 0x1c5c4
jmp 0x1c682
lock
incl 0x8(%rbp)
jmp 0x1c609
movq 0x10(%rsp), %rsi
movq (%rsi), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rsi
leaq 0x18(%rsp), %rdi
callq 0x1615e
movq 0x10(%rsp), %rsi
movq 0x30(%rsp), %r8
cmpq (%r8), %rsi
jne 0x1c5aa
xorl %ebx, %ebx
jmp 0x1c6b6
movb $0x1, %bl
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1c6c5
callq 0x133fc
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x7150
leaq 0x33e39(%rip), %rcx     # 0x50520
movq %rcx, (%rax)
leaq 0x33e07(%rip), %rsi     # 0x504f8
movq 0x358e8(%rip), %rdx     # 0x51fe0
movq %rax, %rdi
callq 0x7400
movq %rax, %rbx
jmp 0x1c733
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1c717
callq 0x133fc
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1c726
callq 0x133fc
testq %rbp, %rbp
je 0x1c733
movq %rbp, %rdi
callq 0x133fc
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1c742
callq 0x133fc
movq %rbx, %rdi
callq 0x7430
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/tests/../include/lois.h
// Function: bool lois::isused<lois::term>(std::shared_ptr<lois::Variable>, lois::lsetof<lois::term> const&)
bool isused(vptr w, const lsetof<T>& where) { 
  for(auto e: where.elts)
    if(isused(w, e->a) || isused(w, e->phi)) 
      return true;
  return false;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, 0x18(%rsp)
movq 0x10(%rsi), %r12
movq 0x18(%rsi), %rax
movq %rax, 0x40(%rsp)
cmpq %rax, %r12
je 0x262bb
movq 0x2be74(%rip), %rbp     # 0x51fc8
movq (%r12), %r14
movq 0x8(%r12), %rbx
testq %rbx, %rbx
je 0x26171
cmpb $0x0, (%rbp)
je 0x2616d
incl 0x8(%rbx)
jmp 0x26171
lock
incl 0x8(%rbx)
movq 0x18(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %r15
testq %r15, %r15
je 0x2619c
cmpb $0x0, (%rbp)
je 0x261b0
incl 0x8(%r15)
movq 0x28(%r14), %rdi
movq %rax, 0x8(%rsp)
movq %r15, 0x10(%rsp)
jmp 0x261cd
movq 0x28(%r14), %rdi
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
jmp 0x261d1
lock
incl 0x8(%r15)
cmpb $0x0, (%rbp)
movq 0x28(%r14), %rdi
movq %rax, 0x8(%rsp)
movq %r15, 0x10(%rsp)
je 0x262b1
incl 0x8(%r15)
movq (%rdi), %rax
leaq 0x8(%rsp), %rsi
callq *0x20(%rax)
movl %eax, %ebp
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x261ed
callq 0x133fc
movb $0x1, %r13b
testb %bpl, %bpl
movq 0x2bdce(%rip), %rbp     # 0x51fc8
jne 0x26280
movq 0x18(%rsp), %rcx
movq (%rcx), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%rcx), %rax
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0x2622a
cmpb $0x0, (%rbp)
je 0x26226
incl 0x8(%rax)
jmp 0x2622a
lock
incl 0x8(%rax)
movq 0x18(%r14), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%r14), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x26250
cmpb $0x0, (%rbp)
je 0x2624c
incl 0x8(%rax)
jmp 0x26250
lock
incl 0x8(%rax)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x297ef
movl %eax, %r13d
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x26271
callq 0x133fc
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x26280
callq 0x133fc
testq %r15, %r15
je 0x2628d
movq %r15, %rdi
callq 0x133fc
testq %rbx, %rbx
je 0x2629a
movq %rbx, %rdi
callq 0x133fc
addq $0x10, %r12
cmpq 0x40(%rsp), %r12
sete %al
orb %r13b, %al
je 0x26154
jmp 0x262be
lock
incl 0x8(%r15)
jmp 0x261d1
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x262e2
callq 0x133fc
movq 0x38(%rsp), %rdi
jmp 0x262f1
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x262fb
callq 0x133fc
testq %r15, %r15
je 0x26308
movq %r15, %rdi
callq 0x133fc
testq %rbx, %rbx
je 0x26315
movq %rbx, %rdi
callq 0x133fc
movq %r14, %rdi
callq 0x7430
nop
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/env.cpp
// Function: lois::ArbCondition::enable(lois::rbool)
bool ArbCondition::enable(rbool psi) { 
  disable();
  currentcontext = ourcontext = std::make_shared<Context> (currentcontext, psi);
  int res = solver->solveEnv();
  if(res == 1) { throw unsolvable_exception(); }
  return res == 2;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x29036
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x29696(%rip), %rcx     # 0x52770
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
movq %r14, %r8
callq 0x2965a
movq (%r15), %rax
movq 0x8(%r15), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq %rax, 0x8(%rbx)
leaq 0x10(%rbx), %r14
movq 0x10(%rbx), %rdi
movq %rcx, 0x10(%rbx)
testq %rdi, %rdi
je 0x2911b
callq 0x133fc
movq 0x8(%rbx), %rax
movq %rax, 0x2964e(%rip)     # 0x52770
leaq 0x2964f(%rip), %rdi     # 0x52778
movq %r14, %rsi
callq 0x1615e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x29140
callq 0x133fc
leaq 0x29729(%rip), %rax     # 0x52870
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x1, %eax
je 0x29165
cmpl $0x2, %eax
sete %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x7150
leaq 0x27832(%rip), %rcx     # 0x509a8
movq %rcx, (%rax)
leaq 0x277d8(%rip), %rsi     # 0x50958
movq 0x28e59(%rip), %rdx     # 0x51fe0
movq %rax, %rdi
callq 0x7400
nop