LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/tests/../include/lois.h
// Function: lois::lsetof<lois::lvector<lois::term>>::display(std::ostream&) const
std::ostream& lsetof<T>::display (std::ostream &os) const { 
  if(elts.size() == 0) return os << sym.emptyset;
  os << sym.leftbrace;
  for(size_t i=0; i<elts.size(); i++) {
    if(i) os << sym.ssunion;
    os << *elts[i];
    }
  return os << sym.rightbrace;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, 0x8(%rsp)
movq 0x18(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x15537
movq %rdi, %r12
movl $0xd8, %esi
addq 0x33b8d(%rip), %rsi     # 0x48fa8
leaq 0x88(%rsp), %rbx
movq %rbx, %rdi
callq 0xd15a
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0xd172
leaq 0x28(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x155f5
leaq 0x30(%rsp), %rdi
callq 0xefce
leaq 0x88(%rsp), %rdi
callq 0xd208
movl $0xc0, %eax
addq 0x33b3e(%rip), %rax     # 0x48fa8
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
leaq 0xa0(%rsp), %rbx
leaq 0x48(%rsp), %r14
xorl %r15d, %r15d
movq 0x10(%r12), %rax
movq 0x18(%r12), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rcx, %r15
jae 0x154f3
testq %r15, %r15
je 0x154dc
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0xd15a
movq %r14, %rbp
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd172
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x155f5
leaq 0x50(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0xd208
movq 0x10(%r12), %rax
movq (%rax,%r13), %rsi
movq 0x8(%rsp), %rdi
callq 0x15647
incq %r15
addq $0x10, %r13
jmp 0x15482
movl $0xf0, %esi
addq 0x33aa9(%rip), %rsi     # 0x48fa8
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
callq 0xd15a
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0xd172
leaq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x155f5
leaq 0x20(%rsp), %rdi
movq %rax, %rbx
leaq 0x58(%rsp), %r14
jmp 0x15579
movl $0xa8, %esi
addq 0x33a65(%rip), %rsi     # 0x48fa8
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0xd15a
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0xd172
leaq 0x38(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x155f5
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
leaq 0x70(%rsp), %r14
callq 0xefce
movq %r14, %rdi
callq 0xd208
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0xefce
leaq 0x70(%rsp), %rbx
jmp 0x155e5
jmp 0x155e2
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xefce
leaq 0x58(%rsp), %rbx
jmp 0x155e5
jmp 0x155e2
movq %rax, %r14
leaq 0x30(%rsp), %rdi
jmp 0x155db
jmp 0x155e2
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0xefce
jmp 0x155e5
movq %rax, %r14
movq %rbx, %rdi
callq 0xd208
movq %r14, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/tests/../include/lois.h
// Function: bool lois::usesenv<lois::lsetof<lois::lvector<lois::term>>>(lois::lsetof<lois::lvector<lois::term>> 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 $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0xf7c2
leaq 0x38(%rsp), %rbp
leaq 0x28(%rsp), %r13
movq %rbx, 0x18(%rsp)
movq 0x8(%rsp), %rax
movq (%rbx), %rcx
movq %rax, (%rsp)
movq %rcx, 0x20(%rsp)
cmpq %rcx, %rax
je 0x15c1f
movq (%rsp), %rax
testq %rax, %rax
je 0x15c46
movq 0x20(%rax), %r14
movq 0x28(%rax), %r12
cmpq %r12, %r14
je 0x15c06
movq %rbp, %rdi
movq %r14, %rsi
callq 0x1160e
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1160e
movq %r13, %rdi
movq %r15, %rsi
callq 0x16001
movl %eax, %ebx
leaq 0x30(%rsp), %rdi
callq 0xefce
leaq 0x40(%rsp), %rdi
callq 0xefce
addq $0x10, %r14
testb %bl, %bl
je 0x15bc0
jmp 0x15c1f
movq 0x8(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x112d4
movq 0x18(%rsp), %rbx
jmp 0x15b95
movq 0x20(%rsp), %rax
cmpq %rax, (%rsp)
setne %bl
leaq 0x10(%rsp), %rdi
callq 0xefce
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x7140
leaq 0x318cb(%rip), %rcx     # 0x47520
movq %rcx, (%rax)
leaq 0x31899(%rip), %rsi     # 0x474f8
movq 0x3337a(%rip), %rdx     # 0x48fe0
movq %rax, %rdi
callq 0x73f0
movq %rax, %r14
jmp 0x15c8a
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0xefce
leaq 0x40(%rsp), %rdi
callq 0xefce
leaq 0x10(%rsp), %rdi
callq 0xefce
movq %r14, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/tests/../include/lois.h
// Function: bool lois::isused<lois::lvector<lois::term>>(std::shared_ptr<lois::Variable>, lois::lsetof<lois::lvector<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, %r13
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %r15
leaq 0x18(%rsp), %r14
leaq 0x28(%rsp), %r12
movq %rax, %rbp
cmpq %r15, %rax
je 0x160d5
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x152ba
movq %r14, %rdi
movq %r13, %rsi
callq 0x1160e
movq 0x8(%rsp), %rsi
addq $0x28, %rsi
movq %r14, %rdi
callq 0x14629
testb %al, %al
jne 0x160c1
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1160e
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
movq %r12, %rdi
callq 0xf04a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1ef3f
movl %eax, %ebx
leaq 0x30(%rsp), %rdi
callq 0xefce
leaq 0x40(%rsp), %rdi
callq 0xefce
leaq 0x20(%rsp), %rdi
callq 0xefce
leaq 0x10(%rsp), %rdi
callq 0xefce
leaq 0x10(%rbp), %rax
testb %bl, %bl
je 0x16024
jmp 0x160d5
leaq 0x20(%rsp), %rdi
callq 0xefce
leaq 0x10(%rsp), %rdi
callq 0xefce
cmpq %r15, %rbp
setne %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xefce
leaq 0x40(%rsp), %rdi
callq 0xefce
jmp 0x16106
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xefce
leaq 0x10(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1e7ee
leaq 0x2af05(%rip), %r15     # 0x49770
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1eaec
addq $0x8, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x131f6
movq %r15, %rdi
movq %r14, %rsi
callq 0x112d4
leaq 0x10(%rsp), %rdi
callq 0xefce
leaq 0x2afc7(%rip), %rax     # 0x49870
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x1, %eax
je 0x1e8c9
cmpl $0x2, %eax
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x8
popq %rdi
callq 0x7140
leaq 0x290d0(%rip), %rcx     # 0x479a8
movq %rcx, (%rax)
leaq 0x29076(%rip), %rsi     # 0x47958
movq 0x2a6f7(%rip), %rdx     # 0x48fe0
movq %rax, %rdi
callq 0x73f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/env.cpp
// Function: lois::CondIterator::go()
void CondIterator::go() {
  if(state == ciIfThen)
    if(!enable(phi)) state = ciEnd;
  if(state == ciIfThenElse)
    if(!enable(phi)) state = ciElse;
  if(state == ciElse)
    if(!enable(!phi)) state = ciEnd;
  if(state == ciWhile) {
    if(!enable(phi)) { disable(); state = ciWhileFailed; }
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movl 0x28(%rdi), %eax
pushq $0x4
popq %r12
testl %eax, %eax
jne 0x1e945
leaq 0x48(%rsp), %r14
leaq 0x18(%rbx), %rsi
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0xf04a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1e84e
movl %eax, %ebp
leaq 0x48(%rsp), %rdi
callq 0xefce
testb %bpl, %bpl
je 0x1ea1a
movl 0x28(%rbx), %eax
cmpl $0x1, %eax
jne 0x1e97f
leaq 0x38(%rsp), %r14
leaq 0x18(%rbx), %rsi
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0xf04a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1e84e
movl %eax, %ebp
leaq 0x38(%rsp), %rdi
callq 0xefce
testb %bpl, %bpl
je 0x1e986
movl 0x28(%rbx), %eax
cmpl $0x3, %eax
je 0x1e98d
jmp 0x1e9d7
movl $0x3, 0x28(%rbx)
leaq 0x28(%rsp), %r14
leaq 0x18(%rbx), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xf04a
movq %rsp, %rdi
movq %r15, %rsi
callq 0x1ef2d
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1e84e
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0xefce
leaq 0x28(%rsp), %rdi
callq 0xefce
testb %bpl, %bpl
je 0x1ea1a
movl 0x28(%rbx), %eax
cmpl $0x2, %eax
jne 0x1ea1e
leaq 0x18(%rsp), %r14
leaq 0x18(%rbx), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xf04a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1e84e
movl %eax, %ebp
leaq 0x18(%rsp), %rdi
callq 0xefce
testb %bpl, %bpl
jne 0x1ea1e
movq %rbx, %rdi
callq 0x1e7ee
pushq $0x5
popq %r12
movl %r12d, 0x28(%rbx)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ea40
jmp 0x1ea40
jmp 0x1ea40
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xefce
jmp 0x1ea43
movq %rax, %rbx
movq %r14, %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::decomposeBin(lois::rbool, bool, std::vector<lois::rbool, std::allocator<lois::rbool>>&)
void decomposeBin(rbool b, bool bt, std::vector<rbool>& v) {
  auto dec = std::dynamic_pointer_cast<FormulaBi> (b.p);
  if(dec && dec->type == bt) {
    decomposeBin(dec->left, bt, v);
    decomposeBin(dec->right, bt, v);
    }
  else
    v.push_back(b);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x21738
movq (%r15), %rsi
testq %rsi, %rsi
je 0x1f839
cmpb %bpl, 0x10(%rsi)
jne 0x1f839
addq $0x18, %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xf04a
movzbl %bpl, %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x1f7ae
leaq 0x30(%rsp), %rdi
callq 0xefce
movq 0x8(%rsp), %rsi
addq $0x28, %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xf04a
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x1f7ae
leaq 0x20(%rsp), %rdi
callq 0xefce
jmp 0x1f844
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2178e
leaq 0x10(%rsp), %rdi
callq 0xefce
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x1f86b
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xefce
jmp 0x1f875
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::operator&&(lois::rbool, lois::rbool)
rbool operator && (rbool a, rbool b) {
  if(a.isTrue()) return b;
  if(b.isTrue()) return a;
  if(a.isFalse() || b.isFalse()) return ffalse;
  if(a.p == b.p) return a;

  auto ae = std::dynamic_pointer_cast<FormulaEq>(a.p);
  auto be = std::dynamic_pointer_cast<FormulaEq>(b.p);
  if(ae) if(be) {
    if(eqterm(ae->t1, be->t1) && eqterm(ae->t2, be->t2))
      return ae->type == be->type ? a : ffalse;
    if(eqterm(ae->t1, be->t2) && eqterm(ae->t2, be->t1))
      return ae->type == be->type ? a : ffalse;
    }

  // if(a->formulasize() > b->formulasize()) swap(a, b);
  
  return rbool(std::make_shared<FormulaBi> (true, a, b));
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x29682(%rip), %rdx     # 0x497b0
movq (%r15), %rcx
cmpq %rdx, %rax
je 0x2016f
movq %rsi, %r14
cmpq %rdx, %rcx
je 0x20250
movq 0x29677(%rip), %rdx     # 0x497c0
cmpq %rdx, %rax
setne %sil
cmpq %rdx, %rcx
setne %dl
testb %dl, %sil
jne 0x20188
leaq 0x2965e(%rip), %rsi     # 0x497c0
movq %rbx, %rdi
callq 0xf04a
jmp 0x202cb
movq %rcx, (%rbx)
movq 0x8(%r15), %rax
andq $0x0, 0x8(%r15)
movq %rax, 0x8(%rbx)
andq $0x0, (%r15)
jmp 0x202cb
cmpq %rcx, %rax
je 0x20250
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x21830
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x21830
movq (%r12), %rdi
testq %rdi, %rdi
je 0x20266
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x20266
addq $0x18, %rdi
addq $0x18, %rsi
callq 0x2190b
testb %al, %al
je 0x201f5
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
callq 0x2190b
testb %al, %al
jne 0x2022b
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
callq 0x2190b
testb %al, %al
je 0x20266
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movq 0x10(%rsp), %rsi
addq $0x18, %rsi
callq 0x2190b
testb %al, %al
je 0x20266
movq 0x20(%rsp), %rax
movb 0x10(%rax), %al
movq 0x10(%rsp), %rcx
cmpb 0x10(%rcx), %al
leaq 0x2957e(%rip), %rsi     # 0x497c0
cmoveq %r14, %rsi
movq %rbx, %rdi
callq 0xf04a
jmp 0x202b7
movq %rax, (%rbx)
movq 0x8(%r14), %rax
andq $0x0, 0x8(%r14)
movq %rax, 0x8(%rbx)
andq $0x0, (%r14)
jmp 0x202cb
leaq 0xf(%rsp), %rsi
movb $0x1, (%rsi)
leaq 0x30(%rsp), %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x21985
leaq 0x48(%rsp), %r14
leaq 0x38(%rsp), %r15
movaps -0x8(%r15), %xmm0
movaps %xmm0, -0x8(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r15)
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0xf04a
movq %r14, %rdi
callq 0xefce
movq %r15, %rdi
callq 0xefce
leaq 0x18(%rsp), %rdi
callq 0xefce
leaq 0x28(%rsp), %rdi
callq 0xefce
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xefce
leaq 0x28(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::operator||(lois::rbool, lois::rbool)
rbool operator || (rbool a, rbool b) {
  if(a.isFalse()) return b;
  if(b.isFalse()) return a;
  if(a.isTrue() || b.isTrue()) return ftrue;
  if(a.p == b.p) return a;

  auto ae = std::dynamic_pointer_cast<FormulaEq>(a.p);
  auto be = std::dynamic_pointer_cast<FormulaEq>(b.p);
  if(ae) if(be) {
    if(eqterm(ae->t1, be->t1) && eqterm(ae->t2, be->t2)) {
      return ae->type == be->type ? a : ftrue;
      }
    if(eqterm(ae->t1, be->t2) && eqterm(ae->t2, be->t1)) {
      return ae->type == be->type ? a : ftrue;
      }
    }

  return rbool(std::make_shared<FormulaBi> (false, a, b));
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x294ac(%rip), %rdx     # 0x497c0
movq (%r15), %rcx
cmpq %rdx, %rax
je 0x20355
movq %rsi, %r14
cmpq %rdx, %rcx
je 0x20436
movq 0x29481(%rip), %rdx     # 0x497b0
cmpq %rdx, %rax
setne %sil
cmpq %rdx, %rcx
setne %dl
testb %dl, %sil
jne 0x2036e
leaq 0x29468(%rip), %rsi     # 0x497b0
movq %rbx, %rdi
callq 0xf04a
jmp 0x204b1
movq %rcx, (%rbx)
movq 0x8(%r15), %rax
andq $0x0, 0x8(%r15)
movq %rax, 0x8(%rbx)
andq $0x0, (%r15)
jmp 0x204b1
cmpq %rcx, %rax
je 0x20436
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x21830
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x21830
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2044c
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x2044c
addq $0x18, %rdi
addq $0x18, %rsi
callq 0x2190b
testb %al, %al
je 0x203db
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
callq 0x2190b
testb %al, %al
jne 0x20411
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
callq 0x2190b
testb %al, %al
je 0x2044c
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movq 0x10(%rsp), %rsi
addq $0x18, %rsi
callq 0x2190b
testb %al, %al
je 0x2044c
movq 0x20(%rsp), %rax
movb 0x10(%rax), %al
movq 0x10(%rsp), %rcx
cmpb 0x10(%rcx), %al
leaq 0x29388(%rip), %rsi     # 0x497b0
cmoveq %r14, %rsi
movq %rbx, %rdi
callq 0xf04a
jmp 0x2049d
movq %rax, (%rbx)
movq 0x8(%r14), %rax
andq $0x0, 0x8(%r14)
movq %rax, 0x8(%rbx)
andq $0x0, (%r14)
jmp 0x204b1
leaq 0xf(%rsp), %rsi
movb $0x0, (%rsi)
leaq 0x30(%rsp), %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x21985
leaq 0x48(%rsp), %r14
leaq 0x38(%rsp), %r15
movaps -0x8(%r15), %xmm0
movaps %xmm0, -0x8(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r15)
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0xf04a
movq %r14, %rdi
callq 0xefce
movq %r15, %rdi
callq 0xefce
leaq 0x18(%rsp), %rdi
callq 0xefce
leaq 0x28(%rsp), %rdi
callq 0xefce
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xefce
leaq 0x28(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::FormulaQ::verifyAt(int)
bool FormulaQ::verifyAt(int at) {
  if(at == -1) return right->verify();
  auto dom = subGet(var[at]);
  int& nextval(dom->nextval);
  triesleft -= nextval;
  if(triesleft < 0) return false;
  for(int z=0; z<nextval; z++) { 
    var[at]->value = z; 
    if(verifyAt(at-1) != type) return !type;
    }
  var[at]->value = nextval;
  nextval++;
  bool b = generateAll(at, dom, nextval-1, 0);
  nextval--;
  return b;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
cmpl $-0x1, %esi
je 0x2057f
movl %esi, %r14d
leaq 0x20(%rsp), %rbx
movslq %esi, %r13
shlq $0x4, %r13
movq 0x28(%r15), %rsi
addq %r13, %rsi
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x1160e
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x205ef
leaq 0x20(%rsp), %rdi
callq 0xefce
movq 0x8(%rsp), %rbx
movl (%rbx), %eax
xorl %ebp, %ebp
subl %eax, 0x2925d(%rip)     # 0x497a0
js 0x205b8
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
leal -0x1(%r14), %r12d
movl (%rbx), %eax
movq 0x28(%r15), %rcx
movq (%rcx,%r13), %rcx
cmpl %eax, %ebp
jge 0x20597
movl %ebp, 0x44(%rcx)
movq %r15, %rdi
movl %r12d, %esi
callq 0x204e0
movb 0x10(%r15), %cl
incl %ebp
cmpb %al, %cl
je 0x20552
xorb $0x1, %cl
movl %ecx, %ebp
jmp 0x205b8
movq 0x18(%r15), %rdi
movq (%rdi), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x20(%rax)
movl %eax, 0x44(%rcx)
movl (%rbx), %ecx
leal 0x1(%rcx), %eax
movl %eax, (%rbx)
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movl %r14d, %esi
xorl %r8d, %r8d
callq 0x206a6
movl %eax, %ebp
decl (%rbx)
leaq 0x10(%rsp), %rdi
callq 0xefce
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x205db
movq %rbx, (%rsp)
jmp 0x205db
movq %rax, %r14
movq (%rsp), %rdi
callq 0xefce
movq %r14, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::FormulaQ::generateAll(int, std::shared_ptr<lois::Subdomain>&, int, int)
bool FormulaQ::generateAll(int at, std::shared_ptr<Subdomain>& dom, int val, int rid) {
  if(rid >= int(dom->rels.size())) {
    if(val < dom->nextval-1) 
      return generateAll(at, dom, val+1, 0);
    else
      return verifyAt(at-1);
    }
  else return dom->rels[rid]->exists(this, at, dom, val, rid);
  }

// Assembly:
movl %r8d, %r9d
movl %ecx, %r8d
movq %rdx, %rcx
movl %esi, %edx
movq %rdi, %rsi
movq (%rcx), %rdi
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %r10
subq %rax, %r10
shrq $0x4, %r10
cmpl %r10d, %r9d
jl 0x206de
movl (%rdi), %r9d
decl %r9d
cmpl %r8d, %r9d
jle 0x206f1
incl %r8d
xorl %r9d, %r9d
jmp 0x206c6
movslq %r9d, %rdi
shlq $0x4, %rdi
movq (%rax,%rdi), %rdi
movq (%rdi), %rax
movq (%rax), %rax
jmpq *%rax
decl %edx
movq %rsi, %rdi
movl %edx, %esi
jmp 0x204e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::Variable::display(std::ostream&) const
std::ostream& Variable::display (std::ostream& os) const {
  if(!id) id = ++vids;
  if(outlan == SMT || outlan == SMT_INC) os << "?";
  if(outlan == SPASS) os << "lois";
  if(name != "") os << name;
  else { os << autoprefix; autoname(os, id-1); }
  return os;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x40(%rdi)
jne 0x20cf5
movl 0x28abb(%rip), %eax     # 0x497a4
incl %eax
movl %eax, 0x28ab3(%rip)     # 0x497a4
movl %eax, 0x40(%r14)
leaq 0x28bf0(%rip), %r15     # 0x498ec
movl (%r15), %eax
movl %eax, %ecx
andl $-0x5, %ecx
cmpl $0x2, %ecx
jne 0x20d1b
leaq 0x11242(%rip), %rsi     # 0x31f52
movq %rbx, %rdi
callq 0x7230
movl (%r15), %eax
cmpl $0x3, %eax
jne 0x20d2f
leaq 0x1122d(%rip), %rsi     # 0x31f54
movq %rbx, %rdi
callq 0x7230
leaq 0x48(%r14), %r15
leaq 0x11932(%rip), %rsi     # 0x3266c
movq %r15, %rdi
callq 0x219f4
testb %al, %al
je 0x20d53
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7210
jmp 0x20d70
leaq 0x28a8e(%rip), %rsi     # 0x497e8
movq %rbx, %rdi
callq 0x7210
movl 0x40(%r14), %esi
decl %esi
movq %rbx, %rdi
callq 0x20c96
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::subInit(std::shared_ptr<lois::Variable>)
void subInit(vptr v) {
  if(v->curcheck < checkid) {
    v->curcheck = checkid;
    v->sublink = v;
    v->sub = nullsub;
    }
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x28a22(%rip), %eax     # 0x497a8
cmpl %eax, 0x18(%rdi)
jge 0x20dae
movl %eax, 0x18(%rdi)
addq $0x30, %rdi
movq %rbx, %rsi
callq 0x21ff2
movq (%rbx), %rdi
addq $0x20, %rdi
leaq 0x28a60(%rip), %rsi     # 0x49808
popq %rbx
jmp 0x2200e
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::Variable::subFindv(std::shared_ptr<lois::TermVariable>)
vptr Variable::subFindv(tvptr v) {
  vptr vv = std::dynamic_pointer_cast<Variable> (v);
  subInit(vv);
  vv->sublink = (vv->sublink == vv) ? vv : subFindv(vv->sublink);
  return vv->sublink;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x219fe
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1160e
movq %r12, %rdi
callq 0x20d79
leaq 0x38(%rsp), %rdi
callq 0xefce
movq (%r15), %r12
movq 0x30(%r12), %r13
cmpq %r12, %r13
je 0x20e25
leaq 0x30(%r12), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x12f26
movq (%r14), %rax
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x28(%rax)
jmp 0x20e32
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x1160e
movq (%rsp), %rdi
addq $0x30, %rdi
leaq 0x10(%rsp), %rsi
callq 0x22612
leaq 0x18(%rsp), %rdi
callq 0xefce
cmpq %r12, %r13
je 0x20e5d
leaq 0x28(%rsp), %rdi
callq 0xefce
leaq 0x8(%rsp), %r14
movq -0x8(%r14), %rsi
addq $0x30, %rsi
movq %rbx, %rdi
callq 0x1160e
movq %r14, %rdi
callq 0xefce
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xefce
leaq 0x8(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::TermBinary::subFindv(std::shared_ptr<lois::TermVariable>)
vptr TermBinary::subFindv(tvptr v) {
  if(v->curcheck < checkid) {
    vptr v1 = left.p->subFindv(left.p);
    vptr v2 = right.p->subFindv(right.p);
    if(v1 == nullvptr) return v2;
    if(v2 == nullvptr) return v1;
    if(v1->sublink != v2->sublink) {
      v2->sublink = v1->sublink;
      subJoin(v1->sub, v2->sub);
      }
    if(!v1->sub) v1->sub = std::make_shared<Subdomain> ();
    v1->sub->useRelation(r);
    sublink = v1->sublink;
    }
  return sublink;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rax
movl 0x8(%rax), %eax
cmpl 0x288df(%rip), %eax     # 0x497a8
jge 0x20ff8
leaq 0x48(%rsp), %r12
leaq 0x20(%r14), %rsi
movq 0x20(%r14), %r15
leaq 0x40(%rsp), %r13
movq %r13, %rdi
callq 0xf5ec
movq (%r15), %rax
movq %rsp, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq *0x28(%rax)
leaq 0x38(%rsp), %r15
leaq 0x48(%rsp), %rdi
callq 0xefce
leaq 0x30(%r14), %rsi
movq 0x30(%r14), %r12
leaq 0x30(%rsp), %r13
movq %r13, %rdi
callq 0xf5ec
movq (%r12), %rax
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *0x28(%rax)
leaq 0x38(%rsp), %rdi
callq 0xefce
movq (%rsp), %rsi
movq 0x2884d(%rip), %rax     # 0x49790
movq 0x10(%rsp), %rdi
cmpq %rax, %rsi
je 0x21009
cmpq %rax, %rdi
je 0x21023
leaq 0x18(%rsp), %r15
movq 0x30(%rsi), %rax
cmpq 0x30(%rdi), %rax
je 0x20f90
addq $0x30, %rsi
addq $0x30, %rdi
callq 0x21ff2
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
callq 0x21088
movq (%rsp), %rsi
movq 0x20(%rsi), %rdi
testq %rdi, %rdi
jne 0x20fc7
leaq 0x20(%rsp), %rdi
callq 0x21a53
movq (%rsp), %rdi
addq $0x20, %rdi
leaq 0x20(%rsp), %rsi
callq 0x252a6
leaq 0x28(%rsp), %rdi
callq 0xefce
movq (%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%r14), %rsi
callq 0x20c26
leaq 0x8(%rsp), %r15
movq -0x8(%r15), %rsi
addq $0x30, %rsi
leaq 0x40(%r14), %rdi
callq 0x21ff2
leaq 0x18(%rsp), %rdi
callq 0xefce
movq %r15, %rdi
callq 0xefce
addq $0x40, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1160e
jmp 0x2104e
movq %rdi, (%rbx)
movq 0x18(%rsp), %rax
andq $0x0, 0x18(%rsp)
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rsp)
jmp 0x2103a
movq %rsi, (%rbx)
movq 0x8(%rsp), %rax
andq $0x0, 0x8(%rsp)
movq %rax, 0x8(%rbx)
andq $0x0, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0xefce
leaq 0x8(%rsp), %rdi
callq 0xefce
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x21063
jmp 0x21063
movq %rax, %rbx
leaq 0x8(%rsp), %r12
movq %r15, %rdi
callq 0xefce
jmp 0x21078
movq %rax, %rbx
movq %r12, %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::TermConst::subFindv(std::shared_ptr<lois::TermVariable>)
vptr TermConst::subFindv(tvptr inv) {
  vptr vv = std::dynamic_pointer_cast<Variable> (inv);
  if(!vv) vv = v;
  subInit(vv);
  vv->sublink = (vv->sublink == vv) ? vv : subFindv(vv->sublink);
  return vv->sublink;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x219fe
cmpq $0x0, (%r15)
jne 0x21169
leaq 0x18(%r14), %rsi
movq %rsp, %rdi
callq 0x21ff2
leaq 0x30(%rsp), %r15
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1160e
movq %r15, %rdi
callq 0x20d79
leaq 0x38(%rsp), %rdi
callq 0xefce
movq (%r12), %r12
movq 0x30(%r12), %r13
cmpq %r12, %r13
je 0x211c1
leaq 0x30(%r12), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x12f26
movq (%r14), %rax
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x28(%rax)
jmp 0x211ce
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x1160e
movq (%rsp), %rdi
addq $0x30, %rdi
leaq 0x10(%rsp), %rsi
callq 0x22612
leaq 0x18(%rsp), %rdi
callq 0xefce
cmpq %r12, %r13
je 0x211f9
leaq 0x28(%rsp), %rdi
callq 0xefce
leaq 0x8(%rsp), %r14
movq -0x8(%r14), %rsi
addq $0x30, %rsi
movq %rbx, %rdi
callq 0x1160e
movq %r14, %rdi
callq 0xefce
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xefce
leaq 0x8(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::subGet(lois::term const&)
std::shared_ptr<Subdomain> subGet(const term& t) {
  vptr v = t.p->subFindv(t.p);
  if(v == nullvptr) return nullsub;
  if(!v->sub) v->sub = std::make_shared<Subdomain> ();
  return v->sub;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xf5ec
movq (%r14), %rax
movq %rsp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x28(%rax)
leaq 0x28(%rsp), %rdi
callq 0xefce
movq (%rsp), %rsi
cmpq 0x284af(%rip), %rsi     # 0x49790
je 0x2131f
cmpq $0x0, 0x20(%rsi)
jne 0x21319
leaq 0x8(%rsp), %r14
leaq 0x10(%rsp), %rdi
callq 0x21a53
movq (%rsp), %rdi
addq $0x20, %rdi
leaq 0x10(%rsp), %rsi
callq 0x252a6
leaq 0x18(%rsp), %rdi
callq 0xefce
movq (%rsp), %rsi
addq $0x20, %rsi
jmp 0x21326
leaq 0x284e2(%rip), %rsi     # 0x49808
movq %rbx, %rdi
callq 0x2202a
leaq 0x8(%rsp), %rdi
callq 0xefce
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x21352
movq %rax, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::subJoin(lois::term const&, lois::term const&)
std::shared_ptr<Subdomain> subJoin(const term& t1, const term &t2) {
  vptr v1 = t1.p->subFindv(t1.p);
  vptr v2 = t2.p->subFindv(t2.p);
  if(v1->sublink != v2->sublink) {
    v2->sublink = v1->sublink;
    subJoin(v1->sub, v2->sub);
    }
  if(!v1->sub) v1->sub = std::make_shared<Subdomain> ();
  return v1->sub;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq (%rsi), %r14
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0xf5ec
movq (%r14), %rax
movq %rsp, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq *0x28(%rax)
leaq 0x38(%rsp), %r14
leaq 0x48(%rsp), %rdi
callq 0xefce
movq (%r15), %r12
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xf5ec
movq (%r12), %rax
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *0x28(%rax)
leaq 0x18(%rsp), %r14
leaq 0x38(%rsp), %rdi
callq 0xefce
movq (%rsp), %rsi
movq -0x8(%r14), %rdi
movq 0x30(%rsi), %rax
cmpq 0x30(%rdi), %rax
je 0x21410
addq $0x30, %rsi
addq $0x30, %rdi
callq 0x21ff2
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
callq 0x21088
movq (%rsp), %rsi
cmpq $0x0, 0x20(%rsi)
jne 0x21441
leaq 0x20(%rsp), %rdi
callq 0x21a53
movq (%rsp), %rdi
addq $0x20, %rdi
leaq 0x20(%rsp), %rsi
callq 0x252a6
leaq 0x28(%rsp), %rdi
callq 0xefce
movq (%rsp), %rsi
addq $0x20, %rsi
movq %rbx, %rdi
callq 0x2202a
leaq 0x18(%rsp), %rdi
callq 0xefce
leaq 0x8(%rsp), %rdi
callq 0xefce
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x21476
jmp 0x21476
movq %rax, %rbx
leaq 0x8(%rsp), %r15
movq %r14, %rdi
callq 0xefce
jmp 0x21490
movq %rax, %rbx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::TermBinary::getValue()
int TermBinary::getValue() { 
  std::shared_ptr<Subdomain> d = subGet(left);
  if(d != subGet(right)) throw subdomain_exception();
  int i = 0;
  while(d->rels[i]->rel != r) i++;
  int r = d->rels[i]->checkterm(op, left.p->getValue(), right.p->getValue());
  return r;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x20(%rdi), %rsi
movq %rsp, %rdi
callq 0x212a1
leaq 0x30(%r14), %rbx
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x212a1
movq (%rsp), %r15
leaq 0x18(%rsp), %rdi
movq -0x8(%rdi), %r12
callq 0xefce
cmpq %r12, %r15
jne 0x21540
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%r14), %rcx
movq (%rax), %r15
addq $0x10, %rax
cmpq %rcx, 0x8(%r15)
jne 0x214ef
movl 0x18(%r14), %ebp
movq 0x20(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %r14d
movq (%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r15), %r8
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
movl %eax, %ecx
callq *0x10(%r8)
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0xefce
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x7140
leaq 0x266b1(%rip), %rcx     # 0x47c00
movq %rcx, (%rax)
leaq 0x264b7(%rip), %rsi     # 0x47a10
movq 0x27a80(%rip), %rdx     # 0x48fe0
movq %rax, %rdi
callq 0x73f0
jmp 0x2156c
jmp 0x2156c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/../include/loisinternal.h
// Function: lois::Formula::qsimplify()
rbool qsimplify() {
    if(!qty[0]) return ftrue;
    if(!qty[1]) return ffalse;
    rbool ret = qsimplify2();
    return ret;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rsi)
je 0x224c9
cmpl $0x0, 0xc(%rsi)
je 0x224d2
movq (%rsi), %rax
movq %rbx, %rdi
callq *0x58(%rax)
jmp 0x224e1
leaq 0x272e0(%rip), %rsi     # 0x497b0
jmp 0x224d9
leaq 0x272e7(%rip), %rsi     # 0x497c0
movq %rbx, %rdi
callq 0xf04a
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::FormulaBi::verify()
bool verify() { 
    bool b;
    if(type) b= left->verify() && right->verify(); 
    else b= left->verify() || right->verify();
#ifdef AGGSYM
    qty[b]++; 
#endif
    return b;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x10(%rdi), %bpl
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %ecx
cmpb $0x1, %bpl
jne 0x23880
testb %cl, %cl
jne 0x23886
xorl %eax, %eax
jmp 0x23890
movb $0x1, %al
testb %cl, %cl
jne 0x23890
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movzbl %al, %eax
incl 0x8(%rbx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::FormulaBi::uses(std::shared_ptr<lois::Variable>)
bool uses(vptr v) { 
    if(v == lastusecheck) return usestat;
    lastusecheck = v; usestat = 0;
    if(left->uses(v)) usestat |= 1;
    if(right->uses(v)) usestat |= 2;
    return usestat; }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
movq (%rsi), %rax
cmpq 0x38(%rdi), %rax
je 0x2394a
movq %rsi, %r14
leaq 0x38(%r15), %rdi
leaq 0x20(%rsp), %rbx
callq 0x21ff2
andl $0x0, 0x48(%r15)
movq 0x18(%r15), %r12
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x1160e
movq (%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *0x28(%rax)
movl %eax, %ebp
leaq 0x48(%r15), %r13
leaq 0x20(%rsp), %rdi
callq 0xefce
testb %bpl, %bpl
je 0x2390d
orb $0x1, (%r13)
leaq 0x10(%rsp), %rbx
movq 0x28(%r15), %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1160e
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x28(%rax)
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0xefce
testb %bpl, %bpl
je 0x23951
orb $0x2, (%r13)
jmp 0x23951
addq $0x48, %r15
movq %r15, %r13
cmpl $0x0, (%r13)
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2396a
movq %rax, %r14
movq %rbx, %rdi
callq 0xefce
movq %r14, %rdi
callq 0x7410
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::FormulaBi::valueKnown(std::shared_ptr<lois::Variable>, bool)
term valueKnown(vptr v, bool negated) { 
    // non-negated: AND => at least one
    if(negated == type) {
      // OR: both need the same value
      term v1 = left->valueKnown(v, negated);
      term v2 = right->valueKnown(v, negated);
      if(v1.p == v2.p) return v1;
      return nullterm;
      }
    else {
      term v1 = left->valueKnown(v, negated);
      if(v1.p) return v1;
      return right->valueKnown(v, negated);
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpb %bpl, 0x10(%rsi)
jne 0x23a31
movq 0x18(%r15), %r13
leaq 0x58(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1160e
movq (%r13), %rax
movzbl %bpl, %ebp
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq *0x30(%rax)
leaq 0x10(%rsp), %r13
leaq 0x60(%rsp), %rdi
callq 0xefce
movq 0x28(%r15), %r15
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1160e
movq (%r15), %rax
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq *0x30(%rax)
leaq 0x40(%rsp), %rdi
callq 0xefce
movq 0x8(%rsp), %rax
cmpq 0x48(%rsp), %rax
je 0x23abc
leaq 0x25dac(%rip), %rsi     # 0x497d0
movq %rbx, %rdi
callq 0xf5ec
jmp 0x23ad4
movq 0x18(%r15), %r13
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1160e
movq (%r13), %rax
movzbl %bpl, %ebp
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq *0x30(%rax)
leaq 0x30(%rsp), %rdi
callq 0xefce
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x23a8b
movq %rax, (%rbx)
movq 0x10(%rsp), %rax
andq $0x0, 0x10(%rsp)
movq %rax, 0x8(%rbx)
andq $0x0, 0x8(%rsp)
jmp 0x23ade
leaq 0x10(%rsp), %r13
movq 0x28(%r15), %r15
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1160e
movq (%r15), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq *0x30(%rax)
leaq 0x20(%rsp), %rdi
jmp 0x23ad9
movq %rax, (%rbx)
movq 0x10(%rsp), %rax
andq $0x0, 0x10(%rsp)
movq %rax, 0x8(%rbx)
andq $0x0, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xefce
leaq 0x10(%rsp), %rdi
callq 0xefce
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r14
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x23b12
movq %r13, %r14
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xefce
jmp 0x23b28
leaq 0x30(%rsp), %r14
jmp 0x23b25
leaq 0x60(%rsp), %r14
movq %rax, %rbx
movq %r14, %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::FormulaEq::FormulaEq(bool, lois::term, lois::term)
FormulaEq(bool t, term v1, term v2) : type(t), t1(v1), t2(v2) {
    // todo
    // if(t1 == t2) aerror("ta sama zmienna", t1, t2);
    /* if(v1->sortid < v2->sortid) {
      fv.push_back(v1);
      fv.push_back(v2);
      }
    else {
      fv.push_back(v2);
      fv.push_back(v1);
      } */
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x23e1b(%rip), %rax     # 0x47e40
movq %rax, (%rdi)
movb %sil, 0x10(%rdi)
addq $0x18, %rdi
movq %rdx, %rsi
callq 0xf5ec
addq $0x28, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf5ec
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::FormulaEq::display(std::ostream&) const
std::ostream& display (std::ostream &os) const { 
    if((outlan == SMT || outlan == SMT_INC) && type)
      return os << "(= " << t1 << " " << t2 << ")"; 
    if((outlan == SMT || outlan == SMT_INC) && !type)
      return os << "(not (= " << t1 << " " << t2 << "))";

    if(outlan == SPASS && type)
      return os << "equal(" << t1 << ", " << t2 << ")"; 
    if(outlan == SPASS && !type)
      return os << "not(equal(" << t1 << ", " << t2 << "))";

    return os << t1 << (type ? sym.eq : sym.neq) << t2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x25888(%rip), %rcx     # 0x498ec
movl (%rcx), %ecx
movl %ecx, %edx
andl $-0x5, %edx
cmpl $0x2, %edx
jne 0x240a1
leaq 0x18(%rbx), %r15
leaq 0x28(%rbx), %r14
cmpb $0x1, 0x10(%rbx)
jne 0x240f8
leaq 0xdf00(%rip), %rsi      # 0x31f85
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
movq %r15, %rsi
callq 0xd05a
leaq 0xe76a(%rip), %rsi      # 0x32809
jmp 0x240d9
cmpl $0x3, %ecx
jne 0x2411e
leaq 0x18(%rbx), %r15
leaq 0x28(%rbx), %r14
cmpb $0x1, 0x10(%rbx)
jne 0x2419c
leaq 0xded1(%rip), %rsi      # 0x31f90
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
movq %r15, %rsi
callq 0xd05a
leaq 0xe904(%rip), %rsi      # 0x329dd
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
movq %r14, %rsi
callq 0xd05a
leaq 0xe5bf(%rip), %rsi      # 0x326b2
jmp 0x241d7
leaq 0xde81(%rip), %rsi      # 0x31f80
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
movq %r15, %rsi
callq 0xd05a
leaq 0xe6f0(%rip), %rsi      # 0x32809
jmp 0x241bd
leaq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0xd05a
movq %rax, %r14
cmpb $0x0, 0x10(%rbx)
pushq $0x60
popq %rax
pushq $0x78
popq %rsi
cmovneq %rax, %rsi
addq 0x24e66(%rip), %rsi     # 0x48fa8
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0xd15a
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xd172
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x155f5
addq $0x28, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd05a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xefce
leaq 0x18(%rsp), %rdi
callq 0xd208
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xdde9(%rip), %rsi      # 0x31f8c
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
movq %r15, %rsi
callq 0xd05a
leaq 0xe820(%rip), %rsi      # 0x329dd
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
movq %r14, %rsi
callq 0xd05a
leaq 0xddb2(%rip), %rsi      # 0x31f89
movq %rax, %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7230
movq %rax, %rbx
jmp 0x241fa
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xefce
leaq 0x18(%rsp), %rdi
callq 0xd208
movq %rbx, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::FormulaBinary::FormulaBinary(lois::Relation*, int, lois::term, lois::term)
FormulaBinary(Relation *r, int i, term v1, term v2) : id(i), rel(r), t1(v1), t2(v2) {
    /* if(v1->sortid < v2->sortid) {
      fv.push_back(v1);
      fv.push_back(v2);
      }
    else {
      fv.push_back(v2);
      fv.push_back(v1);
      } */
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdi, %r14
leaq 0x233ab(%rip), %rax     # 0x47f00
movq %rax, (%rdi)
movl %edx, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
addq $0x20, %rdi
movq %rcx, %rsi
callq 0xf5ec
addq $0x30, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf5ec
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/formula.cpp
// Function: lois::FormulaBinary::verify()
bool verify() { 
    std::shared_ptr<Subdomain> d = subGet(t1);
    if(d != subGet(t2)) throw subdomain_exception();
    int i = 0;
    while(d->rels[i]->rel != rel) i++;
    bool b = d->rels[i]->check(id, t1.p->getValue(), t2.p->getValue());
#ifdef AGGSYM
    qty[b]++; 
#endif
    return b;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %rsi
movq %rsp, %rdi
callq 0x212a1
leaq 0x30(%rbx), %r14
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x212a1
movq (%rsp), %r15
leaq 0x18(%rsp), %rdi
movq -0x8(%rdi), %r12
callq 0xefce
cmpq %r12, %r15
jne 0x24d30
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rbx), %rcx
movq (%rax), %r15
addq $0x10, %rax
cmpq %rcx, 0x8(%r15)
jne 0x24cd9
movl 0x10(%rbx), %ebp
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %r12d
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r15), %r8
movq %r15, %rdi
movl %ebp, %esi
movl %r12d, %edx
movl %eax, %ecx
callq *0x8(%r8)
movl %eax, %ebp
movzbl %al, %eax
incl 0x8(%rbx,%rax,4)
leaq 0x8(%rsp), %rdi
callq 0xefce
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x7140
leaq 0x22ec1(%rip), %rcx     # 0x47c00
movq %rcx, (%rax)
leaq 0x22cc7(%rip), %rsi     # 0x47a10
movq 0x24290(%rip), %rdx     # 0x48fe0
movq %rax, %rdi
callq 0x73f0
jmp 0x24d5c
jmp 0x24d5c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/relations.cpp
// Function: lois::RelUnary::display(std::ostream&, int, lois::term const&, lois::term const&)
std::ostream& RelUnary::display(std::ostream& os, int id, const term& t1, const term& t2) {
  os << oprel;

  if(id == ID_UN_EQ)
    return os << "[" << t1 << sym.eq << t2 << "]";

  if(id == ID_UN_NEQ)
    return os << "[" << t1 << sym.neq << t2 << "]";

  for(int i=0; i<nogroups; i++) if(id & (1<<i)) os << i;
  return os << "(" << t1 << ")";
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rdi), %rsi
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0xf5d8
movq %r15, %rdi
movq %r13, %rsi
callq 0x155f5
leaq 0x30(%rsp), %rdi
callq 0xefce
cmpl $-0x2, %ebp
je 0x25ba7
cmpl $-0x1, %ebp
jne 0x25c29
leaq 0xce5e(%rip), %rsi      # 0x3298f
movq %r15, %rdi
callq 0x7230
movq %rax, %rdi
movq %r14, %rsi
callq 0xd05a
movq %rax, %r14
leaq 0x23da2(%rip), %rsi     # 0x498f0
addq $0x60, %rsi
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0xd15a
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xd172
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x155f5
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd05a
leaq 0xd712(%rip), %rsi      # 0x3329d
movq %rax, %rdi
callq 0x7230
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xefce
leaq 0x50(%rsp), %rdi
jmp 0x25c22
leaq 0xcde1(%rip), %rsi      # 0x3298f
movq %r15, %rdi
callq 0x7230
movq %rax, %rdi
movq %r14, %rsi
callq 0xd05a
movq %rax, %r14
leaq 0x23d25(%rip), %rsi     # 0x498f0
addq $0x78, %rsi
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0xd15a
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xd172
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x155f5
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd05a
leaq 0xd695(%rip), %rsi      # 0x3329d
movq %rax, %rdi
callq 0x7230
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xefce
leaq 0x38(%rsp), %rdi
callq 0xd208
jmp 0x25c71
xorl %ebx, %ebx
cmpl 0x18(%r12), %ebx
jge 0x25c45
btl %ebx, %ebp
jae 0x25c41
movq %r15, %rdi
movl %ebx, %esi
callq 0x7400
incl %ebx
jmp 0x25c2b
leaq 0xc2a8(%rip), %rsi      # 0x31ef4
movq %r15, %rdi
callq 0x7230
movq %rax, %rdi
movq %r14, %rsi
callq 0xd05a
leaq 0xca4c(%rip), %rsi      # 0x326b2
movq %rax, %rdi
callq 0x7230
movq %rax, %rbx
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x25c9a
movq %rax, %rbx
jmp 0x25cae
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xefce
leaq 0x38(%rsp), %rdi
jmp 0x25cb3
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xefce
leaq 0x50(%rsp), %rdi
callq 0xd208
jmp 0x25cc7
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/relations.cpp
// Function: lois::RelUnary::binform(int, lois::term const&, lois::term const&)
rbool RelUnary::binform(int id, const term& a, const term& b) {
  if(id >= 0) {
    int mask = ((1<<nogroups)-1);
    // note: no domain check -> they can actually be in different domains
    if((id & mask) == 0) return ffalse;
    if((id & mask) == mask) return ftrue;
    }
  if(id == ID_UN_EQ && eqterm(a,b)) return ftrue;
  if(id == ID_UN_NEQ && eqterm(a,b)) return ffalse;
  return makebinary(this,id,a,b);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
testl %edx, %edx
js 0x25d00
movb 0x18(%r12), %cl
pushq $-0x1
popq %rax
shll %cl, %eax
notl %eax
movl %eax, %ecx
andl %ebp, %ecx
je 0x25d31
cmpl %eax, %ecx
je 0x25d19
cmpl $-0x2, %ebp
je 0x25d22
cmpl $-0x1, %ebp
jne 0x25d42
movq %r15, %rdi
movq %r14, %rsi
callq 0x2190b
testb %al, %al
je 0x25d42
leaq 0x23a90(%rip), %rsi     # 0x497b0
jmp 0x25d38
movq %r15, %rdi
movq %r14, %rsi
callq 0x2190b
testb %al, %al
je 0x25d42
leaq 0x23a88(%rip), %rsi     # 0x497c0
movq %rbx, %rdi
callq 0xf04a
jmp 0x25d55
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x20bb4
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop