LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: eryxcc[P]lois/tests/../include/loisextra.h
// Function: lois::rbool lois::operator==<lois::term>(lois::lvector<lois::term> const&, lois::lvector<lois::term> const&)
rbool operator == (const lvector<T>& a, const lvector<T>& b) { 
    lbool res = ftrue;
    if(a.size() != b.size()) { res = ffalse; return res;}
    for(int i=0; i<(int) a.size(); i++)
      res &= (a[i] == b[i]);
    return res; 
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x81714(%rip), %rsi     # 0xa5830
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x11030
movq -0x78(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x171a0
jmp 0x24138
leaq -0x48(%rbp), %rdi
callq 0x11060
movq -0x10(%rbp), %rdi
callq 0x242d0
movq %rax, -0x90(%rbp)
jmp 0x24153
movq -0x18(%rbp), %rdi
callq 0x242d0
movq %rax, -0x98(%rbp)
jmp 0x24165
movq -0x90(%rbp), %rax
movq -0x98(%rbp), %rcx
cmpq %rcx, %rax
je 0x241d1
leaq 0x816c1(%rip), %rsi     # 0xa5840
leaq -0x38(%rbp), %rdi
callq 0x14370
jmp 0x2418a
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x17380
movl $0x1, -0x58(%rbp)
jmp 0x2429f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x11060
jmp 0x242be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x242b5
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0xa4(%rbp)
movq -0x10(%rbp), %rdi
callq 0x242d0
movq %rax, -0xa0(%rbp)
jmp 0x241f3
movl -0xa4(%rbp), %eax
movq -0xa0(%rbp), %rcx
cmpl %ecx, %eax
jge 0x24288
movq -0x10(%rbp), %rdi
movl -0x5c(%rbp), %esi
callq 0x242f0
movq %rax, -0xb0(%rbp)
jmp 0x2421d
movq -0x18(%rbp), %rdi
movl -0x5c(%rbp), %esi
callq 0x242f0
movq %rax, -0xb8(%rbp)
jmp 0x24232
movq -0xb8(%rbp), %rdx
movq -0xb0(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x43290
jmp 0x2424b
leaq -0x38(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x17220
jmp 0x2425a
leaq -0x70(%rbp), %rdi
callq 0x11060
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x241d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x11060
jmp 0x242b5
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x17380
movl $0x1, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x14780
movq -0x80(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x14780
movq -0x50(%rbp), %rdi
callq 0x84d0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x90(%rbp)
movq %rsi, %rax
movq -0x90(%rbp), %rsi
movq %rax, -0x88(%rbp)
movq %rdi, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x173b0
movq -0x88(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1af60
testb $0x1, %al
jne 0x29b71
jmp 0x29cdf
leaq -0x30(%rbp), %rdi
callq 0x1afa0
testb $0x1, %al
jne 0x29bce
movl $0x8, %edi
callq 0x8160
movq %rax, %rdi
movq %rdi, -0x98(%rbp)
movq $0x0, (%rdi)
callq 0x1afc0
movq -0x98(%rbp), %rdi
leaq 0x7991c(%rip), %rsi     # 0xa34c8
leaq -0xebb3(%rip), %rdx     # 0x1b000
callq 0x84b0
jmp 0x29d13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x29d01
leaq -0x30(%rbp), %rdi
callq 0x1b020
addq $0x20, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1b040
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1b070
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1b0a0
testb $0x1, %al
jne 0x29c0f
jmp 0x29cc5
leaq -0x50(%rbp), %rdi
callq 0x1b0e0
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x1b100
movq -0xb0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1b100
movq -0xa8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a270
movb %al, -0x99(%rbp)
jmp 0x29c5a
leaq -0x78(%rbp), %rdi
callq 0x10f20
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x29c6f
jmp 0x29c9c
movb $0x1, -0x1(%rbp)
movl $0x1, -0x7c(%rbp)
jmp 0x29ca3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x10f20
leaq -0x68(%rbp), %rdi
callq 0x10f20
jmp 0x29d01
movl $0x0, -0x7c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x10f20
movl -0x7c(%rbp), %eax
testl %eax, %eax
jne 0x29cea
jmp 0x29cb5
jmp 0x29cb7
leaq -0x50(%rbp), %rdi
callq 0x1b390
jmp 0x29bf9
leaq -0x30(%rbp), %rdi
callq 0x1b020
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x1ade0
jmp 0x29b58
movb $0x0, -0x1(%rbp)
movl $0x1, -0x7c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x14b20
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x14b20
movq -0x38(%rbp), %rdi
callq 0x84d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x282e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x28310
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x285e0
testb $0x1, %al
jne 0x2a2c6
jmp 0x2a490
leaq -0x28(%rbp), %rdi
callq 0x28650
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x286d0
movq -0x98(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1b100
movq -0xb0(%rbp), %rdi
callq 0x2a4b0
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
addq $0x28, %rsi
movb $0x0, -0x71(%rbp)
movb $0x0, -0x89(%rbp)
callq 0x257b0
movb %al, -0x99(%rbp)
jmp 0x2a32b
movb -0x99(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xb1(%rbp)
jne 0x2a3ae
jmp 0x2a340
movq -0x98(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x1b100
movb $0x1, -0x71(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2a4b0
movq %rax, %rsi
addq $0x18, %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x11030
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movb $0x1, -0x89(%rbp)
callq 0x400f0
movb %al, -0xb2(%rbp)
jmp 0x2a3a0
movb -0xb2(%rbp), %al
movb %al, -0xb1(%rbp)
jmp 0x2a3ae
movb -0xb1(%rbp), %al
movb %al, -0xc9(%rbp)
testb $0x1, -0x89(%rbp)
jne 0x2a3c5
jmp 0x2a3d1
leaq -0x88(%rbp), %rdi
callq 0x11060
testb $0x1, -0x71(%rbp)
jne 0x2a3d9
jmp 0x2a3e2
leaq -0x70(%rbp), %rdi
callq 0x10f20
leaq -0x50(%rbp), %rdi
callq 0x10f20
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x2a3f7
jmp 0x2a45f
movb $0x1, -0x1(%rbp)
movl $0x1, -0x90(%rbp)
jmp 0x2a469
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2a44b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
testb $0x1, -0x89(%rbp)
jne 0x2a42c
jmp 0x2a438
leaq -0x88(%rbp), %rdi
callq 0x11060
testb $0x1, -0x71(%rbp)
jne 0x2a440
jmp 0x2a449
leaq -0x70(%rbp), %rdi
callq 0x10f20
jmp 0x2a44b
leaq -0x50(%rbp), %rdi
callq 0x10f20
leaq -0x40(%rbp), %rdi
callq 0x25b90
jmp 0x2a4a2
movl $0x0, -0x90(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x25b90
movl -0x90(%rbp), %eax
testl %eax, %eax
je 0x2a480
jmp 0x2a47e
jmp 0x2a494
jmp 0x2a482
leaq -0x28(%rbp), %rdi
callq 0x28670
jmp 0x2a2b0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x84d0
nopl (%rax,%rax)
// File: eryxcc[P]lois/tests/../include/lois.h
// Function: lois::EIteratorOf<lois::lvector<lois::term>>::disconnectIterator()
void EIteratorOf<T>::disconnectIterator() {
  // printf("%p: disconnect\n", this);
  if(ourcontext) {
    if(currentcontext != ourcontext) throw iterator_exception();
    currentcontext = ourcontext->parent;
    ourcontext = NULL;
    at = NULL;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x20, %rdi
callq 0x1afa0
testb $0x1, %al
jne 0x2a6b6
jmp 0x2a777
movq -0x30(%rbp), %rsi
addq $0x20, %rsi
leaq 0x7b12b(%rip), %rdi     # 0xa57f0
callq 0x1af60
testb $0x1, %al
jne 0x2a6d0
jmp 0x2a70d
movl $0x8, %edi
callq 0x8160
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x8190
movq -0x38(%rbp), %rdi
callq 0x2a780
movq -0x38(%rbp), %rdi
leaq 0x78fff(%rip), %rsi     # 0xa3700
leaq 0xb8(%rip), %rdx        # 0x2a7c0
callq 0x84b0
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x1b020
movq %rax, %rsi
leaq 0x7b0cc(%rip), %rdi     # 0xa57f0
callq 0x1ade0
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a7e0
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
leaq -0x18(%rbp), %rsi
callq 0x202d0
leaq -0x18(%rbp), %rdi
callq 0x14b20
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a800
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
leaq -0x28(%rbp), %rsi
callq 0x204e0
leaq -0x28(%rbp), %rdi
callq 0x1ffd0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: eryxcc[P]lois/src/env.cpp
// Function: lois::ArbCondition::disable()
void ArbCondition::disable() {
  if(ourcontext) {
    if(currentcontext == ourcontext) {
      currentcontext = ourcontext->parent, ourcontext = emptycontext;
      }
    else {
      throw condition_exception();
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x8, %rdi
callq 0x1afa0
testb $0x1, %al
jne 0x3e6a6
jmp 0x3e731
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq 0x6713b(%rip), %rdi     # 0xa57f0
callq 0x3ec00
testb $0x1, %al
jne 0x3e6c0
jmp 0x3e6f2
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1b020
movq %rax, %rsi
leaq 0x67119(%rip), %rdi     # 0xa57f0
callq 0x1ade0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq 0x670f5(%rip), %rsi     # 0xa57e0
callq 0x1ade0
jmp 0x3e72f
movl $0x8, %edi
callq 0x8160
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x8190
movq -0x18(%rbp), %rdi
callq 0x3ed60
movq -0x18(%rbp), %rdi
leaq 0x651ed(%rip), %rsi     # 0xa3910
leaq 0x676(%rip), %rdx       # 0x3eda0
callq 0x84b0
jmp 0x3e731
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x3e680
movq -0x38(%rbp), %rdx
leaq -0x20(%rbp), %rdi
leaq 0x67080(%rip), %rsi     # 0xa57f0
callq 0x3edc0
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
leaq -0x20(%rbp), %rsi
callq 0x202d0
movq %rax, %rsi
leaq 0x67060(%rip), %rdi     # 0xa57f0
callq 0x1ade0
leaq -0x20(%rbp), %rdi
callq 0x14b20
leaq 0x67143(%rip), %rdi     # 0xa58e8
callq 0x20350
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jne 0x3e7f9
movl $0x8, %edi
callq 0x8160
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x8190
movq -0x40(%rbp), %rdi
callq 0x3ee40
movq -0x40(%rbp), %rdi
leaq 0x6513b(%rip), %rsi     # 0xa3928
leaq 0x68c(%rip), %rdx       # 0x3ee80
callq 0x84b0
cmpl $0x2, -0x24(%rbp)
sete %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movl %esi, %eax
movq %rdi, %rsi
movq %rsi, -0x60(%rbp)
movq %rsi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x44a30
leaq -0x28(%rbp), %rdi
callq 0x44ac0
testb $0x1, %al
jne 0x41129
jmp 0x411f3
leaq -0x28(%rbp), %rdi
callq 0x44ae0
movb 0x10(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x9(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x411f3
leaq -0x28(%rbp), %rdi
callq 0x44ae0
movq %rax, %rsi
addq $0x18, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x11030
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rdx
movzbl -0x9(%rbp), %esi
andl $0x1, %esi
callq 0x410f0
jmp 0x4117e
leaq -0x38(%rbp), %rdi
callq 0x11060
leaq -0x28(%rbp), %rdi
callq 0x44ae0
movq %rax, %rsi
addq $0x28, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x11030
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rdx
movzbl -0x9(%rbp), %esi
andl $0x1, %esi
callq 0x410f0
jmp 0x411ba
leaq -0x58(%rbp), %rdi
callq 0x11060
jmp 0x41212
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11060
jmp 0x41221
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x11060
jmp 0x41221
movq -0x60(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x44b00
jmp 0x41202
jmp 0x41212
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x41221
leaq -0x28(%rbp), %rdi
callq 0x44b70
addq $0x70, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x44b70
movq -0x40(%rbp), %rdi
callq 0x84d0
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x45010
movq %rax, %rdi
addq $0x8, %rdi
callq 0x45030
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jl 0x42d0b
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x45010
movq %rax, %rcx
movl -0x3c(%rbp), %eax
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x42cf5
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
xorl %r8d, %r8d
callq 0x42c70
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x42d4c
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x42950
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x42d4c
movq -0x20(%rbp), %rdi
callq 0x45010
movq %rax, %rdi
addq $0x8, %rdi
movslq -0x28(%rbp), %rsi
callq 0x45050
movq %rax, %rdi
callq 0x45070
movq -0x38(%rbp), %rsi
movq %rax, %rdi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movl -0x28(%rbp), %r9d
movq (%rdi), %rax
callq *(%rax)
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x40(%rax)
jne 0x436e4
movq -0x18(%rbp), %rax
movl 0x6214c(%rip), %ecx     # 0xa5824
addl $0x1, %ecx
movl %ecx, 0x62143(%rip)     # 0xa5824
movl %ecx, 0x40(%rax)
leaq 0x62279(%rip), %rax     # 0xa5964
cmpl $0x2, (%rax)
je 0x436fc
leaq 0x6226d(%rip), %rax     # 0xa5964
cmpl $0x6, (%rax)
jne 0x4370c
movq -0x10(%rbp), %rdi
leaq 0x2f8c7(%rip), %rsi     # 0x72fce
callq 0x82b0
leaq 0x62251(%rip), %rax     # 0xa5964
cmpl $0x3, (%rax)
jne 0x43728
movq -0x10(%rbp), %rdi
leaq 0x2f8ad(%rip), %rsi     # 0x72fd0
callq 0x82b0
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
leaq 0x2ff88(%rip), %rsi     # 0x736bf
callq 0x454c0
testb $0x1, %al
jne 0x43742
jmp 0x43755
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x48, %rsi
callq 0x8280
jmp 0x43778
movq -0x10(%rbp), %rdi
leaq 0x62108(%rip), %rsi     # 0xa5868
callq 0x8280
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x40(%rax), %esi
subl $0x1, %esi
callq 0x43660
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x11830
movl 0x18(%rax), %eax
cmpl 0x6207a(%rip), %eax     # 0xa5828
jge 0x437fd
movq -0x10(%rbp), %rdi
movl 0x6206e(%rip), %eax     # 0xa5828
movl %eax, -0x14(%rbp)
callq 0x11830
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rdi
movl %ecx, 0x18(%rax)
callq 0x11830
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0x30, %rdi
callq 0x44bb0
movq -0x10(%rbp), %rdi
callq 0x11830
movq %rax, %rdi
addq $0x20, %rdi
leaq 0x62090(%rip), %rsi     # 0xa5888
callq 0x454f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x90(%rbp)
movq %rsi, %rax
movq -0x90(%rbp), %rsi
movq %rdi, -0x88(%rbp)
movq %rdi, %rcx
movq %rcx, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x45520
leaq -0x38(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1b100
leaq -0x38(%rbp), %rdi
callq 0x43790
leaq -0x38(%rbp), %rdi
callq 0x10f20
leaq -0x28(%rbp), %rdi
callq 0x11830
movq %rax, %rdi
addq $0x30, %rdi
leaq -0x28(%rbp), %rsi
callq 0x45090
movb $0x0, -0x59(%rbp)
testb $0x1, %al
jne 0x43899
jmp 0x438a8
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1b100
jmp 0x438e8
leaq -0x28(%rbp), %rdi
callq 0x11830
movq %rax, %rsi
addq $0x30, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x20220
movq -0x78(%rbp), %rsi
movq -0x98(%rbp), %rdx
movb $0x1, -0x59(%rbp)
movq (%rsi), %rax
movq 0x28(%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
jmp 0x438e6
jmp 0x438e8
leaq -0x28(%rbp), %rdi
callq 0x11830
movq %rax, %rdi
addq $0x30, %rdi
leaq -0x48(%rbp), %rsi
callq 0x455b0
leaq -0x48(%rbp), %rdi
callq 0x10f20
testb $0x1, -0x59(%rbp)
jne 0x43912
jmp 0x4391b
leaq -0x58(%rbp), %rdi
callq 0x14cf0
leaq -0x28(%rbp), %rdi
callq 0x11830
movq -0x88(%rbp), %rdi
movq %rax, %rsi
addq $0x30, %rsi
callq 0x1b100
leaq -0x28(%rbp), %rdi
callq 0x10f20
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
testb $0x1, -0x59(%rbp)
jne 0x43961
jmp 0x4396a
leaq -0x58(%rbp), %rdi
callq 0x14cf0
leaq -0x28(%rbp), %rdi
callq 0x10f20
movq -0x68(%rbp), %rdi
callq 0x84d0
nopl (%rax)
// File: eryxcc[P]lois/src/formula.cpp
// Function: lois::subJoin(std::shared_ptr<lois::Subdomain>&, std::shared_ptr<lois::Subdomain>&)
void subJoin(std::shared_ptr<Subdomain>& s1, std::shared_ptr<Subdomain>& s2) {
  if(s2 == nullsub) return;
  if(s1 == nullsub) { swap(s1, s2); return; }
  s1->numEq += s2->numEq;
  s1->numQuantifier += s2->numQuantifier;
  for(size_t i=0; i<s2->rels.size(); i++) 
    s1->useRelation(s2->rels[i]->rel);
  s2 = nullsub;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x61b7d(%rip), %rsi     # 0xa5888
callq 0x457b0
testb $0x1, %al
jne 0x43d16
jmp 0x43d1b
jmp 0x43e0f
movq -0x8(%rbp), %rdi
leaq 0x61b62(%rip), %rsi     # 0xa5888
callq 0x457b0
testb $0x1, %al
jne 0x43d31
jmp 0x43d43
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x457f0
jmp 0x43e0f
movq -0x10(%rbp), %rdi
callq 0x45010
movl 0x20(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45010
movl -0x20(%rbp), %ecx
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x45010
movl 0x24(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45010
movl -0x1c(%rbp), %ecx
addl 0x24(%rax), %ecx
movl %ecx, 0x24(%rax)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x45010
movq %rax, %rdi
addq $0x8, %rdi
callq 0x45030
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x43dff
movq -0x8(%rbp), %rdi
callq 0x45010
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x45010
movq %rax, %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x45050
movq %rax, %rdi
callq 0x45070
movq -0x30(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x43580
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x43d8d
movq -0x10(%rbp), %rdi
leaq 0x61a7e(%rip), %rsi     # 0xa5888
callq 0x454f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x90(%rbp)
movq %rsi, %rax
movq -0x90(%rbp), %rsi
movq %rdi, -0x88(%rbp)
movq %rdi, %rcx
movq %rcx, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x45520
leaq -0x28(%rbp), %rdi
callq 0x44d90
testb $0x1, %al
jne 0x43e85
movq -0x78(%rbp), %rsi
addq $0x18, %rsi
leaq -0x28(%rbp), %rdi
callq 0x44bb0
leaq -0x38(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1b100
leaq -0x38(%rbp), %rdi
callq 0x43790
leaq -0x38(%rbp), %rdi
callq 0x10f20
leaq -0x28(%rbp), %rdi
callq 0x11830
movq %rax, %rdi
addq $0x30, %rdi
leaq -0x28(%rbp), %rsi
callq 0x45090
movb $0x0, -0x59(%rbp)
testb $0x1, %al
jne 0x43ec7
jmp 0x43ed6
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1b100
jmp 0x43f16
leaq -0x28(%rbp), %rdi
callq 0x11830
movq %rax, %rsi
addq $0x30, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x20220
movq -0x78(%rbp), %rsi
movq -0x98(%rbp), %rdx
movb $0x1, -0x59(%rbp)
movq (%rsi), %rax
movq 0x28(%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
jmp 0x43f14
jmp 0x43f16
leaq -0x28(%rbp), %rdi
callq 0x11830
movq %rax, %rdi
addq $0x30, %rdi
leaq -0x48(%rbp), %rsi
callq 0x455b0
leaq -0x48(%rbp), %rdi
callq 0x10f20
testb $0x1, -0x59(%rbp)
jne 0x43f40
jmp 0x43f49
leaq -0x58(%rbp), %rdi
callq 0x14cf0
leaq -0x28(%rbp), %rdi
callq 0x11830
movq -0x88(%rbp), %rdi
movq %rax, %rsi
addq $0x30, %rsi
callq 0x1b100
leaq -0x28(%rbp), %rdi
callq 0x10f20
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
testb $0x1, -0x59(%rbp)
jne 0x43f8f
jmp 0x43f98
leaq -0x58(%rbp), %rdi
callq 0x14cf0
leaq -0x28(%rbp), %rdi
callq 0x10f20
movq -0x68(%rbp), %rdi
callq 0x84d0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14bd0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x16e30
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq (%rsi), %rax
movq 0x28(%rax), %rax
leaq -0x20(%rbp), %rdi
callq *%rax
jmp 0x440e0
leaq -0x30(%rbp), %rdi
callq 0x14cf0
leaq -0x20(%rbp), %rdi
leaq 0x6171c(%rip), %rsi     # 0xa5810
callq 0x45090
testb $0x1, %al
jne 0x440ff
jmp 0x44135
movq -0x70(%rbp), %rdi
leaq 0x6177e(%rip), %rsi     # 0xa5888
callq 0x45780
movl $0x1, -0x40(%rbp)
jmp 0x441b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x14cf0
jmp 0x441c7
leaq -0x20(%rbp), %rdi
callq 0x11830
movq %rax, %rdi
addq $0x20, %rdi
callq 0x45620
testb $0x1, %al
jne 0x44194
leaq -0x50(%rbp), %rdi
callq 0x45640
jmp 0x44159
leaq -0x20(%rbp), %rdi
callq 0x11830
movq %rax, %rdi
addq $0x20, %rdi
leaq -0x50(%rbp), %rsi
callq 0x456b0
leaq -0x50(%rbp), %rdi
callq 0x21170
jmp 0x44194
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x10f20
jmp 0x441c7
leaq -0x20(%rbp), %rdi
callq 0x11830
movq -0x70(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x45780
movl $0x1, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x10f20
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x84d0
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14bd0
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x16e30
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq (%rsi), %rax
movq 0x28(%rax), %rax
leaq -0x28(%rbp), %rdi
callq *%rax
jmp 0x44233
leaq -0x38(%rbp), %rdi
callq 0x14cf0
movq -0x18(%rbp), %rdi
callq 0x14bd0
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x16e30
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq (%rsi), %rax
movq 0x28(%rax), %rax
leaq -0x58(%rbp), %rdi
callq *%rax
jmp 0x4427d
leaq -0x68(%rbp), %rdi
callq 0x14cf0
leaq -0x28(%rbp), %rdi
callq 0x11830
addq $0x30, %rax
movq %rax, -0xb0(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x11830
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
addq $0x30, %rsi
callq 0x455e0
testb $0x1, %al
jne 0x442bf
jmp 0x44385
leaq -0x28(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x11830
addq $0x30, %rax
movq %rax, -0xd0(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x11830
movq -0xd0(%rbp), %rsi
movq %rax, %rdi
addq $0x30, %rdi
callq 0x44bb0
movq -0xc8(%rbp), %rdi
callq 0x11830
movq -0xc0(%rbp), %rdi
addq $0x20, %rax
movq %rax, -0xb8(%rbp)
callq 0x11830
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x43cf0
jmp 0x44335
jmp 0x44385
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x14cf0
jmp 0x44412
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x14cf0
jmp 0x44409
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x10f20
jmp 0x44409
leaq -0x28(%rbp), %rdi
callq 0x11830
movq %rax, %rdi
addq $0x20, %rdi
callq 0x45620
testb $0x1, %al
jne 0x443cb
leaq -0x78(%rbp), %rdi
callq 0x45640
jmp 0x443a9
leaq -0x28(%rbp), %rdi
callq 0x11830
movq %rax, %rdi
addq $0x20, %rdi
leaq -0x78(%rbp), %rsi
callq 0x456b0
leaq -0x78(%rbp), %rdi
callq 0x21170
leaq -0x28(%rbp), %rdi
callq 0x11830
movq -0x98(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x45780
leaq -0x58(%rbp), %rdi
callq 0x10f20
leaq -0x28(%rbp), %rdi
callq 0x10f20
movq -0x90(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x10f20
movq -0x40(%rbp), %rdi
callq 0x84d0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
addq $0x20, %rsi
leaq -0x18(%rbp), %rdi
callq 0x44090
movq -0x48(%rbp), %rsi
addq $0x30, %rsi
leaq -0x28(%rbp), %rdi
callq 0x44090
jmp 0x44457
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x45820
movb %al, -0x49(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x21170
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x44479
jmp 0x444cc
movl $0x8, %edi
callq 0x8160
movq %rax, %rdi
movq %rdi, -0x58(%rbp)
movq $0x0, (%rdi)
callq 0x45860
movq -0x58(%rbp), %rdi
leaq 0x5f5bf(%rip), %rsi     # 0xa3a60
leaq 0x13f8(%rip), %rdx      # 0x458a0
callq 0x84b0
jmp 0x445b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x21170
jmp 0x445ae
movl $0x0, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x45010
movq %rax, %rdi
addq $0x8, %rdi
movslq -0x38(%rbp), %rsi
callq 0x45050
movq %rax, %rdi
callq 0x45070
movq -0x48(%rbp), %rcx
movq 0x8(%rax), %rax
cmpq 0x10(%rcx), %rax
je 0x4450d
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x444d3
leaq -0x18(%rbp), %rdi
callq 0x45010
movq %rax, %rdi
addq $0x8, %rdi
movslq -0x38(%rbp), %rsi
callq 0x45050
movq %rax, %rdi
callq 0x45070
movq -0x48(%rbp), %rdi
movq %rax, -0x68(%rbp)
movl 0x18(%rdi), %eax
movl %eax, -0x60(%rbp)
addq $0x20, %rdi
callq 0x14bd0
movq %rax, %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, -0x5c(%rbp)
jmp 0x44555
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
callq 0x14bd0
movq %rax, %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, -0x6c(%rbp)
jmp 0x44572
movl -0x6c(%rbp), %ecx
movl -0x5c(%rbp), %edx
movl -0x60(%rbp), %esi
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movl %eax, -0x70(%rbp)
jmp 0x4458d
movl -0x70(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x74(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x21170
movl -0x74(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x84d0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x8(%rax)
jne 0x4776b
movq -0x30(%rbp), %rdi
leaq 0x5e0cc(%rip), %rsi     # 0xa5830
callq 0x11030
jmp 0x477ae
movq -0x20(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x47787
movq -0x30(%rbp), %rdi
leaq 0x5e0c0(%rip), %rsi     # 0xa5840
callq 0x11030
jmp 0x477ae
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movb $0x0, -0x11(%rbp)
movq (%rsi), %rax
callq *0x58(%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x477ac
movq -0x30(%rbp), %rdi
callq 0x11060
jmp 0x477ae
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x10(%rax)
je 0x4c411
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x3ece0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0x4c3ee
jmp 0x4c407
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x3ece0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x4c454
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x3ece0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1a(%rbp)
jne 0x4c44c
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x3ece0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x18(%rbp), %rax
movb -0x9(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl 0x8(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x8(%rax,%rcx,4)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, %rax
movq -0x60(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x50(%rbp)
addq $0x38, %rsi
callq 0x45090
testb $0x1, %al
jne 0x4c4b9
jmp 0x4c4ce
movq -0x50(%rbp), %rax
cmpl $0x0, 0x48(%rax)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4c5e5
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
callq 0x44bb0
movq -0x50(%rbp), %rdi
movl $0x0, 0x48(%rdi)
addq $0x18, %rdi
callq 0x3ece0
movq -0x58(%rbp), %rsi
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1b100
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
movb %al, -0x61(%rbp)
jmp 0x4c51e
leaq -0x28(%rbp), %rdi
callq 0x10f20
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x4c530
jmp 0x4c559
movq -0x50(%rbp), %rax
movl 0x48(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x48(%rax)
jmp 0x4c559
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x10f20
jmp 0x4c5f3
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
callq 0x3ece0
movq -0x58(%rbp), %rsi
movq %rax, -0x90(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x1b100
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
movb %al, -0x79(%rbp)
jmp 0x4c59d
leaq -0x48(%rbp), %rdi
callq 0x10f20
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x4c5af
jmp 0x4c5d5
movq -0x50(%rbp), %rax
movl 0x48(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x48(%rax)
jmp 0x4c5d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x10f20
jmp 0x4c5f3
movq -0x50(%rbp), %rax
cmpl $0x0, 0x48(%rax)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x84d0
nopl (%rax)
// File: eryxcc[P]lois/src/formula.cpp
// Function: lois::FormulaEq::verify()
bool verify() { 
    bool b;
    if(type) b= t1.p->getValue() == t2.p->getValue(); 
    else b = t1.p->getValue() != t2.p->getValue();
#ifdef AGGSYM
    qty[b]++; 
#endif
    return b;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x10(%rax)
je 0x4e0d8
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x14bd0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rdi
movl %eax, -0x1c(%rbp)
addq $0x28, %rdi
callq 0x14bd0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x4e114
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x14bd0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rdi
movl %eax, -0x20(%rbp)
addq $0x28, %rdi
callq 0x14bd0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
setne %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x18(%rbp), %rax
movb -0x9(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl 0x8(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x8(%rax,%rcx,4)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
addq $0x20, %rsi
leaq -0x18(%rbp), %rdi
callq 0x44090
movq -0x48(%rbp), %rsi
addq $0x30, %rsi
leaq -0x28(%rbp), %rdi
callq 0x44090
jmp 0x4fd24
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x45820
movb %al, -0x49(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x21170
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x4fd46
jmp 0x4fd99
movl $0x8, %edi
callq 0x8160
movq %rax, %rdi
movq %rdi, -0x58(%rbp)
movq $0x0, (%rdi)
callq 0x45860
movq -0x58(%rbp), %rdi
leaq 0x53cf2(%rip), %rsi     # 0xa3a60
leaq -0xa4d5(%rip), %rdx     # 0x458a0
callq 0x84b0
jmp 0x4fe9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x21170
jmp 0x4fe95
movl $0x0, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x45010
movq %rax, %rdi
addq $0x8, %rdi
movslq -0x38(%rbp), %rsi
callq 0x45050
movq %rax, %rdi
callq 0x45070
movq -0x48(%rbp), %rcx
movq 0x8(%rax), %rax
cmpq 0x18(%rcx), %rax
je 0x4fdda
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x4fda0
leaq -0x18(%rbp), %rdi
callq 0x45010
movq %rax, %rdi
addq $0x8, %rdi
movslq -0x38(%rbp), %rsi
callq 0x45050
movq %rax, %rdi
callq 0x45070
movq -0x48(%rbp), %rdi
movq %rax, -0x68(%rbp)
movl 0x10(%rdi), %eax
movl %eax, -0x60(%rbp)
addq $0x20, %rdi
callq 0x14bd0
movq %rax, %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, -0x5c(%rbp)
jmp 0x4fe22
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
callq 0x14bd0
movq %rax, %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, -0x6c(%rbp)
jmp 0x4fe3f
movl -0x6c(%rbp), %ecx
movl -0x5c(%rbp), %edx
movl -0x60(%rbp), %esi
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movb %al, -0x6d(%rbp)
jmp 0x4fe5a
movq -0x48(%rbp), %rax
movb -0x6d(%rbp), %cl
andb $0x1, %cl
movb %cl, -0x39(%rbp)
movb -0x39(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl 0x8(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x8(%rax,%rcx,4)
movb -0x39(%rbp), %al
movb %al, -0x6e(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x21170
movb -0x6e(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x84d0
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x53567
movq -0x38(%rbp), %rax
movl 0x18(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %eax
andl -0x2c(%rbp), %eax
cmpl $0x0, %eax
jne 0x53548
movq -0x48(%rbp), %rdi
leaq 0x52302(%rip), %rsi     # 0xa5840
callq 0x11030
jmp 0x535d5
movl -0x14(%rbp), %eax
andl -0x2c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jne 0x53565
movq -0x48(%rbp), %rdi
leaq 0x522d2(%rip), %rsi     # 0xa5830
callq 0x11030
jmp 0x535d5
jmp 0x53567
cmpl $-0x1, -0x14(%rbp)
jne 0x53592
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x45180
testb $0x1, %al
jne 0x53580
jmp 0x53592
movq -0x48(%rbp), %rdi
leaq 0x522a5(%rip), %rsi     # 0xa5830
callq 0x11030
jmp 0x535d5
cmpl $-0x2, -0x14(%rbp)
jne 0x535bd
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x45180
testb $0x1, %al
jne 0x535ab
jmp 0x535bd
movq -0x48(%rbp), %rdi
leaq 0x5228a(%rip), %rsi     # 0xa5840
callq 0x11030
jmp 0x535d5
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x434d0
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: eryxcc[P]lois/src/relations.cpp
// Function: lois::SubOrder::exists(lois::FormulaQ*, int, std::shared_ptr<lois::Subdomain>&, int, int)
bool exists(FormulaQ* q, int at, std::shared_ptr<Subdomain>& dom, int val, int rid) {
    if(int(position.size()) < val+1) position.resize(val+1);
    for(int i=0; i<=val; i++) {
      position[val] = i;
      if(q->generateAll(at, dom, val, rid+1) != q->type) return !q->type;
      }
    return q->type;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x10, %rdi
callq 0x4a5e0
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x55c20
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x55e80
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jg 0x55c99
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, -0x44(%rbp)
addq $0x10, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x44e60
movl -0x44(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r8d
addl $0x1, %r8d
callq 0x42c70
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movb 0x10(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x55c8c
movq -0x18(%rbp), %rax
movb 0x10(%rax), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x55ca5
jmp 0x55c8e
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x55c27
movq -0x18(%rbp), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
// File: eryxcc[P]lois/src/relations.cpp
// Function: lois::SubOrder::check(int, int, int)
bool check(int id, int val1, int val2) {
    if(val1 == val2) return id == ID_LEQ;
    else {
      int v1 = position[val1], v2 = position[val2];
      for(int k=val1+1; k<=val2; k++) if(position[k] <= v1) v1++;
      for(int k=val2+1; k<=val1; k++) if(position[k] <= v2) v2++;
      if(id == ID_LEQ) return v1 <= v2;
      else return v1 > v2;
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x55ce6
cmpl $0x2, -0x14(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x55db4
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
movslq -0x18(%rbp), %rsi
callq 0x44e60
movq -0x38(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x20(%rbp)
addq $0x10, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x44e60
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x55d51
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
movslq -0x28(%rbp), %rsi
callq 0x44e60
movl (%rax), %eax
cmpl -0x20(%rbp), %eax
jg 0x55d44
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x55d46
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x55d1b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x55d90
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x44e60
movl (%rax), %eax
cmpl -0x24(%rbp), %eax
jg 0x55d83
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x55d85
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x55d5a
cmpl $0x2, -0x14(%rbp)
jne 0x55da6
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
setle %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x55db4
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: eryxcc[P]lois/src/relations.cpp
// Function: lois::SubBinary::exists(lois::FormulaQ*, int, std::shared_ptr<lois::Subdomain>&, int, int)
bool exists(FormulaQ* q, int at, std::shared_ptr<Subdomain>& dom, int val, int rid) {
    if(int(edges.size()) < val+1) edges.resize(val+1);
    
    int tochoose = val;
    
    if(lm == lmPossibleLoops) tochoose ++;
    if(sm == smAsymmetric) tochoose += val;
    
    for(int i=0; i<(1<<tochoose); i++) {
      edges[val] = i;
      if(q->generateAll(at, dom, val, rid+1) != q->type) return !q->type;
      }
    return q->type;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x10, %rdi
callq 0x4a5e0
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x586f0
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x55e80
movq -0x40(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, -0x34(%rbp)
cmpl $0x2, 0x28(%rax)
jne 0x58709
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x40(%rbp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0x5871c
movl -0x2c(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl -0x34(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jge 0x587a0
movq -0x40(%rbp), %rdi
movl -0x38(%rbp), %eax
movl %eax, -0x44(%rbp)
addq $0x10, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x44e60
movl -0x44(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r8d
addl $0x1, %r8d
callq 0x42c70
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movb 0x10(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x58793
movq -0x18(%rbp), %rax
movb 0x10(%rax), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x587ac
jmp 0x58795
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x58723
movq -0x18(%rbp), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)