LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/app/icnf/icnf.c
// Function: msg
static void msg (const char * fmt, ...) {
  va_list ap;
  fflush (stderr);
  printf ("c [icnf] ");
  va_start (ap, fmt);
  vprintf (fmt, ap);
  va_end (ap);
  fputc ('\n', stdout);
  fflush (stdout);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x2ef3
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0xb0e6(%rip), %rax      # 0xdfe0
movq (%rax), %rdi
callq 0x2180
leaq 0x63a6(%rip), %rdi      # 0x92af
xorl %eax, %eax
callq 0x2050
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsi)
movq %r14, 0x10(%rsi)
movq %rbx, %rdi
callq 0x2160
movq 0xb081(%rip), %rbx      # 0xdfc0
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x21d0
movq (%rbx), %rdi
callq 0x2180
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/ipasirminisatglue.cc
// Function: IPAsirMiniSAT::stats()
void stats () {
    double t = getime ();
    printf (
      "c [%s]\n"
      "c [%s]        calls %12llu   %9.1f per second\n"
      "c [%s]     restarts %12llu   %9.1f per second\n"
      "c [%s]    conflicts %12llu   %9.1f per second\n"
      "c [%s]    decisions %12llu   %9.1f per second\n"
      "c [%s] propagations %12llu   %9.1f per second\n"
      "c [%s]\n",
    sig,
    sig, (unsigned long long) calls, ps (calls, t),
    sig, (unsigned long long) starts, ps (starts, t),
    sig, (unsigned long long) conflicts, ps (conflicts, t),
    sig, (unsigned long long) decisions, ps (decisions, t),
    sig, (unsigned long long) propagations, ps (propagations, t),
    sig);
    fflush (stdout);
  }

