LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movl 0x28(%rdi), %eax
testl %eax, %eax
jne 0x291fb
movq 0x18(%rbx), %rax
movq %rax, 0x38(%rsp)
movq 0x20(%rbx), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x291cc
movq 0x28e0a(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x291c8
incl 0x8(%rax)
jmp 0x291cc
lock
incl 0x8(%rax)
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x290b2
movl %eax, %ebp
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x291ea
callq 0x133fc
movl $0x4, %eax
testb %bpl, %bpl
je 0x29336
movl 0x28(%rbx), %eax
cmpl $0x1, %eax
jne 0x29252
movq 0x18(%rbx), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rbx), %rax
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x2922c
movq 0x28daa(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x29228
incl 0x8(%rax)
jmp 0x2922c
lock
incl 0x8(%rax)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x290b2
movl %eax, %ebp
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2924a
callq 0x133fc
testb %bpl, %bpl
je 0x29259
movl 0x28(%rbx), %eax
cmpl $0x3, %eax
je 0x29260
jmp 0x292d5
movl $0x3, 0x28(%rbx)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rbx), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x2928c
movq 0x28d4a(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x29288
incl 0x8(%rax)
jmp 0x2928c
lock
incl 0x8(%rax)
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x297dd
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x290b2
movl %eax, %ebp
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x292b9
callq 0x133fc
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x292c8
callq 0x133fc
movl $0x4, %eax
testb %bpl, %bpl
je 0x29336
movl 0x28(%rbx), %eax
cmpl $0x2, %eax
jne 0x29339
movq 0x18(%rbx), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rbx), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x29306
movq 0x28cd0(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x29302
incl 0x8(%rax)
jmp 0x29306
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x290b2
movl %eax, %ebp
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x29324
callq 0x133fc
testb %bpl, %bpl
jne 0x29339
movq %rbx, %rdi
callq 0x29036
movl $0x5, %eax
movl %eax, 0x28(%rbx)
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
jmp 0x2937a
movq %rax, %rbx
movq 0x40(%rsp), %rdi
jmp 0x2937a
movq %rax, %rbx
movq 0x30(%rsp), %rdi
jmp 0x2937a
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x29375
callq 0x133fc
jmp 0x29375
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x29384
callq 0x133fc
movq %rbx, %rdi
callq 0x7430
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %r12
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2a35c
movl %esi, %ebp
leaq 0x268b7(%rip), %rsi     # 0x50be0
leaq 0x269c0(%rip), %rdx     # 0x50cf0
xorl %ebx, %ebx
xorl %ecx, %ecx
callq 0x72b0
testq %rax, %rax
je 0x2a392
movq %rax, %r15
movq 0x8(%r12), %rbx
testq %rbx, %rbx
je 0x2a364
movq 0x27c76(%rip), %rax     # 0x51fc8
cmpb $0x0, (%rax)
je 0x2a360
incl 0x8(%rbx)
jmp 0x2a364
xorl %ebx, %ebx
jmp 0x2a392
lock
incl 0x8(%rbx)
cmpb %bpl, 0x10(%r15)
jne 0x2a392
movq 0x18(%r15), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%r15), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x2a3bb
movq 0x27c40(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2a3b7
incl 0x8(%rax)
jmp 0x2a3bb
movq %r14, %rdi
movq %r12, %rsi
callq 0x2d284
testq %rbx, %rbx
je 0x2a3aa
movq %rbx, %rdi
callq 0x133fc
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
lock
incl 0x8(%rax)
movzbl %bpl, %ebp
leaq 0x10(%rsp), %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x2a306
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2a3dd
callq 0x133fc
movq 0x28(%r15), %rax
movq %rax, (%rsp)
movq 0x30(%r15), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x2a408
movq 0x27bce(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2a404
incl 0x8(%rax)
jmp 0x2a408
lock
incl 0x8(%rax)
movq %rsp, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x2a306
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2a39d
callq 0x133fc
jmp 0x2a39d
movq %rax, %r14
movq 0x8(%rsp), %rdi
jmp 0x2a43f
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2a44e
callq 0x133fc
jmp 0x2a44e
movq %rax, %r14
testq %rbx, %rbx
je 0x2a45b
movq %rbx, %rdi
callq 0x133fc
movq %r14, %rdi
callq 0x7430
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
cmpl $-0x1, %esi
je 0x2b80a
movl %esi, %ebx
movslq %esi, %r12
movq 0x28(%r14), %rax
shlq $0x4, %r12
movq (%rax,%r12), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax,%r12), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x2b826
movq 0x267c8(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2b822
incl 0x8(%rax)
jmp 0x2b826
movq 0x18(%r14), %rdi
movq (%rdi), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x20(%rax)
lock
incl 0x8(%rax)
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2b914
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2b844
callq 0x133fc
movq 0x18(%rsp), %r13
movl (%r13), %eax
subl %eax, 0x26f4d(%rip)     # 0x527a0
js 0x2b8c6
movq %rbx, (%rsp)
movl (%r13), %eax
testl %eax, %eax
jle 0x2b894
movq (%rsp), %rax
leal -0x1(%rax), %r15d
xorl %ebx, %ebx
movq 0x28(%r14), %rax
movq (%rax,%r12), %rax
movl %ebx, 0x44(%rax)
movq %r14, %rdi
movl %r15d, %esi
callq 0x2b7be
movb 0x10(%r14), %bpl
cmpb %al, %bpl
jne 0x2b8ca
incl %ebx
movl (%r13), %eax
cmpl %eax, %ebx
jl 0x2b86b
movq 0x28(%r14), %rcx
movq (%rcx,%r12), %rcx
movl %eax, 0x44(%rcx)
movl (%r13), %ecx
leal 0x1(%rcx), %eax
movl %eax, (%r13)
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
movq (%rsp), %rsi
xorl %r8d, %r8d
callq 0x2ba42
movl %eax, %ebp
decl (%r13)
jmp 0x2b8ce
xorl %ebp, %ebp
jmp 0x2b8ce
xorb $0x1, %bpl
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2b8dd
callq 0x133fc
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b8fa
movq %rax, %rbx
movq 0x10(%rsp), %rdi
jmp 0x2b902
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2b90c
callq 0x133fc
movq %rbx, %rdi
callq 0x7430
// File: /workspace/github_cpp_makefile_star2_O3/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 %ecx, %eax
movq %rdx, %rcx
movl %esi, %edx
movq %rdi, %rsi
movq (%rcx), %r10
movq 0x8(%r10), %rdi
movq 0x10(%r10), %r9
subq %rdi, %r9
shrq $0x4, %r9
cmpl %r8d, %r9d
jg 0x2ba7f
movl (%r10), %r8d
decl %r8d
cmpl %r8d, %eax
cmovgl %eax, %r8d
cmpl %eax, %r8d
je 0x2ba99
incl %eax
testl %r9d, %r9d
jle 0x2ba70
xorl %r8d, %r8d
movslq %r8d, %r9
movq %r9, %r8
shlq $0x4, %r8
movq (%rdi,%r8), %rdi
movq (%rdi), %r8
movq (%r8), %r11
movl %eax, %r8d
jmpq *%r11
decl %edx
movq %rsi, %rdi
movl %edx, %esi
jmp 0x2b7be
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2c3cb
movl 0x263e5(%rip), %eax     # 0x527a4
incl %eax
movl %eax, 0x263dd(%rip)     # 0x527a4
movl %eax, 0x40(%r14)
leaq 0x2651a(%rip), %r15     # 0x528ec
movl (%r15), %eax
movl %eax, %ecx
andl $-0x5, %ecx
cmpl $0x2, %ecx
jne 0x2c3f6
leaq 0x13b6c(%rip), %rsi     # 0x3ff52
movl $0x1, %edx
movq %rbx, %rdi
callq 0x72c0
movl (%r15), %eax
cmpl $0x3, %eax
jne 0x2c40f
leaq 0x13b52(%rip), %rsi     # 0x3ff54
movl $0x4, %edx
movq %rbx, %rdi
callq 0x72c0
leaq 0x48(%r14), %rdi
leaq 0x14252(%rip), %rsi     # 0x4066c
callq 0x70c0
testl %eax, %eax
je 0x2c435
movq 0x48(%r14), %rsi
movq 0x50(%r14), %rdx
movq %rbx, %rdi
callq 0x72c0
jmp 0x2c459
movq 0x263ac(%rip), %rsi     # 0x527e8
movq 0x263ad(%rip), %rdx     # 0x527f0
movq %rbx, %rdi
callq 0x72c0
movl 0x40(%r14), %esi
decl %esi
movq %rbx, %rdi
callq 0x2c342
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26339(%rip), %eax     # 0x527a8
cmpl %eax, 0x18(%rdi)
jge 0x2c4a7
movl %eax, 0x18(%rdi)
movq %rdi, 0x30(%rdi)
addq $0x38, %rdi
leaq 0x8(%rbx), %rsi
callq 0x1615e
movq (%rbx), %rdi
movq 0x26376(%rip), %rax     # 0x52808
movq %rax, 0x20(%rdi)
addq $0x28, %rdi
leaq 0x2636f(%rip), %rsi     # 0x52810
popq %rbx
jmp 0x1615e
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdx), %rdi
testq %rdi, %rdi
je 0x2c50e
movq %rdx, %r14
leaq 0x24700(%rip), %rsi     # 0x50bd0
leaq 0x24599(%rip), %rdx     # 0x50a70
xorl %r13d, %r13d
xorl %ecx, %ecx
callq 0x72b0
testq %rax, %rax
je 0x2c516
movq %rax, %r15
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x2c513
movq 0x25acf(%rip), %rax     # 0x51fc8
cmpb $0x0, (%rax)
je 0x2c52f
incl 0x8(%r14)
movq %r15, 0x18(%rsp)
movq %r14, 0x20(%rsp)
jmp 0x2c547
xorl %r13d, %r13d
jmp 0x2c516
movq %r15, %r13
movq %r13, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movb $0x1, %bpl
xorl %r14d, %r14d
movq %r13, %r15
jmp 0x2c54d
lock
incl 0x8(%r14)
cmpb $0x0, (%rax)
movq %r15, 0x18(%rsp)
movq %r14, 0x20(%rsp)
je 0x2c66a
incl 0x8(%r14)
xorl %ebp, %ebp
leaq 0x18(%rsp), %r13
movq %r13, %rdi
callq 0x2c462
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0x2c568
callq 0x133fc
movq 0x30(%r15), %r13
cmpq %r15, %r13
je 0x2c595
movq %r13, 0x28(%rsp)
movq 0x38(%r15), %rax
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x2c5bd
movq 0x25a3d(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2c5b9
incl 0x8(%rax)
jmp 0x2c5bd
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
testb %bpl, %bpl
jne 0x2c5cf
movq 0x25a1e(%rip), %rax     # 0x51fc8
cmpb $0x0, (%rax)
je 0x2c660
incl 0x8(%r14)
jmp 0x2c5cf
lock
incl 0x8(%rax)
movq (%r12), %rax
movq %rsp, %rdi
leaq 0x28(%rsp), %rdx
movq %r12, %rsi
callq *0x28(%rax)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq 0x38(%r15), %rdi
movq %rax, 0x30(%r15)
movq %rcx, 0x38(%r15)
testq %rdi, %rdi
je 0x2c604
callq 0x133fc
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2c604
callq 0x133fc
cmpq %r15, %r13
je 0x2c618
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2c618
callq 0x133fc
movq 0x30(%r15), %rax
movq %rax, (%rbx)
movq 0x38(%r15), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x2c641
movq 0x25995(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2c63d
incl 0x8(%rax)
jmp 0x2c641
lock
incl 0x8(%rax)
testb %bpl, %bpl
jne 0x2c64e
movq %r14, %rdi
callq 0x133fc
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
lock
incl 0x8(%r14)
jmp 0x2c5cf
lock
incl 0x8(%r14)
jmp 0x2c54b
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2c686
callq 0x133fc
testb %bpl, %bpl
jne 0x2c693
movq %r14, %rdi
callq 0x133fc
movq %rbx, %rdi
callq 0x7430
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rdi
testq %rdi, %rdi
je 0x2ca25
movq %rdx, %r15
leaq 0x241e5(%rip), %rsi     # 0x50bd0
leaq 0x2407e(%rip), %rdx     # 0x50a70
xorl %ecx, %ecx
callq 0x72b0
testq %rax, %rax
je 0x2ca25
movq %rax, (%rsp)
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rsp)
testq %rcx, %rcx
je 0x2ca4b
movq 0x255b1(%rip), %rdx     # 0x51fc8
cmpb $0x0, (%rdx)
je 0x2cb9a
incl 0x8(%rcx)
jmp 0x2ca4b
movq $0x0, 0x8(%rsp)
movq 0x18(%r14), %rax
leaq 0x8(%rsp), %r15
movq %rax, -0x8(%r15)
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x1615e
movq -0x8(%r15), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x2ca74
movq 0x25562(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2ca70
incl 0x8(%rax)
jmp 0x2ca74
lock
incl 0x8(%rax)
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x2c462
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x2ca8f
callq 0x133fc
movq (%rsp), %r15
movq 0x30(%r15), %r12
cmpq %r15, %r12
je 0x2cac0
movq %r12, 0x28(%rsp)
movq 0x38(%r15), %rax
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x2caed
movq 0x25512(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2cae9
incl 0x8(%rax)
jmp 0x2caed
movq %r15, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x2cb00
movq 0x254ed(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2cbb0
incl 0x8(%rax)
jmp 0x2cb00
lock
incl 0x8(%rax)
movq (%r14), %rax
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
callq *0x28(%rax)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x38(%rax), %rdi
movq %rcx, 0x30(%rax)
movq %rdx, 0x38(%rax)
testq %rdi, %rdi
je 0x2cb3b
callq 0x133fc
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2cb3b
callq 0x133fc
cmpq %r15, %r12
je 0x2cb4f
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2cb4f
callq 0x133fc
movq (%rsp), %rax
movq 0x30(%rax), %rcx
movq %rcx, (%rbx)
movq 0x38(%rax), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x2cb7c
movq 0x2545a(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2cb78
incl 0x8(%rax)
jmp 0x2cb7c
lock
incl 0x8(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2cb8b
callq 0x133fc
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
lock
incl 0x8(%rcx)
movq (%rsp), %rax
testq %rax, %rax
jne 0x2ca4b
jmp 0x2ca2e
lock
incl 0x8(%rax)
jmp 0x2cb00
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2cbcb
callq 0x133fc
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2cbda
callq 0x133fc
movq %rbx, %rdi
callq 0x7430
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq (%rsi), %rsi
movq %rsi, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x2cc73
movq 0x25363(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2cc6f
incl 0x8(%rax)
jmp 0x2cc73
lock
incl 0x8(%rax)
movq (%rsi), %rax
movq %rsp, %rdi
leaq 0x10(%rsp), %rdx
callq *0x28(%rax)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2cc90
callq 0x133fc
movq (%rsp), %rcx
cmpq 0x25af5(%rip), %rcx     # 0x52790
je 0x2cd0c
movq 0x20(%rcx), %rdx
testq %rdx, %rdx
jne 0x2cd03
movl $0x38, %edi
callq 0x7270
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x242c3(%rip), %rcx     # 0x50f88
movq %rcx, (%rax)
movq %rax, %rdx
addq $0x10, %rdx
movl $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movq (%rsp), %rcx
movq %rdx, 0x20(%rcx)
movq 0x28(%rcx), %rdi
movq %rax, 0x28(%rcx)
testq %rdi, %rdi
je 0x2cd03
callq 0x133fc
movq (%rsp), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, (%rbx)
movq 0x28(%rcx), %rax
jmp 0x2cd1d
movq 0x25af5(%rip), %rax     # 0x52808
movq %rax, (%rbx)
movq 0x25af3(%rip), %rax     # 0x52810
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x2cd3b
movq 0x2529b(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2cd37
incl 0x8(%rax)
jmp 0x2cd3b
lock
incl 0x8(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2cd4a
callq 0x133fc
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x2cd65
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2cd6f
callq 0x133fc
movq %rbx, %rdi
callq 0x7430
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
movq (%rsi), %rsi
movq %rsi, 0x38(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x2cdb2
movq 0x25224(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2cdae
incl 0x8(%rax)
jmp 0x2cdb2
lock
incl 0x8(%rax)
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq *0x28(%rax)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2cdd1
callq 0x133fc
movq (%r14), %rsi
movq %rsi, 0x18(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x2cdfc
movq 0x251da(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2cdf8
incl 0x8(%rax)
jmp 0x2cdfc
lock
incl 0x8(%rax)
movq (%rsi), %rax
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq *0x28(%rax)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2ce1b
callq 0x133fc
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdi
movq 0x30(%rsi), %rax
cmpq 0x30(%rdi), %rax
je 0x2ce5c
movq %rax, 0x30(%rdi)
addq $0x38, %rdi
addq $0x38, %rsi
callq 0x1615e
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq 0x28(%rsp), %rsi
addq $0x20, %rsi
callq 0x2c903
movq 0x8(%rsp), %rsi
movq 0x20(%rsi), %rcx
testq %rcx, %rcx
jne 0x2cec4
movl $0x38, %edi
callq 0x7270
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x24104(%rip), %rcx     # 0x50f88
movq %rcx, (%rax)
movq %rax, %rcx
addq $0x10, %rcx
movl $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movq 0x8(%rsp), %rsi
movq %rcx, 0x20(%rsi)
movq 0x28(%rsi), %rdi
movq %rax, 0x28(%rsi)
testq %rdi, %rdi
je 0x2cec4
callq 0x133fc
movq 0x8(%rsp), %rsi
movq 0x20(%rsi), %rcx
movq %rcx, (%rbx)
movq 0x28(%rsi), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x2cee9
movq 0x250ed(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2cee5
incl 0x8(%rax)
jmp 0x2cee9
lock
incl 0x8(%rax)
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2cef8
callq 0x133fc
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2cf07
callq 0x133fc
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x2cf14
movq %rax, %rbx
movq 0x30(%rsp), %rdi
jmp 0x2cf26
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2cf30
callq 0x133fc
movq 0x10(%rsp), %rdi
jmp 0x2cf3f
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2cf49
callq 0x133fc
movq %rbx, %rdi
callq 0x7430
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2cc3d
leaq 0x30(%r14), %rbx
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x2cc3d
movq (%rsp), %r15
movq 0x10(%rsp), %r12
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2cf96
callq 0x133fc
cmpq %r12, %r15
jne 0x2cff9
movq 0x8(%r15), %rax
movq 0x10(%r14), %rcx
movq (%rax), %r15
addq $0x10, %rax
cmpq %rcx, 0x8(%r15)
jne 0x2cfa3
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
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2cfea
callq 0x133fc
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x7150
leaq 0x23bf6(%rip), %rcx     # 0x50c00
movq %rcx, (%rax)
leaq 0x239fc(%rip), %rsi     # 0x50a10
movq 0x24fc5(%rip), %rdx     # 0x51fe0
movq %rax, %rdi
callq 0x7400
jmp 0x2d027
jmp 0x2d027
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2d039
callq 0x133fc
movq %rbx, %rdi
callq 0x7430
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2ddd3
cmpl $0x0, 0xc(%rsi)
je 0x2dde6
movq (%rsi), %rax
movq %rbx, %rdi
callq *0x58(%rax)
jmp 0x2de15
movq 0x249d6(%rip), %rax     # 0x527b0
movq %rax, (%rbx)
movq 0x249d4(%rip), %rax     # 0x527b8
jmp 0x2ddf7
movq 0x249d3(%rip), %rax     # 0x527c0
movq %rax, (%rbx)
movq 0x249d1(%rip), %rax     # 0x527c8
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x2de15
movq 0x241c1(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2de11
incl 0x8(%rax)
jmp 0x2de15
lock
incl 0x8(%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f214
testb %cl, %cl
jne 0x2f21a
xorl %eax, %eax
jmp 0x2f224
movb $0x1, %al
testb %cl, %cl
jne 0x2f224
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_O3/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 %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq (%rsi), %rax
cmpq 0x38(%rdi), %rax
je 0x2f28f
movq %rsi, %rbx
movq %rax, 0x38(%r14)
leaq 0x40(%r14), %rdi
addq $0x8, %rsi
callq 0x1615e
movl $0x0, 0x48(%r14)
movq 0x18(%r14), %rdi
movq (%rbx), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x2f29f
movq 0x22d43(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2f29b
incl 0x8(%rax)
jmp 0x2f29f
addq $0x48, %r14
movq %r14, %r15
jmp 0x2f31b
lock
incl 0x8(%rax)
movq (%rdi), %rax
leaq 0x18(%rsp), %rsi
callq *0x28(%rax)
movl %eax, %ebp
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2f2bb
callq 0x133fc
leaq 0x48(%r14), %r15
testb %bpl, %bpl
je 0x2f2c8
orb $0x1, (%r15)
movq 0x28(%r14), %rdi
movq (%rbx), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x2f2f7
movq 0x22cdf(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2f2f3
incl 0x8(%rax)
jmp 0x2f2f7
lock
incl 0x8(%rax)
movq (%rdi), %rax
leaq 0x8(%rsp), %rsi
callq *0x28(%rax)
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2f313
callq 0x133fc
testb %bl, %bl
je 0x2f31b
orb $0x2, (%r15)
cmpl $0x0, (%r15)
setne %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
jmp 0x2f33f
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2f349
callq 0x133fc
movq %rbx, %rdi
callq 0x7430
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
leaq 0x21449(%rip), %rax     # 0x50e40
movq %rax, (%rdi)
movb %sil, 0x10(%rdi)
movq (%rdx), %rax
movq %rax, 0x18(%rdi)
movq 0x8(%rdx), %rax
movq %rax, 0x20(%rdi)
testq %rax, %rax
je 0x2fa27
movq 0x225af(%rip), %rdx     # 0x51fc8
cmpb $0x0, (%rdx)
je 0x2fa23
incl 0x8(%rax)
jmp 0x2fa27
lock
incl 0x8(%rax)
movq (%rcx), %rax
movq %rax, 0x28(%rdi)
movq 0x8(%rcx), %rax
movq %rax, 0x30(%rdi)
testq %rax, %rax
je 0x2fa4f
movq 0x22586(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x2fa4b
incl 0x8(%rax)
retq
lock
incl 0x8(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
leaq 0x20809(%rip), %rax     # 0x50f00
movq %rax, (%rdi)
movl %edx, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movq (%rcx), %rax
movq %rax, 0x20(%rdi)
movq 0x8(%rcx), %rax
movq %rax, 0x28(%rdi)
testq %rax, %rax
je 0x3072a
movq 0x218ac(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x30726
incl 0x8(%rax)
jmp 0x3072a
lock
incl 0x8(%rax)
movq (%r8), %rax
movq %rax, 0x30(%rdi)
movq 0x8(%r8), %rax
movq %rax, 0x38(%rdi)
testq %rax, %rax
je 0x30752
movq 0x21883(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x3074e
incl 0x8(%rax)
retq
lock
incl 0x8(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2cc3d
leaq 0x30(%rbx), %r14
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x2cc3d
movq (%rsp), %r15
movq 0x10(%rsp), %r12
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x308b4
callq 0x133fc
cmpq %r12, %r15
jne 0x3091d
movq 0x8(%r15), %rax
movq 0x18(%rbx), %rcx
movq (%rax), %r15
addq $0x10, %rax
cmpq %rcx, 0x8(%r15)
jne 0x308c1
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)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3090e
callq 0x133fc
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x7150
leaq 0x202d2(%rip), %rcx     # 0x50c00
movq %rcx, (%rax)
leaq 0x200d8(%rip), %rsi     # 0x50a10
movq 0x216a1(%rip), %rdx     # 0x51fe0
movq %rax, %rdi
callq 0x7400
jmp 0x3094b
jmp 0x3094b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3095d
callq 0x133fc
movq %rbx, %rdi
callq 0x7430
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x31c6a
movb 0x18(%r12), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
movl %eax, %ecx
andl %ebp, %ecx
je 0x31c9b
cmpl %eax, %ecx
je 0x31c83
cmpl $-0x2, %ebp
je 0x31c8c
cmpl $-0x1, %ebp
jne 0x31cc6
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d325
testb %al, %al
je 0x31cc6
leaq 0x20b26(%rip), %rax     # 0x527b0
jmp 0x31ca2
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d325
testb %al, %al
je 0x31cc6
leaq 0x20b1e(%rip), %rax     # 0x527c0
movq (%rax), %rcx
movq %rcx, (%rbx)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x31cdf
movq 0x2030c(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x31cdb
incl 0x8(%rax)
jmp 0x31cdf
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x2c230
jmp 0x31cdf
lock
incl 0x8(%rax)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x8(%rsp)
movl %r8d, %r14d
movq %rcx, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r12
leaq 0x10(%rdi), %r13
movq 0x18(%rdi), %rax
subq 0x10(%rdi), %rax
shrq $0x2, %rax
cmpl %r8d, %eax
jg 0x33806
leal 0x1(%r14), %eax
movslq %eax, %rsi
movq %r13, %rdi
callq 0x33940
testl %r14d, %r14d
js 0x3384c
movl %r14d, %r15d
incl 0x8(%rsp)
leal 0x1(%r14), %ebp
xorl %ebx, %ebx
movq (%r13), %rax
movl %ebx, (%rax,%r15,4)
movq %r12, %rdi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
movl %r14d, %ecx
movl 0x8(%rsp), %r8d
callq 0x2ba42
movl %eax, %ecx
movb 0x10(%r12), %al
cmpb %cl, %al
jne 0x33853
incl %ebx
cmpl %ebx, %ebp
jne 0x33818
jmp 0x33855
movb 0x10(%r12), %al
jmp 0x33855
xorb $0x1, %al
andb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl %ecx, %edx
jne 0x33871
cmpl $0x2, %esi
sete %al
retq
pushq %rbx
movslq %edx, %rax
movq 0x10(%rdi), %rdi
movl (%rdi,%rax,4), %r10d
movslq %ecx, %r9
jge 0x338a5
movq %rax, %r11
xorl %r8d, %r8d
cmpl %r10d, 0x4(%rdi,%r11,4)
leaq 0x1(%r11), %rbx
setle %r8b
addl %r10d, %r8d
movq %rbx, %r11
movl %r8d, %r10d
cmpq %rbx, %r9
jne 0x33885
jmp 0x338a8
movl %r10d, %r8d
movl (%rdi,%r9,4), %r10d
cmpl %edx, %ecx
jge 0x338ce
xorl %ecx, %ecx
cmpl %r10d, 0x4(%rdi,%r9,4)
leaq 0x1(%r9), %rdx
setle %cl
addl %r10d, %ecx
movq %rdx, %r9
movl %ecx, %r10d
cmpq %rdx, %rax
jne 0x338b0
jmp 0x338d1
movl %r10d, %ecx
cmpl $0x2, %esi
sete %dl
cmpl %ecx, %r8d
setg %al
xorb %dl, %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x8(%rsp)
movl %r8d, %r14d
movq %rcx, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r12
movq %rdi, %r15
movq 0x18(%rdi), %rax
subq 0x10(%rdi), %rax
leaq 0x10(%rdi), %r13
shrq $0x2, %rax
leal 0x1(%r14), %ebx
cmpl %r8d, %eax
jg 0x33ec9
movslq %ebx, %rsi
movq %r13, %rdi
callq 0x33940
cmpl $0x2, 0x28(%r15)
cmovnel %r14d, %ebx
xorl %ebp, %ebp
cmpl $0x1, 0x2c(%r15)
movl $0x0, %ecx
cmovel %r14d, %ecx
addl %ebx, %ecx
cmpl $0x1f, %ecx
jne 0x33ef0
movb 0x10(%r12), %al
jmp 0x33f36
movl $0x1, %r15d
shll %cl, %r15d
movslq %r14d, %rbx
incl 0x8(%rsp)
movq (%r13), %rax
movl %ebp, (%rax,%rbx,4)
movq %r12, %rdi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
movl %r14d, %ecx
movl 0x8(%rsp), %r8d
callq 0x2ba42
movl %eax, %ecx
movb 0x10(%r12), %al
cmpb %cl, %al
jne 0x33f34
incl %ebp
cmpl %ebp, %r15d
jne 0x33f00
jmp 0x33f36
xorb $0x1, %al
andb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/relations.cpp
// Function: lois::SubBinary::check(int, int, int)
bool check(int id, int val1, int val2) {
    // printf("val1=%d val2=%d\n", val1, val2);
    if(val1 == val2) {
      if(lm == lmNoLoops) return id == ID_NOBINARY;
      if(lm == lmAllLoops) return id == ID_BINARY;
      }
    if(val1 > val2) {
      std::swap(val1, val2);
      if(sm == smAsymmetric) { val1 += val2; if(lm == lmPossibleLoops) val1++; }
      if(sm == smAntisymmetric) id ^= (ID_NOBINARY ^ ID_BINARY);
      }
      
    // printf("-> val1=%d val2=%d\n", val1, val2);
    bool b = edges[val2] & (1<<val1);
    if(id == ID_NOBINARY) return !b;
    return b;
    }

// Assembly:
cmpl %ecx, %edx
jne 0x33f5d
movl 0x28(%rdi), %eax
cmpl $0x1, %eax
je 0x33fa8
testl %eax, %eax
jne 0x33f5d
cmpl $0x2, %esi
jmp 0x33fab
cmpl %ecx, %edx
jle 0x33f8b
movl 0x2c(%rdi), %eax
cmpl $0x1, %eax
jne 0x33f79
addl %edx, %ecx
xorl %r8d, %r8d
cmpl $0x2, 0x28(%rdi)
sete %r8b
addl %r8d, %ecx
movl %esi, %r8d
xorl $0x3, %r8d
cmpl $0x2, %eax
cmovel %r8d, %esi
movl %ecx, %eax
jmp 0x33f8f
movl %edx, %eax
movl %ecx, %edx
movslq %edx, %rcx
movq 0x10(%rdi), %rdx
movl (%rdx,%rcx,4), %ecx
btl %eax, %ecx
setb %cl
cmpl $0x2, %esi
sete %al
xorb %cl, %al
retq
cmpl $0x1, %esi
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/relations.cpp
// Function: lois::SubUnary::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(groups.size() < val+1) groups.resize(val+1);
    
    for(int i=0; i<nogroups; i++) {
      groups[val] = i;
      if(q->generateAll(at, dom, val, rid+1) != q->type) return !q->type;
      }
    return q->type;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x8(%rsp)
movl %r8d, %r14d
movq %rcx, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r12
movq %rdi, %r13
leaq 0x10(%rdi), %r15
movq 0x18(%rdi), %rax
subq 0x10(%rdi), %rax
sarq $0x2, %rax
leal 0x1(%r14), %ecx
movslq %ecx, %rsi
cmpq %rsi, %rax
jae 0x34073
movq %r15, %rdi
callq 0x33940
cmpl $0x0, 0x28(%r13)
jle 0x340b7
movslq %r14d, %rbp
incl 0x8(%rsp)
xorl %ebx, %ebx
movq (%r15), %rax
movl %ebx, (%rax,%rbp,4)
movq %r12, %rdi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
movl %r14d, %ecx
movl 0x8(%rsp), %r8d
callq 0x2ba42
movl %eax, %ecx
movb 0x10(%r12), %al
cmpb %cl, %al
jne 0x340be
incl %ebx
cmpl 0x28(%r13), %ebx
jl 0x34083
jmp 0x340c0
movb 0x10(%r12), %al
jmp 0x340c0
xorb $0x1, %al
andb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/relations.cpp
// Function: lois::SubUnary::check(int, int, int)
bool check(int id, int val1, int val2) {
  if(id == ID_UN_EQ) return groups[val1] == groups[val2];
  if(id == ID_UN_NEQ) return groups[val1] != groups[val2];
  // printf("val1=%d val2=%d\n", val1, val2);
  if(val1 != val2) throw loisexception();
  return ((1<<groups[val1]) & id);
  }

// Assembly:
cmpl $-0x2, %esi
je 0x340f0
cmpl $-0x1, %esi
jne 0x34104
movslq %edx, %rax
movq 0x10(%rdi), %rdx
movl (%rdx,%rax,4), %eax
movslq %ecx, %rcx
cmpl (%rdx,%rcx,4), %eax
sete %al
retq
movslq %edx, %rax
movq 0x10(%rdi), %rdx
movl (%rdx,%rax,4), %eax
movslq %ecx, %rcx
cmpl (%rdx,%rcx,4), %eax
setne %al
retq
cmpl %ecx, %edx
jne 0x34119
movslq %edx, %rax
movq 0x10(%rdi), %rcx
movl (%rcx,%rax,4), %eax
btl %eax, %esi
setb %al
retq
pushq %rax
movl $0x8, %edi
callq 0x7150
leaq 0x1d12d(%rip), %rcx     # 0x51258
movq %rcx, (%rax)
leaq 0x1c193(%rip), %rsi     # 0x502c8
movq 0x1dea4(%rip), %rdx     # 0x51fe0
movq %rax, %rdi
callq 0x7400
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/relations.cpp
// Function: lois::SubRelTree::check(int, int, int)
bool check(int id, int val1, int val2) {
    while(true) {
      if(val2 == -1) return id == ID_NOT_ANCESTOR_OR_EQUAL;
      if(val2 == val1) return id == ID_ANCESTOR_OR_EQUAL;
      val2 = parent[val2];
      }
    }

// Assembly:
movl $0x2, %eax
cmpl $-0x1, %ecx
je 0x343b8
movq 0x10(%rdi), %rdi
cmpl %edx, %ecx
je 0x343b3
movslq %ecx, %rcx
movl (%rdi,%rcx,4), %ecx
cmpl $-0x1, %ecx
jne 0x343a2
jmp 0x343b8
movl $0x1, %eax
cmpl %esi, %eax
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/relations.cpp
// Function: lois::SubRelTree::checkterm(int, int, int)
int checkterm(int id, int val1, int val2) { 
    int l1 = 0; int up1 = val1;
    while(up1 != -1) up1 = parent[up1], l1++;

    int l2 = 0; int up2 = val2;
    while(up2 != -1) up2 = parent[up2], l2++;
    
    up1 = val1; up2 = val2;
    while(l2 > l1) l2--, up2 = parent[up2];
    while(l1 > l2) l1--, up1 = parent[up1];
    
    while(up1 != up2) up1 = parent[up1], up2 = parent[up2];

    return up1;
    }

// Assembly:
movl %edx, %eax
xorl %esi, %esi
movl $0x0, %edx
cmpl $-0x1, %eax
je 0x343e4
movq 0x10(%rdi), %r8
xorl %edx, %edx
movl %eax, %r9d
movslq %r9d, %r9
movl (%r8,%r9,4), %r9d
incl %edx
cmpl $-0x1, %r9d
jne 0x343d5
cmpl $-0x1, %ecx
je 0x34424
movq 0x10(%rdi), %rsi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl %ecx, %r9d
movslq %r9d, %r9
movl (%rsi,%r9,4), %r9d
incl %r8d
cmpl $-0x1, %r9d
jne 0x343f6
leal 0x1(%r8), %esi
cmpl %edx, %r8d
jl 0x34429
movq 0x10(%rdi), %r8
decl %esi
movslq %ecx, %rcx
movl (%r8,%rcx,4), %ecx
cmpl %edx, %esi
jg 0x34413
movl %edx, %esi
jmp 0x34429
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl %esi, %edx
jle 0x3443d
movq 0x10(%rdi), %r8
decl %edx
cltq
movl (%r8,%rax,4), %eax
cmpl %esi, %edx
jg 0x34431
cmpl %ecx, %eax
jne 0x34444
movl %ecx, %eax
retq
movq 0x10(%rdi), %rdx
cltq
movl (%rdx,%rax,4), %eax
movslq %ecx, %rcx
movl (%rdx,%rcx,4), %ecx
cmpl %ecx, %eax
jne 0x34448
retq
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/solvers.cpp
// Function: lois::smtsort[abi:cxx11]()
std::string smtsort() {
  if(smtLogic == "LRA" || smtLogic == "NRA")
    return "Real";
  if(smtLogic == "LIA" || smtLogic == "NIA")
    return "Int";
  throw other_exception("logic unknown to LOIS");
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x1e177(%rip), %rdi     # 0x52888
leaq 0xbe79(%rip), %rsi      # 0x40591
callq 0x70c0
testl %eax, %eax
je 0x3477d
leaq 0x1e160(%rip), %rdi     # 0x52888
leaq 0xbe66(%rip), %rsi      # 0x40595
callq 0x70c0
testl %eax, %eax
je 0x3477d
leaq 0x1e149(%rip), %rdi     # 0x52888
leaq 0xbe53(%rip), %rsi      # 0x40599
callq 0x70c0
testl %eax, %eax
je 0x34766
leaq 0x1e132(%rip), %rdi     # 0x52888
leaq 0xbe40(%rip), %rsi      # 0x4059d
callq 0x70c0
testl %eax, %eax
jne 0x347a8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xbfea(%rip), %rsi      # 0x4075e
leaq 0xbfe6(%rip), %rdx      # 0x40761
jmp 0x34792
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xbfb9(%rip), %rsi      # 0x40744
leaq 0xbfb6(%rip), %rdx      # 0x40748
movq %rbx, %rdi
callq 0x1c74a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x7150
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xbddc(%rip), %rsi      # 0x405a1
leaq 0xbdea(%rip), %rdx      # 0x405b6
leaq 0x8(%rsp), %rdi
callq 0x1c74a
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3514c
xorl %ebp, %ebp
leaq 0x1cdb1(%rip), %rsi     # 0x515a0
leaq 0x9a0(%rip), %rdx       # 0x35196
movq %rbx, %rdi
callq 0x7400
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x34818
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7280
testb %bpl, %bpl
jne 0x34822
jmp 0x3482a
movq %rax, %r14
movq %rbx, %rdi
callq 0x71b0
movq %r14, %rdi
callq 0x7430
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/solvers.cpp
// Function: lois::spassescape[abi:cxx11](lois::symbol)
std::string spassescape(symbol tt) {
  std::string res;
  std::string t = tt.asString();
  for(int i=0; i<int(t.size()); i++)
    if(isalpha(t[i]))
      res += t[i];
    else {
      int v = t[i];
      res += "_";
      if(v<0) res += 'N', v = -v;
      while(v>0) { res += 'a' + (v%26); v /= 26; }
      res += "_";
      }
  return res;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *(%rax)
cmpl $0x0, 0x10(%rsp)
jle 0x350dc
xorl %r12d, %r12d
leaq 0xb58c(%rip), %r14      # 0x405d6
movq 0x8(%rsp), %rax
movsbl (%rax,%r12), %ebp
movl %ebp, %edi
callq 0x73a0
testl %eax, %eax
je 0x3506b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7220
jmp 0x350cb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7450
testb %bpl, %bpl
jns 0x3508a
movq %rbx, %rdi
movl $0x4e, %esi
callq 0x7220
negl %ebp
testl %ebp, %ebp
jle 0x350c0
movl %ebp, %eax
imulq $0x4ec4ec4f, %rax, %r13 # imm = 0x4EC4EC4F
shrq $0x23, %r13
leal (%r13,%r13,4), %eax
leal (%rax,%rax,4), %eax
addl %r13d, %eax
movl %ebp, %ecx
subl %eax, %ecx
addb $0x61, %cl
movzbl %cl, %esi
movq %rbx, %rdi
callq 0x7220
cmpl $0x19, %ebp
movl %r13d, %ebp
ja 0x3508e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7450
incq %r12
movslq 0x10(%rsp), %rax
cmpq %rax, %r12
jl 0x3504a
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x350f7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7280
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x35130
jmp 0x35112
jmp 0x35112
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35130
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7280
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x35143
movq (%r15), %rsi
incq %rsi
callq 0x7280
movq %r14, %rdi
callq 0x7430
nop
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/solvers.cpp
// Function: lois::SolverExhaustive::solve(lois::rbool)
virtual int solve(rbool phi) {
    if(notForInternalSolver(phi)) return 1;
    checkid++;
    phi->initDomains();
    triesleft = tries;
    // std::cout << "{exhaustive solving " << phi << "} ";
    try {
      bool b = phi->verify();
      if(triesleft > 0) {
        if(verbose) printf("answer: %d (%d values tried)\n", b, tries-triesleft);
        return b ? 2 : 0;
        }
      }
    catch(unsolvable_exception) {
      if(verbose) printf("unable to verify\n");
      return 1;
      }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x359c3
movq 0x1c613(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x359bf
incl 0x8(%rax)
jmp 0x359c3
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x34458
movl %eax, %r15d
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x359df
callq 0x133fc
movl $0x1, %ebp
testb %r15b, %r15b
jne 0x35a38
leaq 0x1cdb8(%rip), %rax     # 0x527a8
incl (%rax)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movl 0x8(%rbx), %eax
leaq 0x1cd9b(%rip), %r15     # 0x527a0
movl %eax, (%r15)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl (%r15), %ecx
testl %ecx, %ecx
jle 0x35a38
cmpb $0x1, 0xc(%rbx)
movzbl %al, %ebp
jne 0x35a36
movl 0x8(%rbx), %edx
subl %ecx, %edx
leaq 0xabab(%rip), %rdi      # 0x405d8
movl %ebp, %esi
xorl %eax, %eax
callq 0x7050
addl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x35a6e
movq %r14, %rdi
movl %edx, %esi
movq %rbx, %rdx
callq 0x7621
jmp 0x35a38
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x35a6e
callq 0x133fc
movq %r14, %rdi
callq 0x7430