// Assembly:
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq %rsp, %rsi
xorl %edi, %edi
callq 0x20c0
xorpd %xmm1, %xmm1
xorpd %xmm5, %xmm5
testl %eax, %eax
jne 0x3266
cvtsi2sdq (%rsp), %xmm0
cvtsi2sdq 0x8(%rsp), %xmm2
movsd 0x5dc4(%rip), %xmm3     # 0x9008
mulsd %xmm3, %xmm2
cvtsi2sdq 0x10(%rsp), %xmm4
cvtsi2sdq 0x18(%rsp), %xmm5
addsd %xmm0, %xmm2
mulsd %xmm3, %xmm5
addsd %xmm4, %xmm5
addsd %xmm2, %xmm5
movq 0x3c8(%rbx), %rcx
movq %rcx, %xmm2
movq 0x60b6(%rip), %xmm4     # 0x9330
punpckldq %xmm4, %xmm2    # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
movapd 0x60ba(%rip), %xmm6     # 0x9340
subpd %xmm6, %xmm2
movapd %xmm2, %xmm0
unpckhpd %xmm2, %xmm0            # xmm0 = xmm0[1],xmm2[1]
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm5
divsd %xmm5, %xmm0
jne 0x32a6
jp 0x32a6
xorpd %xmm0, %xmm0
movq 0xe8(%rbx), %r9
movq %r9, %xmm2
punpckldq %xmm4, %xmm2    # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
subpd %xmm6, %xmm2
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1            # xmm1 = xmm1[1],xmm2[1]
addsd %xmm2, %xmm1
divsd %xmm5, %xmm1
jne 0x32d2
jp 0x32d2
xorpd %xmm1, %xmm1
movq 0xf0(%rbx), %r11
movq 0x108(%rbx), %r10
movq %r10, %xmm3
punpckldq %xmm4, %xmm3    # xmm3 = xmm3[0],xmm4[0],xmm3[1],xmm4[1]
subpd %xmm6, %xmm3
movapd %xmm3, %xmm2
unpckhpd %xmm3, %xmm2            # xmm2 = xmm2[1],xmm3[1]
addsd %xmm3, %xmm2
divsd %xmm5, %xmm2
jne 0x3305
jp 0x3305
xorpd %xmm2, %xmm2
movq %r11, %xmm7
punpckldq %xmm4, %xmm7    # xmm7 = xmm7[0],xmm4[0],xmm7[1],xmm4[1]
subpd %xmm6, %xmm7
movapd %xmm7, %xmm3
unpckhpd %xmm7, %xmm3            # xmm3 = xmm3[1],xmm7[1]
addsd %xmm7, %xmm3
divsd %xmm5, %xmm3
jne 0x332a
jp 0x332a
xorpd %xmm3, %xmm3
movq 0x100(%rbx), %rbx
movq %rbx, %xmm7
punpckldq %xmm4, %xmm7    # xmm7 = xmm7[0],xmm4[0],xmm7[1],xmm4[1]
subpd %xmm6, %xmm7
movapd %xmm7, %xmm4
unpckhpd %xmm7, %xmm4            # xmm4 = xmm4[1],xmm7[1]
addsd %xmm7, %xmm4
divsd %xmm5, %xmm4
jne 0x3356
jp 0x3356
xorpd %xmm4, %xmm4
subq $0x8, %rsp
leaq 0x5fef(%rip), %rdx      # 0x9350
leaq 0x5ff3(%rip), %rdi      # 0x935b
movq %rdx, %rsi
movq %rdx, %r8
movb $0x5, %al
pushq %rdx
pushq %rbx
pushq %rdx
pushq %r11
pushq %rdx
pushq %r10
pushq %rdx
callq 0x2050
addq $0x40, %rsp
movq 0xac37(%rip), %rax      # 0xdfc0
movq (%rax), %rdi
callq 0x2180
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/ipasirminisatglue.cc
// Function: IPAsirMiniSAT::solve()
int solve () {
    calls++;
    reset ();
    lbool res = solveLimited (assumptions);
    assumptions.clear ();
    nomodel = (res != l_True);
    return (res == l_Undef) ? 0 : (res == l_True ? 10 : 20);
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
incq 0x3c8(%rdi)
callq 0x3602
leaq 0x390(%rbx), %rsi
movq %rbx, %rdi
callq 0x3628
movb %al, 0xf(%rsp)
cmpq $0x0, 0x390(%rbx)
je 0x33d5
andl $0x0, 0x398(%rbx)
leaq 0xf(%rsp), %r14
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0x3648
movb %al, 0x3c0(%rbx)
movb (%r14), %cl
testb %cl, %cl
pushq $0xa
popq %rdx
pushq $0x14
popq %rax
cmovel %edx, %eax
testb $0x2, %cl
cmovnel %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/ipasirminisatglue.cc
// Function: IPAsirMiniSAT::add(int)
void add (int32_t lit) {
    reset ();
    nomodel = true;
    if (lit) clause.push (import (lit));
    else addClause (clause), clause.clear ();
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x3602
movb $0x1, 0x3c0(%rbx)
leaq 0x3a0(%rbx), %r14
testl %ebp, %ebp
je 0x3449
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3798
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x375e
jmp 0x3465
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37e0
cmpq $0x0, 0x3a0(%rbx)
je 0x3465
andl $0x0, 0x3a8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/ipasirminisatglue.cc
// Function: IPAsirMiniSAT::failed(int)
int failed (int32_t lit) {
    if (!fmap) ana ();
    int tmp = var (import (lit));
    assert (0 <= tmp && tmp < nVars ());
    return fmap[tmp] != 0;
  }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x0, 0x3b8(%rdi)
jne 0x3508
movq %rbx, %rdi
callq 0x380c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3798
sarl %eax
js 0x3537
cmpl 0x2d4(%rbx), %eax
jge 0x3537
movq 0x3b8(%rbx), %rcx
movl %eax, %edx
xorl %eax, %eax
cmpb $0x0, (%rcx,%rdx)
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5f12(%rip), %rdi      # 0x9450
leaq 0x5f26(%rip), %rsi      # 0x946b
leaq 0x5f34(%rip), %rcx      # 0x9480
pushq $0x57
popq %rdx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.h
// Function: Minisat::Solver::setLearnCallback(void*, int, void (*)(void*, int*))
void setLearnCallback(void * state, int maxLength, void (*learn)(void * state, int * clause)) {
      this->learnCallbackState = state;
      this->learnCallbackLimit = maxLength;
      this->learnCallbackBuffer = (int*) realloc (this->learnCallbackBuffer, (1+maxLength)*sizeof(int));
      this->learnCallback = learn;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq %rsi, 0x18(%rdi)
movl %edx, 0x28(%rdi)
movq 0x20(%rdi), %rdi
movslq %edx, %rax
leaq 0x4(,%rax,4), %rsi
callq 0x22a0
movq %rax, 0x20(%r14)
movq %rbx, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/./minisat/mtl/Vec.h
// Function: Minisat::vec<Minisat::vec<Minisat::Solver::Watcher, int>, int>::clear(bool)
void vec<T,_Size>::clear(bool dealloc) {
    if (data != NULL){
        for (Size i = 0; i < sz; i++) data[i].~T();
        sz = 0;
        if (dealloc) free(data), data = NULL, cap = 0; } }

// Assembly:
cmpq $0x0, (%rdi)
je 0x7400
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jge 0x73dd
movq (%rbx), %rdi
addq %r14, %rdi
callq 0x7402
incq %r15
addq $0x10, %r14
jmp 0x73c0
andl $0x0, 0x8(%rbx)
testb %bpl, %bpl
je 0x73f6
movq (%rbx), %rdi
callq 0x21b0
andq $0x0, (%rbx)
andl $0x0, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/./minisat/mtl/Vec.h
// Function: Minisat::vec<Minisat::lbool, int>::growTo(int)
void vec<T,_Size>::growTo(Size size) {
    if (sz >= size) return;
    capacity(size);
    for (Size i = sz; i < size; i++) new (&data[i]) T();
    sz = size; }

// Assembly:
cmpl %esi, 0x8(%rdi)
jge 0x6c68
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x80a0
movslq 0x8(%r14), %rax
movq (%r14), %rcx
movslq %ebx, %rdx
cmpq %rdx, %rax
jge 0x6c5d
movb $0x0, (%rcx,%rax)
incq %rax
jmp 0x6c4f
movl %ebx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/mtl/Vec.h
// Function: Minisat::vec<Minisat::Lit, int>::capacity(int)
void vec<T,_Size>::capacity(Size min_cap) {
    if (cap >= min_cap) return;
    Size add = max((min_cap - cap + 1) & ~1, ((cap >> 1) + 2) & ~1);   // NOTE: grow by approximately 3/2
    const Size size_max = std::numeric_limits<Size>::max();
    if ( ((size_max <= std::numeric_limits<int>::max()) && (add > size_max - cap))
    ||   (((data = (T*)::realloc(data, (cap += add) * sizeof(T))) == NULL) && errno == ENOMEM) )
        throw OutOfMemoryException();
 }

// Assembly:
pushq %rbx
movl 0xc(%rdi), %eax
cmpl %esi, %eax
jge 0x3743
subl %eax, %esi
incl %esi
andl $-0x2, %esi
movl %eax, %ecx
sarl %ecx
andl $-0x2, %ecx
addl $0x2, %ecx
cmpl %ecx, %esi
cmovgl %esi, %ecx
movl %eax, %edx
xorl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
cmpl %edx, %ecx
jg 0x3745
movq %rdi, %rbx
movq (%rdi), %rdi
addl %eax, %ecx
movl %ecx, 0xc(%rbx)
movslq %ecx, %rsi
shlq $0x2, %rsi
callq 0x22a0
movq %rax, (%rbx)
testq %rax, %rax
jne 0x3743
callq 0x2040
cmpl $0xc, (%rax)
je 0x3745
popq %rbx
retq
pushq $0x1
popq %rdi
callq 0x20a0
leaq 0xa4ec(%rip), %rsi      # 0xdc40
movq %rax, %rdi
xorl %edx, %edx
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/ipasirminisatglue.cc
// Function: IPAsirMiniSAT::ana()
void ana () {
    fmap = new unsigned char [szfmap = nVars ()];
    memset (fmap, 0, szfmap);
    for (int i = 0; i < conflict.size (); i++) {
      int tmp = var (conflict[i]);
      assert (0 <= tmp && tmp < szfmap);
      fmap[tmp] = 1;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x2d4(%rdi), %r14
movl %r14d, 0x3b0(%rdi)
movq %r14, %rdi
callq 0x2030
movq %rax, 0x3b8(%rbx)
xorl %r15d, %r15d
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x20b0
movslq 0x68(%rbx), %rax
cmpq %rax, %r15
jge 0x3870
movq 0x60(%rbx), %rax
movl (%rax,%r15,4), %eax
sarl %eax
js 0x3876
cmpl 0x3b0(%rbx), %eax
jge 0x3876
movq 0x3b8(%rbx), %rcx
movl %eax, %eax
movb $0x1, (%rcx,%rax)
incq %r15
jmp 0x3841
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5c26(%rip), %rdi      # 0x94a3
leaq 0x5be7(%rip), %rsi      # 0x946b
leaq 0x5c31(%rip), %rcx      # 0x94bc
pushq $0x30
popq %rdx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::newVar(Minisat::lbool, bool)
Var Solver::newVar(lbool upol, bool dvar)
{
    Var v;
    if (free_vars.size() > 0){
        v = free_vars.last();
        free_vars.pop();
    }else
        v = next_var++;

    watches  .init(mkLit(v, false));
    watches  .init(mkLit(v, true ));
    assigns  .insert(v, l_Undef);
    vardata  .insert(v, mkVarData(CRef_Undef, 0));
    activity .insert(v, rnd_init_act ? drand(random_seed) * 0.00001 : 0);
    seen     .insert(v, 0);
    polarity .insert(v, true);
    user_pol .insert(v, upol);
    decision .reserve(v);
    trail    .capacity(v+1);
    setDecisionVar(v, dvar);
    return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movslq 0x310(%rdi), %rax
testq %rax, %rax
jle 0x3d58
movq 0x308(%r14), %rcx
movl -0x4(%rcx,%rax,4), %r15d
decl %eax
movl %eax, 0x310(%r14)
jmp 0x3d6a
movl 0x2d4(%r14), %r15d
leal 0x1(%r15), %eax
movl %eax, 0x2d4(%r14)
leaq 0x228(%r14), %r12
leal (%r15,%r15), %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
movq %r12, %rdi
callq 0x64dc
leal 0x1(,%r15,2), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movq %r12, %rdi
callq 0x64dc
leaq 0x1b0(%r14), %rdi
movzbl 0xa439(%rip), %edx      # 0xe1e2
movl %r15d, %esi
callq 0x6520
leaq 0x210(%r14), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %r15d, %esi
callq 0x653e
xorpd %xmm0, %xmm0
cmpb $0x1, 0xa5(%r14)
jne 0x3de7
leaq 0x90(%r14), %rdi
callq 0x658a
mulsd 0x5759(%rip), %xmm0     # 0x9540
leaq 0x198(%r14), %rdi
movl %r15d, %esi
callq 0x655e
leaq 0x318(%r14), %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x65c0
leaq 0x1c8(%r14), %rdi
pushq $0x1
popq %rdx
movl %r15d, %esi
callq 0x65c0
leaq 0x1e0(%r14), %rdi
movzbl %bpl, %edx
movl %r15d, %esi
callq 0x6520
leaq 0x1f8(%r14), %rdi
movl %r15d, %esi
callq 0x65de
leaq 0x168(%r14), %rdi
leal 0x1(%r15), %esi
callq 0x36f0
movzbl %bl, %edx
movq %r14, %rdi
movl %r15d, %esi
callq 0x65e6
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::addClause_(Minisat::vec<Minisat::Lit, int>&)
bool Solver::addClause_(vec<Lit>& ps)
{
    assert(decisionLevel() == 0);
    if (!ok) return false;

    // Check if clause is satisfied and remove false/duplicate literals:
    sort(ps);
    Lit p; int i, j;
    for (i = j = 0, p = lit_Undef; i < ps.size(); i++)
        if (value(ps[i]) == l_True || ps[i] == ~p)
            return true;
        else if (value(ps[i]) != l_False && ps[i] != p)
            ps[j++] = p = ps[i];
    ps.shrink(i - j);

    if (ps.size() == 0)
        return ok = false;
    else if (ps.size() == 1){
        uncheckedEnqueue(ps[0]);
        return ok = (propagate() == CRef_Undef);
    }else{
        CRef cr = ca.alloc(ps, false);
        clauses.push(cr);
        attachClause(cr);
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r15d, %r15d
cmpb $0x1, 0x2a0(%rdi)
jne 0x402d
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7ba3
pushq $-0x2
popq %rbp
leaq 0x3(%rsp), %r13
xorl %r12d, %r12d
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jge 0x3fa8
movq (%r14), %rax
movl (%rax,%r12,4), %eax
movl %eax, %ecx
sarl %ecx
movq 0x1b0(%rbx), %rdx
movslq %ecx, %rcx
andb $0x1, %al
xorb (%rdx,%rcx), %al
movb %al, 0x3(%rsp)
movzbl 0xa2aa(%rip), %esi      # 0xe1e0
movq %r13, %rdi
callq 0x3652
testb %al, %al
jne 0x402a
movq (%r14), %rax
movl (%rax,%r12,4), %eax
movl %eax, %ecx
xorl %ebp, %ecx
cmpl $0x1, %ecx
je 0x402a
movl %eax, %ecx
sarl %ecx
movq 0x1b0(%rbx), %rdx
movslq %ecx, %rcx
andb $0x1, %al
xorb (%rdx,%rcx), %al
movb %al, 0x2(%rsp)
movzbl 0xa269(%rip), %esi      # 0xe1e1
leaq 0x2(%rsp), %rdi
callq 0x3648
testb %al, %al
je 0x3f91
movq (%r14), %rcx
movl (%rcx,%r12,4), %eax
cmpl %ebp, %eax
jne 0x3f95
movl %ebp, %eax
jmp 0x3f9e
movslq %r15d, %rdx
incl %r15d
movl %eax, (%rcx,%rdx,4)
incq %r12
movl %eax, %ebp
jmp 0x3f04
subl %r15d, %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x6694
movl 0x8(%r14), %eax
cmpl $0x1, %eax
je 0x3fcf
testl %eax, %eax
jne 0x3ff7
movb $0x0, 0x2a0(%rbx)
xorl %r15d, %r15d
jmp 0x402d
movq (%r14), %rax
movl (%rax), %esi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x4040
movq %rbx, %rdi
callq 0x408c
cmpl $-0x1, %eax
sete %r15b
sete 0x2a0(%rbx)
jmp 0x402d
leaq 0x2d8(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x66ac
leaq 0x4(%rsp), %r14
movl %eax, (%r14)
leaq 0x148(%rbx), %rdi
movq %r14, %rsi
callq 0x66f6
movl (%r14), %esi
movq %rbx, %rdi
callq 0x435e
movb $0x1, %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::attachClause(unsigned int)
void Solver::attachClause(CRef cr){
    const Clause& c = ca[cr];
    assert(c.size() > 1);
    watches[~c[0]].push(Watcher(cr, c[1]));
    watches[~c[1]].push(Watcher(cr, c[0]));
    if (c.learnt()) num_learnts++, learnts_literals += c.size();
    else            num_clauses++, clauses_literals += c.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x2d8(%rdi), %r15
movl %esi, %r12d
movslq 0x4(%r15,%r12,4), %rdi
xorq $0x1, %rdi
shlq $0x4, %rdi
addq 0x228(%rbx), %rdi
movl 0x8(%r15,%r12,4), %eax
leaq 0x8(%rsp), %r14
movl %esi, (%r14)
movl %eax, 0x4(%r14)
movq %r14, %rsi
callq 0x6730
movslq 0x8(%r15,%r12,4), %rdi
xorq $0x1, %rdi
shlq $0x4, %rdi
addq 0x228(%rbx), %rdi
movl 0x4(%r15,%r12,4), %eax
movl %ebp, (%r14)
movl %eax, 0x4(%r14)
leaq 0x8(%rsp), %rsi
callq 0x6730
movl (%r15,%r12,4), %eax
andl $0x4, %eax
incq 0x118(%rbx,%rax,2)
movl (%r15,%r12,4), %ecx
shrl $0x5, %ecx
addq %rcx, 0x128(%rbx,%rax,2)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::detachClause(unsigned int, bool)
void Solver::detachClause(CRef cr, bool strict){
    const Clause& c = ca[cr];
    assert(c.size() > 1);
    
    // Strict or lazy detaching:
    if (strict){
        remove(watches[~c[0]], Watcher(cr, c[1]));
        remove(watches[~c[1]], Watcher(cr, c[0]));
    }else{
        watches.smudge(~c[0]);
        watches.smudge(~c[1]);
    }

    if (c.learnt()) num_learnts--, learnts_literals -= c.size();
    else            num_clauses--, clauses_literals -= c.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2d8(%rdi), %r12
movl %esi, %r13d
leaq 0x228(%rdi), %r14
testl %edx, %edx
je 0x446e
movl %esi, %ebp
movslq 0x4(%r12,%r13,4), %rdi
xorq $0x1, %rdi
shlq $0x4, %rdi
addq (%r14), %rdi
movl 0x8(%r12,%r13,4), %eax
movq %rsp, %r15
movl %esi, (%r15)
movl %eax, 0x4(%r15)
movq %r15, %rsi
callq 0x44ca
movslq 0x8(%r12,%r13,4), %rdi
xorq $0x1, %rdi
shlq $0x4, %rdi
addq (%r14), %rdi
movl 0x4(%r12,%r13,4), %eax
movl %ebp, (%r15)
movl %eax, 0x4(%r15)
movq %rsp, %rsi
callq 0x44ca
jmp 0x449d
movl 0x4(%r12,%r13,4), %eax
xorl $0x1, %eax
movq %rsp, %r15
movl %eax, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x676c
movl 0x8(%r12,%r13,4), %eax
xorl $0x1, %eax
movl %eax, (%r15)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x676c
movl (%r12,%r13,4), %eax
andl $0x4, %eax
decq 0x118(%rbx,%rax,2)
movl (%r12,%r13,4), %ecx
shrl $0x5, %ecx
subq %rcx, 0x128(%rbx,%rax,2)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/./minisat/mtl/Alg.h
// Function: void Minisat::remove<Minisat::vec<Minisat::Solver::Watcher, int>, Minisat::Solver::Watcher>(Minisat::vec<Minisat::Solver::Watcher, int>&, Minisat::Solver::Watcher const&)
static inline void remove(V& ts, const T& t)
{
    int j = 0;
    for (; j < (int)ts.size() && ts[j] != t; j++);
    assert(j < (int)ts.size());
    for (; j < (int)ts.size()-1; j++) ts[j] = ts[j+1];
    ts.pop();
}

// Assembly:
movl 0x8(%rdi), %eax
movq (%rdi), %rdx
movl (%rsi), %r8d
xorl %esi, %esi
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
cmpq %rsi, %rcx
je 0x4506
cmpl %r8d, (%rdx,%rsi,8)
je 0x44ef
incq %rsi
jmp 0x44df
movq %rsi, %rcx
jmp 0x4506
movq (%rdi), %rax
movq 0x8(%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
incq %rcx
movl 0x8(%rdi), %eax
decl %eax
movslq %eax, %rdx
cmpq %rdx, %rcx
jl 0x44f4
movl %eax, 0x8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::removeClause(unsigned int)
void Solver::removeClause(CRef cr) {
    Clause& c = ca[cr];
    detachClause(cr);
    // Don't leave pointers to free'd memory!
    if (locked(c)) vardata[var(c[0])].reason = CRef_Undef;
    c.mark(1); 
    ca.free(cr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r12
leaq 0x2d8(%rdi), %r14
movl %esi, %r15d
shlq $0x2, %r15
addq 0x2d8(%rdi), %r15
xorl %edx, %edx
callq 0x43fc
movq %r12, %rdi
movq %r15, %rsi
callq 0x6788
testb %al, %al
je 0x4560
movl 0x4(%r15), %eax
sarl %eax
movq 0x210(%r12), %rcx
cltq
orl $-0x1, (%rcx,%rax,8)
movl (%r15), %eax
andl $-0x4, %eax
incl %eax
movl %eax, (%r15)
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x67f8
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::satisfied(Minisat::Clause const&) const
bool Solver::satisfied(const Clause& c) const {
    for (int i = 0; i < c.size(); i++)
        if (value(c[i]) == l_True)
            return true;
    return false; }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %ecx, %ecx
leaq 0xf(%rsp), %r15
movq %rcx, %r12
movl (%rbx), %r13d
shrl $0x5, %r13d
cmpq %r13, %rcx
jae 0x45dd
movl 0x4(%rbx,%r12,4), %eax
movl %eax, %ecx
sarl %ecx
movq 0x1b0(%r14), %rdx
movslq %ecx, %rcx
andb $0x1, %al
xorb (%rdx,%rcx), %al
movb %al, 0xf(%rsp)
movzbl 0x9c14(%rip), %esi      # 0xe1e0
movq %r15, %rdi
callq 0x3652
leaq 0x1(%r12), %rcx
testb %al, %al
je 0x459a
cmpq %r13, %r12
setb %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::cancelUntil(int)
void Solver::cancelUntil(int level) {
    if (decisionLevel() > level){
        for (int c = trail.size()-1; c >= trail_lim[level]; c--){
            Var      x  = var(trail[c]);
            assigns [x] = l_Undef;
            if (phase_saving > 1 || (phase_saving == 1 && c > trail_lim.last()))
                polarity[x] = sign(trail[c]);
            insertVarOrder(x); }
        qhead = trail_lim[level];
        trail.shrink(trail.size() - trail_lim[level]);
        trail_lim.shrink(trail_lim.size() - level);
    } }

// Assembly:
cmpl %esi, 0x180(%rdi)
jle 0x46ce
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x168(%rdi), %r15
movslq 0x170(%rdi), %r13
leaq 0x178(%rdi), %r14
movslq %esi, %r12
decq %r13
leaq 0x1(%r13), %rdx
movq (%r14), %rax
movslq (%rax,%r12,4), %rcx
cmpq %rcx, %rdx
jle 0x469c
movq 0x168(%rbx), %rax
movq 0x1b0(%rbx), %rcx
movl (%rax,%r13,4), %esi
sarl %esi
movslq %esi, %rax
movb 0x9b90(%rip), %dl       # 0xe1e2
movb %dl, (%rcx,%rax)
cmpl $0x1, 0xa0(%rbx)
jle 0x4678
movq 0x168(%rbx), %rcx
movq 0x1c8(%rbx), %rdx
movb (%rcx,%r13,4), %cl
andb $0x1, %cl
movb %cl, (%rdx,%rax)
jmp 0x4692
jne 0x4692
movq 0x178(%rbx), %rcx
movslq 0x180(%rbx), %rdx
movslq -0x4(%rcx,%rdx,4), %rcx
cmpq %rcx, %r13
jg 0x465e
movq %rbx, %rdi
callq 0x6810
jmp 0x4622
movl %ecx, 0x2b8(%rbx)
movl 0x170(%rbx), %esi
subl (%rax,%r12,4), %esi
movq %r15, %rdi
callq 0x6694
movl 0x180(%rbx), %esi
subl %r12d, %esi
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6848
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::pickBranchLit()
Lit Solver::pickBranchLit()
{
    Var next = var_Undef;

    // Random decision:
    if (drand(random_seed) < random_var_freq && !order_heap.empty()){
        next = order_heap[irand(random_seed,order_heap.size())];
        if (value(next) == l_Undef && decision[next])
            rnd_decisions++; }

    // Activity based decision:
    while (next == var_Undef || value(next) != l_Undef || !decision[next])
        if (order_heap.empty()){
            next = var_Undef;
            break;
        }else
            next = order_heap.removeMin();

    // Choose polarity based on different polarity modes (global or per-variable):
    if (next == var_Undef)
        return lit_Undef;
    else if (user_pol[next] != l_Undef)
        return mkLit(next, user_pol[next] == l_True);
    else if (rnd_pol)
        return mkLit(next, drand(random_seed) < 0.5);
    else
        return mkLit(next, polarity[next]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x90(%rdi), %r12
movq %r12, %rdi
callq 0x658a
movsd 0x88(%r14), %xmm1
pushq $-0x1
popq %rbx
ucomisd %xmm0, %xmm1
jbe 0x475b
movl 0x278(%r14), %esi
testl %esi, %esi
je 0x475b
movq %r12, %rdi
callq 0x6860
movq 0x270(%r14), %rcx
cltq
movl (%rcx,%rax,4), %ebx
movq 0x1b0(%r14), %rax
movslq %ebx, %r15
movb (%rax,%r15), %al
leaq 0xf(%rsp), %rdi
movb %al, (%rdi)
movzbl 0x9aa5(%rip), %esi      # 0xe1e2
callq 0x3652
testb %al, %al
je 0x475b
movq 0x1f8(%r14), %rax
cmpb $0x0, (%rax,%r15)
je 0x475b
incq 0xf8(%r14)
movq %r12, 0x10(%rsp)
leaq 0x270(%r14), %r13
pushq $-0x2
popq %rbp
leaq 0xe(%rsp), %r15
cmpl $-0x1, %ebx
je 0x47a7
movq 0x1b0(%r14), %rax
movslq %ebx, %r12
movb (%rax,%r12), %al
movb %al, 0xe(%rsp)
movzbl 0x9a55(%rip), %esi      # 0xe1e2
movq %r15, %rdi
callq 0x3648
testb %al, %al
jne 0x47a7
movq 0x1f8(%r14), %rax
cmpb $0x0, (%rax,%r12)
jne 0x47bd
cmpl $0x0, 0x278(%r14)
je 0x4830
movq %r13, %rdi
callq 0x6876
movl %eax, %ebx
jmp 0x476f
movq 0x1e0(%r14), %rdi
addq %r12, %rdi
movzbl 0x9a14(%rip), %esi      # 0xe1e2
callq 0x3648
testb %al, %al
je 0x47f2
addq 0x1e0(%r14), %r12
movzbl 0x99fb(%rip), %esi      # 0xe1e0
movq %r12, %rdi
callq 0x3652
movzbl %al, %eax
jmp 0x4817
cmpb $0x1, 0xa4(%r14)
jne 0x481c
movq 0x10(%rsp), %rdi
callq 0x658a
movsd 0x4d4a(%rip), %xmm1     # 0x9558
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
leal (%rax,%rbx,2), %ebp
jmp 0x4830
movq 0x1c8(%r14), %rax
xorl %ecx, %ecx
cmpb $0x0, (%rax,%r12)
setne %cl
leal (%rcx,%rbx,2), %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::analyzeFinal(Minisat::Lit, Minisat::LSet&)
void Solver::analyzeFinal(Lit p, LSet& out_conflict)
{
    out_conflict.clear();
    out_conflict.insert(p);

    if (decisionLevel() == 0)
        return;

    seen[var(p)] = 1;

    for (int i = trail.size()-1; i >= trail_lim[0]; i--){
        Var x = var(trail[i]);
        if (seen[x]){
            if (reason(x) == CRef_Undef){
                assert(level(x) > 0);
                out_conflict.insert(~trail[i]);
            }else{
                Clause& c = ca[reason(x)];
                for (int j = 1; j < c.size(); j++)
                    if (level(var(c[j])) > 0)
                        seen[var(c[j])] = 1;
            }
            seen[x] = 0;
        }
    }

    seen[var(p)] = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rdi
xorl %esi, %esi
callq 0x69d6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6a24
cmpl $0x0, 0x180(%r14)
je 0x4e35
sarl %ebp
movq 0x318(%r14), %rax
movslq %ebp, %rcx
movq %rcx, (%rsp)
movb $0x1, (%rax,%rcx)
movslq 0x170(%r14), %r12
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
pushq $0x1
popq %rbp
movq 0x178(%r14), %rax
movslq (%rax), %rax
cmpq %rax, %r12
jle 0x4e26
movq 0x168(%r14), %rax
movq 0x318(%r14), %rcx
movl -0x4(%rax,%r12,4), %esi
decq %r12
movl %esi, %eax
sarl %eax
movslq %eax, %r15
cmpb $0x0, (%rcx,%r15)
je 0x4d7d
movq 0x210(%r14), %rax
movl (%rax,%r15,8), %eax
cmpq %r13, %rax
je 0x4e0a
movq 0x2d8(%r14), %rcx
leaq (%rcx,%rax,4), %rdx
addq $0x8, %rdx
movq %rbp, %rsi
movl (%rcx,%rax,4), %edi
shrl $0x5, %edi
cmpq %rdi, %rsi
jae 0x4e15
movl -0x4(%rdx,%rsi,4), %edi
sarl %edi
movq 0x210(%r14), %r8
movslq %edi, %rdi
cmpl $0x0, 0x4(%r8,%rdi,8)
jle 0x4e05
movq 0x318(%r14), %r8
movb $0x1, (%r8,%rdi)
incq %rsi
jmp 0x4dd6
xorl $0x1, %esi
movq %rbx, %rdi
callq 0x6a24
movq 0x318(%r14), %rax
movb $0x0, (%rax,%r15)
jmp 0x4d7d
movq 0x318(%r14), %rax
movq (%rsp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::reduceDB()
void Solver::reduceDB()
{
    int     i, j;
    double  extra_lim = cla_inc / learnts.size();    // Remove any clause below this activity

    sort(learnts, reduceDB_lt(ca));
    // Don't delete binary or locked clauses. From the rest, delete clauses from the first half
    // and clauses with activity smaller than 'extra_lim':
    for (i = j = 0; i < learnts.size(); i++){
        Clause& c = ca[learnts[i]];
        if (c.size() > 2 && !locked(c) && (i < learnts.size() / 2 || c.activity() < extra_lim))
            removeClause(learnts[i]);
        else
            learnts[j++] = learnts[i];
    }
    learnts.shrink(i - j);
    checkGarbage();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x2a8(%rdi), %xmm1
leaq 0x158(%rdi), %r14
cvtsi2sdl 0x160(%rdi), %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
leaq 0x2d8(%rdi), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x6aa9
xorl %r15d, %r15d
xorl %ebp, %ebp
movslq 0x160(%rbx), %rax
cmpq %rax, %r15
jge 0x4f0e
movq (%r14), %rax
movl (%rax,%r15,4), %eax
movq (%r12), %rcx
cmpl $0x60, (%rcx,%rax,4)
jb 0x4eb9
leaq (%rcx,%rax,4), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6788
testb %al, %al
je 0x4ecd
movq (%r14), %rax
movl (%rax,%r15,4), %ecx
movslq %ebp, %rdx
incl %ebp
movl %ecx, (%rax,%rdx,4)
incq %r15
jmp 0x4e89
movl 0x160(%rbx), %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
cltq
cmpq %rax, %r15
jl 0x4ef9
movl (%r13), %eax
shrl $0x5, %eax
cvtss2sd 0x4(%r13,%rax,4), %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x4eb9
movq 0x158(%rbx), %rax
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x4514
jmp 0x4ec8
subl %ebp, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x6aba
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6ad2
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::removeSatisfied(Minisat::vec<unsigned int, int>&)
void Solver::removeSatisfied(vec<CRef>& cs)
{
    int i, j;
    for (i = j = 0; i < cs.size(); i++){
        Clause& c = ca[cs[i]];
        if (satisfied(c))
            removeClause(cs[i]);
        else{
            // Trim clause:
            assert(value(c[0]) == l_Undef && value(c[1]) == l_Undef);
            for (int k = 2; k < c.size(); k++)
                if (value(c[k]) == l_False){
                    c[k--] = c[c.size()-1];
                    c.pop();
                }
            cs[j++] = cs[i];
        }
    }
    cs.shrink(i - j);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
leaq 0xb(%rsp), %r12
xorl %ebp, %ebp
movq %rsi, 0x10(%rsp)
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jge 0x5017
movq (%rbx), %rax
movl (%rax,%r14,4), %r13d
shlq $0x2, %r13
addq 0x2d8(%r15), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x4580
testb %al, %al
je 0x4f94
movq (%rbx), %rax
movl (%rax,%r14,4), %esi
movq %r15, %rdi
callq 0x4514
jmp 0x500f
movl %ebp, 0xc(%rsp)
pushq $0x2
popq %rbp
movl (%r13), %eax
shrl $0x5, %eax
cmpl %eax, %ebp
jge 0x4ff7
movslq %ebp, %rbx
movl 0x4(%r13,%rbx,4), %eax
movl %eax, %ecx
sarl %ecx
movq 0x1b0(%r15), %rdx
movslq %ecx, %rcx
andb $0x1, %al
xorb (%rdx,%rcx), %al
movb %al, 0xb(%rsp)
movzbl 0x9215(%rip), %esi      # 0xe1e1
movq %r12, %rdi
callq 0x3652
testb %al, %al
je 0x4ff3
movl (%r13), %eax
shrl $0x5, %eax
decl %ebp
movl (%r13,%rax,4), %eax
movl %eax, 0x4(%r13,%rbx,4)
movq %r13, %rdi
callq 0x6ae0
incl %ebp
jmp 0x4f9b
movq 0x10(%rsp), %rbx
movq (%rbx), %rax
movl (%rax,%r14,4), %ecx
movl 0xc(%rsp), %ebp
movslq %ebp, %rdx
incl %ebp
movl %ecx, (%rax,%rdx,4)
incq %r14
jmp 0x4f55
subl %ebp, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x6aba
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::rebuildOrderHeap()
void Solver::rebuildOrderHeap()
{
    vec<Var> vs;
    for (Var v = 0; v < nVars(); v++)
        if (decision[v] && value(v) == l_Undef)
            vs.push(v);
    order_heap.build(vs);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
xorl %eax, %eax
leaq 0xb(%rsp), %r15
leaq 0xc(%rsp), %r12
movl %eax, 0xc(%rsp)
cmpl 0x2d4(%rbx), %eax
jge 0x50a9
movq 0x1f8(%rbx), %rcx
cltq
cmpb $0x0, (%rcx,%rax)
je 0x50a1
movq 0x1b0(%rbx), %rcx
movb (%rcx,%rax), %al
movb %al, 0xb(%rsp)
movzbl 0x9158(%rip), %esi      # 0xe1e2
movq %r15, %rdi
callq 0x3652
testb %al, %al
je 0x50a1
movq %r14, %rdi
movq %r12, %rsi
callq 0x665a
movl 0xc(%rsp), %eax
incl %eax
jmp 0x505a
addq $0x270, %rbx            # imm = 0x270
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x6ae8
leaq 0x10(%rsp), %rdi
callq 0x6478
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x50d5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6478
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::progressEstimate() const
double Solver::progressEstimate() const
{
    double  progress = 0;
    double  F = 1.0 / nVars();

    for (int i = 0; i <= decisionLevel(); i++){
        int beg = i == 0 ? 0 : trail_lim[i - 1];
        int end = i == decisionLevel() ? trail.size() : trail_lim[i];
        progress += pow(F, i) * (end - beg);
    }

    return progress / nVars();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cvtsi2sdl 0x2d4(%rdi), %xmm0
movsd 0x3e3d(%rip), %xmm1     # 0x9578
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
leaq 0x170(%rdi), %r14
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x180(%rbx), %rcx
cmpq %rcx, %r12
jg 0x57b6
movq 0x178(%rbx), %rax
testq %r15, %r15
movsd %xmm0, 0x8(%rsp)
je 0x577a
movl -0x4(%rax,%r15), %edx
jmp 0x577c
xorl %edx, %edx
movl %ecx, %ecx
addq %r15, %rax
cmpq %rcx, %r12
cmoveq %r14, %rax
movl (%rax), %ebp
subl %edx, %ebp
cvtsi2sd %r12d, %xmm1
movsd (%rsp), %xmm0
callq 0x22c0
cvtsi2sd %ebp, %xmm1
mulsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
incq %r12
addq $0x4, %r15
jmp 0x5755
cvtsi2sdl 0x2d4(%rbx), %xmm1
divsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::implies(Minisat::vec<Minisat::Lit, int> const&, Minisat::vec<Minisat::Lit, int>&)
bool Solver::implies(const vec<Lit>& assumps, vec<Lit>& out)
{
    trail_lim.push(trail.size());
    for (int i = 0; i < assumps.size(); i++){
        Lit a = assumps[i];

        if (value(a) == l_False){
            cancelUntil(0);
            return false;
        }else if (value(a) == l_Undef)
            uncheckedEnqueue(a);
    }

    unsigned trail_before = trail.size();
    bool     ret          = true;
    if (propagate() == CRef_Undef){
        out.clear();
        for (int j = trail_before; j < trail.size(); j++)
            out.push(trail[j]);
    }else
        ret = false;
    
    cancelUntil(0);
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
addq $0x178, %rdi            # imm = 0x178
movl 0x170(%rbx), %eax
leaq 0x14(%rsp), %rsi
movl %eax, (%rsi)
callq 0x665a
xorl %ebp, %ebp
movslq 0x8(%r15), %rax
cmpq %rax, %rbp
jge 0x5a81
movq (%r15), %rax
movl (%rax,%rbp,4), %r14d
movl %r14d, %eax
sarl %eax
movq 0x1b0(%rbx), %rcx
movslq %eax, %r13
movl %r14d, %r12d
andb $0x1, %r12b
movb (%rcx,%r13), %al
xorb %r12b, %al
movb %al, 0x7(%rsp)
movzbl 0x87ad(%rip), %esi      # 0xe1e1
leaq 0x7(%rsp), %rdi
callq 0x3652
testb %al, %al
jne 0x5ad9
movq 0x1b0(%rbx), %rax
xorb (%rax,%r13), %r12b
movb %r12b, 0x6(%rsp)
movzbl 0x8785(%rip), %esi      # 0xe1e2
leaq 0x6(%rsp), %rdi
callq 0x3652
testb %al, %al
je 0x5a79
movq %rbx, %rdi
movl %r14d, %esi
pushq $-0x1
popq %rdx
callq 0x4040
incq %rbp
jmp 0x59fc
movslq 0x170(%rbx), %r14
movq %rbx, %rdi
callq 0x408c
cmpl $-0x1, %eax
sete %bpl
jne 0x5adb
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x5aa8
andl $0x0, 0x8(%rax)
leaq (,%r14,4), %r15
movslq 0x170(%rbx), %rax
cmpq %rax, %r14
jge 0x5adb
movq 0x168(%rbx), %rsi
addq %r15, %rsi
movq 0x8(%rsp), %rdi
callq 0x375e
incq %r14
addq $0x4, %r15
jmp 0x5ab0
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x45f2
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::toDimacs(_IO_FILE*, Minisat::Clause&, Minisat::vec<int, int>&, int&)
void Solver::toDimacs(FILE* f, Clause& c, vec<Var>& map, Var& max)
{
    if (satisfied(c)) return;

    for (int i = 0; i < c.size(); i++)
        if (value(c[i]) != l_False)
            fprintf(f, "%s%d ", sign(c[i]) ? "-" : "", mapVar(var(c[i]), map, max)+1);
    fprintf(f, "0\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
movq %rdx, %rsi
callq 0x4580
testb %al, %al
jne 0x5bca
leaq 0x7(%rsp), %rbp
xorl %r15d, %r15d
movl (%r12), %eax
shrl $0x5, %eax
cmpq %rax, %r15
jae 0x5bb5
movl 0x4(%r12,%r15,4), %eax
movl %eax, %ecx
sarl %ecx
movq 0x1b0(%r13), %rdx
movslq %ecx, %rcx
andb $0x1, %al
xorb (%rdx,%rcx), %al
movb %al, 0x7(%rsp)
movzbl 0x8683(%rip), %esi      # 0xe1e1
movq %rbp, %rdi
callq 0x3648
testb %al, %al
je 0x5bad
movl 0x4(%r12,%r15,4), %edi
testb $0x1, %dil
leaq 0x3fe2(%rip), %r14      # 0x9b5c
leaq 0x3db2(%rip), %rax      # 0x9933
cmoveq %rax, %r14
sarl %edi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x5bd9
leal 0x1(%rax), %ecx
movq %rbx, %rdi
leaq 0x3ccc(%rip), %rsi      # 0x986f
movq %r14, %rdx
xorl %eax, %eax
callq 0x2250
incq %r15
jmp 0x5b2f
leaq 0x3ce5(%rip), %rdi      # 0x98a1
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x2320
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: mapVar(int, Minisat::vec<int, int>&, int&)
static Var mapVar(Var x, vec<Var>& map, Var& max)
{
    if (map.size() <= x || map[x] == -1){
        map.growTo(x+1, -1);
        map[x] = max++;
    }
    return map[x];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %esi
cmpl %edi, 0x8(%rbx)
jle 0x5c00
movq (%rbx), %rax
movslq %esi, %r15
movl (%rax,%r15,4), %eax
cmpl $-0x1, %eax
jne 0x5c25
jmp 0x5c03
movslq %esi, %r15
incl %esi
leaq 0xc(%rsp), %rdx
orl $-0x1, (%rdx)
movq %rbx, %rdi
callq 0x75fa
movl (%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
movq (%rbx), %rcx
movl %eax, (%rcx,%r15,4)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::toDimacs(char const*, Minisat::vec<Minisat::Lit, int> const&)
void Solver::toDimacs(const char *file, const vec<Lit>& assumps)
{
    FILE* f = fopen(file, "wr");
    if (f == NULL)
        fprintf(stderr, "could not open file %s\n", file), exit(1);
    toDimacs(f, assumps);
    fclose(f);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x3c2d(%rip), %rsi      # 0x9875
movq %rbx, %rdi
callq 0x2190
testq %rax, %rax
je 0x5c79
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x5c9c
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2130
movq 0x8360(%rip), %rax      # 0xdfe0
movq (%rax), %rdi
leaq 0x3bee(%rip), %rsi      # 0x9878
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2250
pushq $0x1
popq %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/minisat/core/Solver.cc
// Function: Minisat::Solver::garbageCollect()
void Solver::garbageCollect()
{
    // Initialize the next region to a size corresponding to the estimated utilization degree. This
    // is not precise but should avoid some unnecessary reallocations for the new region:
    ClauseAllocator to(ca.size() - ca.wasted()); 

    relocAll(to);
    if (verbosity >= 2)
        printf("c [minisat220] |  Garbage collection:   %12d bytes => %12d bytes             |\n", 
               ca.size()*ClauseAllocator::Unit_Size, to.size()*ClauseAllocator::Unit_Size);
    to.moveTo(ca);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl 0x2e0(%rdi), %esi
subl 0x2e8(%rdi), %esi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x6cf2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x612c
leaq 0x2d8(%r14), %rbx
cmpl $0x2, 0x70(%r14)
jl 0x6387
movl 0x2e0(%r14), %esi
movl 0x10(%rsp), %edx
shll $0x2, %esi
shll $0x2, %edx
leaq 0x3696(%rip), %rdi      # 0x9a16
xorl %eax, %eax
callq 0x2050
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x6d02
movq 0x8(%rsp), %rdi
callq 0x21b0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x21b0
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/./minisat/utils/ParseUtils.h
// Function: bool Minisat::match<char const*>(char const*&, char const*)
static bool match(B& in, const char* str) {
    int i;
    for (i = 0; str[i] != '\0'; i++)
        if (in[i] != str[i])
            return false;

    in += i;

    return true; 
}

// Assembly:
movq (%rdi), %rax
movb (%rsi), %cl
testb %cl, %cl
je 0x63d4
leaq 0x1(%rax), %rdx
incq %rsi
cmpb %cl, (%rax)
movq %rdx, %rax
je 0x63be
jmp 0x63d7
movq %rax, (%rdi)
testb %cl, %cl
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/./minisat/core/Solver.h
// Function: Minisat::Solver::drand(double&)
static inline double drand(double& seed) {
        seed *= 1389796;
        int q = (int)(seed / 2147483647);
        seed -= (double)q * 2147483647;
        return seed / 2147483647; }

// Assembly:
movsd (%rdi), %xmm0
mulsd 0x2fb2(%rip), %xmm0     # 0x9548
movsd 0x2fb2(%rip), %xmm1     # 0x9550
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, (%rdi)
divsd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/./minisat/core/SolverTypes.h
// Function: Minisat::ClauseAllocator::alloc(Minisat::vec<Minisat::Lit, int> const&, bool)
CRef alloc(const vec<Lit>& ps, bool learnt = false)
    {
        assert(sizeof(Lit)      == sizeof(uint32_t));
        assert(sizeof(float)    == sizeof(uint32_t));
        bool use_extra = learnt | extra_clause_field;
        CRef cid       = ra.alloc(clauseWord32Size(ps.size(), use_extra));
        new (lea(cid)) Clause(ps, use_extra, learnt);

        return cid;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movb 0x18(%rdi), %al
orb %bl, %al
movzbl %al, %r12d
movl 0x8(%rsi), %eax
leal (%rax,%r12), %esi
incl %esi
callq 0x7486
movl %eax, %ebp
movl %eax, %edi
shlq $0x2, %rdi
addq (%r15), %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebx, %ecx
callq 0x74c6
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/./minisat/mtl/Heap.h
// Function: Minisat::Heap<int, Minisat::Solver::VarOrderLt, Minisat::MkIndexDefault<int>>::removeMin()
void update(K k)
    {
        if (!inHeap(k))
            insert(k);
        else {
            percolateUp(indices[k]);
            percolateDown(indices[k]); }
    }

// Assembly:
pushq %rbx
movq (%rdi), %rax
movslq (%rax), %rbx
movslq 0x8(%rdi), %rcx
movslq -0x4(%rax,%rcx,4), %rcx
movl %ecx, (%rax)
movq 0x10(%rdi), %rax
andl $0x0, (%rax,%rcx,4)
orl $-0x1, (%rax,%rbx,4)
movl 0x8(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x8(%rdi)
cmpl $0x3, %eax
jl 0x68a9
xorl %esi, %esi
callq 0x7d62
movl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/./minisat/core/Solver.h
// Function: Minisat::Solver::claBumpActivity(Minisat::Clause&)
inline void Solver::claBumpActivity (Clause& c) {
        if ( (c.activity() += cla_inc) > 1e20 ) {
            // Rescale:
            for (int i = 0; i < learnts.size(); i++)
                ca[learnts[i]].activity() *= 1e-20;
            cla_inc *= 1e-20; } }

// Assembly:
movsd 0x2a8(%rdi), %xmm0
movl (%rsi), %eax
shrl $0x5, %eax
cvtss2sd 0x4(%rsi,%rax,4), %xmm1
addsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, 0x4(%rsi,%rax,4)
cvtss2sd %xmm1, %xmm1
ucomisd 0x2c5d(%rip), %xmm1     # 0x9560
jbe 0x6967
movl 0x160(%rdi), %eax
movq 0x158(%rdi), %rcx
movq 0x2d8(%rdi), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
movsd 0x2c40(%rip), %xmm1     # 0x9568
cmpq %rsi, %rax
je 0x6957
movl (%rcx,%rsi,4), %r8d
leaq (%rdx,%r8,4), %r8
movl (%r8), %r9d
shrl $0x5, %r9d
cvtss2sd 0x4(%r8,%r9,4), %xmm2
mulsd %xmm1, %xmm2
cvtsd2ss %xmm2, %xmm2
movss %xmm2, 0x4(%r8,%r9,4)
incq %rsi
jmp 0x6928
mulsd 0x2c09(%rip), %xmm0     # 0x9568
movsd %xmm0, 0x2a8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/./minisat/mtl/IntMap.h
// Function: Minisat::IntSet<Minisat::Lit, Minisat::MkIndexLit>::clear(bool)
void     clear       (bool free = false){
            if (free)
                in_set.clear(true); 
            else
                for (int i = 0; i < xs.size(); i++)
                    in_set[xs[i]] = 0;
            xs.clear(free);
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
je 0x6a04
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x72f2
addq $0x18, %r14
movzbl %bl, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35de
xorl %eax, %eax
movslq 0x20(%r14), %rcx
cmpq %rcx, %rax
jge 0x69ee
movq (%r14), %rcx
movq 0x18(%r14), %rdx
movslq (%rdx,%rax,4), %rdx
movb $0x0, (%rcx,%rdx)
incq %rax
jmp 0x6a06
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/minisat220/minisat-220/./minisat/mtl/Heap.h
// Function: Minisat::Heap<int, Minisat::Solver::VarOrderLt, Minisat::MkIndexDefault<int>>::build(Minisat::vec<int, int> const&)
void build(const vec<K>& ns) {
        for (int i = 0; i < heap.size(); i++)
            indices[heap[i]] = -1;
        heap.clear();

        for (int i = 0; i < ns.size(); i++){
            // TODO: this should probably call reserve instead of relying on it being reserved already.
            assert(indices.has(ns[i]));
            indices[ns[i]] = i;
            heap.push(ns[i]); }

        for (int i = heap.size() / 2 - 1; i >= 0; i--)
            percolateDown(i);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rdi), %rcx
xorl %edx, %edx
movslq 0x8(%rbx), %rsi
cmpq %rsi, %rdx
jge 0x6b15
movslq (%rax,%rdx,4), %rsi
orl $-0x1, (%rcx,%rsi,4)
incq %rdx
jmp 0x6aff
testq %rax, %rax
je 0x6b1e
andl $0x0, 0x8(%rbx)
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jge 0x6b50
movq (%r14), %rsi
movslq (%rsi,%r15), %rax
addq %r15, %rsi
movq 0x10(%rbx), %rcx
movl %r12d, (%rcx,%rax,4)
movq %rbx, %rdi
callq 0x665a
incq %r12
addq $0x4, %r15
jmp 0x6b24
movl 0x8(%rbx), %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, %ebp
testl %ebp, %ebp
jle 0x6b6d
decl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d62
jmp 0x6b5b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq