LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/../include/lois.h
// Function: lois::RelOrder::displaytermbin(std::ostream&, lois::TermBinary const*)
std::ostream& displaytermbin(std::ostream& os, const TermBinary* t) {
    int id = t->op;
    if(outlan == SPASS) {
      if(id == ID_MIN) return os << spassescape(opmin) << "(" << t->left << ", " << t->left << ")";
      if(id == ID_MAX) return os << spassescape(opmax) << "(" << t->right << ", " << t->right << ")";
      }
    return os << "(" << t->left << (id==ID_MIN?opmin:opmax) << t->right << ")";
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x18(%rdx), %ebp
leaq 0x236fb(%rip), %rax     # 0x498ec
cmpl $0x3, (%rax)
jne 0x2628f
cmpl $0x5, %ebp
je 0x26313
cmpl $0x4, %ebp
jne 0x2628f
addq $0x38, %r15
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf5d8
movq %rsp, %rdi
movq %r12, %rsi
callq 0x2865a
movq %rsp, %rsi
movq %r14, %rdi
callq 0x7210
leaq 0xbcb7(%rip), %rsi      # 0x31ef4
movq %rax, %rdi
callq 0x7230
addq $0x20, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd05a
leaq 0xc782(%rip), %rsi      # 0x329dd
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd05a
leaq 0xc43d(%rip), %rsi      # 0x326b2
movq %rax, %rdi
callq 0x7230
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7478
leaq 0x48(%rsp), %rdi
jmp 0x262fe
leaq 0xbc5e(%rip), %rsi      # 0x31ef4
movq %r14, %rdi
callq 0x7230
leaq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0xd05a
movq %rax, %r14
xorl %eax, %eax
cmpl $0x4, %ebp
sete %al
shll $0x4, %eax
leaq (%r15,%rax), %rsi
addq $0x28, %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xf5d8
movq %r14, %rdi
movq %r15, %rsi
callq 0x155f5
addq $0x30, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd05a
leaq 0xc3c4(%rip), %rsi      # 0x326b2
movq %rax, %rdi
callq 0x7230
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xefce
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq $0x28, %r15
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf5d8
movq %rsp, %rdi
movq %r12, %rsi
callq 0x2865a
movq %rsp, %rsi
movq %r14, %rdi
callq 0x7210
leaq 0xbbb0(%rip), %rsi      # 0x31ef4
movq %rax, %rdi
callq 0x7230
addq $0x30, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd05a
leaq 0xc67b(%rip), %rsi      # 0x329dd
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd05a
leaq 0xc336(%rip), %rsi      # 0x326b2
movq %rax, %rdi
callq 0x7230
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7478
leaq 0x38(%rsp), %rdi
jmp 0x262fe
movq %rax, %rbx
jmp 0x263ae
movq %rax, %rbx
jmp 0x263c0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7478
leaq 0x38(%rsp), %rdi
jmp 0x263cf
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7478
leaq 0x48(%rsp), %rdi
jmp 0x263cf
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/../include/lois.h
// Function: lois::RelBinary::display(std::ostream&, int, lois::term const&, lois::term const&)
std::ostream& display(std::ostream& os, int id, const term& t1, const term& t2) {
    if(outlan == SPASS) {
      if(id == ID_BINARY) return os << spassescape(opinrel) << "(" << t1 << ", " << t2 << ")";
      if(id == ID_LEQ) return os << "not(" << spassescape(opinrel) << "(" << t1 << ", " << t2 << "))";
      }
    return os << t1 << (id == ID_BINARY ? opinrel : opnotinrel) << t2;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r15
leaq 0x23345(%rip), %rax     # 0x498ec
cmpl $0x3, (%rax)
jne 0x26647
cmpl $0x2, %ebp
je 0x266aa
cmpl $0x1, %ebp
jne 0x26647
addq $0x8, %r15
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xf5d8
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x2865a
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x7210
leaq 0xb8fd(%rip), %rsi      # 0x31ef4
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
movq %r14, %rsi
callq 0xd05a
leaq 0xc3cc(%rip), %rsi      # 0x329dd
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd05a
leaq 0xc087(%rip), %rsi      # 0x326b2
movq %rax, %rdi
callq 0x7230
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7478
leaq 0x50(%rsp), %rdi
jmp 0x26693
movq %r12, %rdi
movq %r14, %rsi
callq 0xd05a
movq %rax, %r14
xorl %eax, %eax
cmpl $0x1, %ebp
setne %al
shll $0x4, %eax
leaq (%r15,%rax), %rsi
addq $0x8, %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xf5d8
movq %r14, %rdi
movq %r15, %rsi
callq 0x155f5
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd05a
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xefce
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc448(%rip), %rsi      # 0x32af9
movq %r12, %rdi
callq 0x7230
movq %rax, %r12
addq $0x8, %r15
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xf5d8
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x2865a
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x7210
leaq 0xb803(%rip), %rsi      # 0x31ef4
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
movq %r14, %rsi
callq 0xd05a
leaq 0xc2d2(%rip), %rsi      # 0x329dd
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd05a
leaq 0xb864(%rip), %rsi      # 0x31f89
movq %rax, %rdi
callq 0x7230
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7478
leaq 0x40(%rsp), %rdi
jmp 0x26693
movq %rax, %rbx
jmp 0x2675b
movq %rax, %rbx
jmp 0x2676f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7478
leaq 0x40(%rsp), %rdi
jmp 0x2677e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7478
leaq 0x50(%rsp), %rdi
jmp 0x2677e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/../include/lois.h
// Function: lois::RelTree::display(std::ostream&, int, lois::term const&, lois::term const&)
std::ostream& display(std::ostream& os, int id, const term& t1, const term& t2) {
    if(outlan == SPASS) {
      if(id == ID_ANCESTOR_OR_EQUAL) return os << spassescape(opanceq) << "(" << t1 << ", " << t2 << ")";
      if(id == ID_NOT_ANCESTOR_OR_EQUAL) return os << "not(" << spassescape(opanceq) << "(" << t1 << ", " << t2 << "))";
      }
    return os << t1 << (id == ID_ANCESTOR_OR_EQUAL ? opanceq : opanceq) << t2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x22ff8(%rip), %rax     # 0x498ec
cmpl $0x3, (%rax)
jne 0x2698a
cmpl $0x2, %edx
je 0x269e0
cmpl $0x1, %edx
jne 0x2698a
addq $0x8, %r15
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xf5d8
movq %rsp, %rdi
movq %r13, %rsi
callq 0x2865a
movq %rsp, %rsi
movq %r12, %rdi
callq 0x7210
leaq 0xb5b8(%rip), %rsi      # 0x31ef4
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
movq %r14, %rsi
callq 0xd05a
leaq 0xc087(%rip), %rsi      # 0x329dd
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd05a
leaq 0xbd42(%rip), %rsi      # 0x326b2
movq %rax, %rdi
callq 0x7230
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7478
leaq 0x48(%rsp), %rdi
jmp 0x269ca
movq %r12, %rdi
movq %r14, %rsi
callq 0xd05a
movq %rax, %r14
addq $0x8, %r15
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf5d8
movq %r14, %rdi
movq %r12, %rsi
callq 0x155f5
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd05a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xefce
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xc112(%rip), %rsi      # 0x32af9
movq %r12, %rdi
callq 0x7230
movq %rax, %r12
addq $0x8, %r15
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xf5d8
movq %rsp, %rdi
movq %r13, %rsi
callq 0x2865a
movq %rsp, %rsi
movq %r12, %rdi
callq 0x7210
leaq 0xb4d1(%rip), %rsi      # 0x31ef4
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
movq %r14, %rsi
callq 0xd05a
leaq 0xbfa0(%rip), %rsi      # 0x329dd
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd05a
leaq 0xb532(%rip), %rsi      # 0x31f89
movq %rax, %rdi
callq 0x7230
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7478
leaq 0x38(%rsp), %rdi
jmp 0x269ca
movq %rax, %rbx
jmp 0x26a89
movq %rax, %rbx
jmp 0x26a9b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7478
leaq 0x38(%rsp), %rdi
jmp 0x26aaa
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7478
leaq 0x48(%rsp), %rdi
jmp 0x26aaa
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/relations.cpp
// Function: lois::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, %ebx
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 0x26dec
leal 0x1(%r14), %eax
movslq %eax, %rsi
movq %r13, %rdi
callq 0x26ef6
movslq %r14d, %r15
incl %ebx
xorl %ebp, %ebp
cmpl %r14d, %ebp
jg 0x26e28
movq (%r13), %rax
movl %ebp, (%rax,%r15,4)
movq %r12, %rdi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
movl %r14d, %ecx
movl %ebx, %r8d
callq 0x206a6
movl %eax, %ecx
movb 0x10(%r12), %al
incl %ebp
cmpb %cl, %al
je 0x26df3
xorb $0x1, %al
jmp 0x26e2d
movb 0x10(%r12), %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x26e47
cmpl $0x2, %esi
sete %al
retq
movslq %edx, %rdx
movq 0x10(%rdi), %rdi
movl (%rdi,%rdx,4), %eax
movslq %ecx, %r8
movl (%rdi,%r8,4), %ecx
movq %rdx, %r9
cmpq %r8, %r9
jge 0x26e88
xorl %r10d, %r10d
cmpl %eax, 0x4(%rdi,%r9,4)
leaq 0x1(%r9), %r9
setle %r10b
addl %r10d, %eax
jmp 0x26e5b
xorl %r9d, %r9d
cmpl %ecx, 0x4(%rdi,%r8,4)
leaq 0x1(%r8), %r8
setle %r9b
addl %r9d, %ecx
cmpq %rdx, %r8
jl 0x26e75
cmpl $0x2, %esi
sete %dl
cmpl %ecx, %eax
setg %al
xorb %dl, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbp
movq 0x18(%rdi), %rax
subq 0x10(%rdi), %rax
leaq 0x10(%rdi), %r13
shrq $0x2, %rax
leal 0x1(%r14), %ebx
cmpl %r8d, %eax
jg 0x276bb
movslq %ebx, %rsi
movq %r13, %rdi
callq 0x26ef6
cmpl $0x2, 0x28(%rbp)
cmovnel %r14d, %ebx
xorl %r15d, %r15d
cmpl $0x1, 0x2c(%rbp)
movl $0x0, %ecx
cmovel %r14d, %ecx
addl %ebx, %ecx
pushq $0x1
popq %rbp
shll %cl, %ebp
movslq %r14d, %rbx
incl 0x8(%rsp)
testl %ebp, %ebp
cmovlel %r15d, %ebp
cmpl %r15d, %ebp
je 0x2771f
movq (%r13), %rax
movl %r15d, (%rax,%rbx,4)
movq %r12, %rdi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
movl %r14d, %ecx
movl 0x8(%rsp), %r8d
callq 0x206a6
movl %eax, %ecx
movb 0x10(%r12), %al
incl %r15d
cmpb %cl, %al
je 0x276e7
xorb $0x1, %al
jmp 0x27724
movb 0x10(%r12), %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27749
movl 0x28(%rdi), %eax
cmpl $0x1, %eax
je 0x27794
testl %eax, %eax
jne 0x27749
cmpl $0x2, %esi
jmp 0x27797
cmpl %ecx, %edx
jle 0x27777
movl 0x2c(%rdi), %eax
cmpl $0x1, %eax
jne 0x27765
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 0x2777b
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_O2/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, %ebx
movl %r8d, %r14d
movq %rcx, 0x10(%rsp)
movl %edx, 0x4(%rsp)
movq %rsi, %r12
movq %rdi, %r13
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rdi), %rax
subq 0x10(%rdi), %rax
sarq $0x2, %rax
leal 0x1(%r14), %ecx
movslq %ecx, %rsi
cmpq %rsi, %rax
jae 0x27956
movq 0x8(%rsp), %rdi
callq 0x26ef6
movslq %r14d, %rbp
incl %ebx
xorl %r15d, %r15d
cmpl 0x28(%r13), %r15d
jge 0x27999
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl %r15d, (%rax,%rbp,4)
movq %r12, %rdi
movl 0x4(%rsp), %esi
movq 0x10(%rsp), %rdx
movl %r14d, %ecx
movl %ebx, %r8d
callq 0x206a6
movl %eax, %ecx
movb 0x10(%r12), %al
incl %r15d
cmpb %cl, %al
je 0x2795e
xorb $0x1, %al
jmp 0x2799e
movb 0x10(%r12), %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x279cc
cmpl $-0x1, %esi
jne 0x279e0
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 0x279f5
movslq %edx, %rax
movq 0x10(%rdi), %rcx
movl (%rcx,%rax,4), %eax
btl %eax, %esi
setb %al
retq
pushq %rax
pushq $0x8
popq %rdi
callq 0x7140
leaq 0x20853(%rip), %rcx     # 0x48258
movq %rcx, (%rax)
leaq 0x1f8a9(%rip), %rsi     # 0x472b8
movq 0x215ca(%rip), %rdx     # 0x48fe0
movq %rax, %rdi
callq 0x73f0
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq 0x10(%rdi), %rdi
pushq $0x2
popq %rax
pushq $0x1
popq %r8
cmpl $-0x1, %ecx
je 0x27d7f
cmpl %edx, %ecx
je 0x27d7c
movslq %ecx, %rcx
movl (%rdi,%rcx,4), %ecx
jmp 0x27d6b
movl %r8d, %eax
cmpl %esi, %eax
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x10(%rdi), %rdx
xorl %esi, %esi
movl %eax, %edi
cmpl $-0x1, %edi
je 0x27d9f
movslq %edi, %rdi
movl (%rdx,%rdi,4), %edi
incl %esi
jmp 0x27d90
xorl %edi, %edi
movl %ecx, %r8d
cmpl $-0x1, %r8d
je 0x27db5
movslq %r8d, %r8
movl (%rdx,%r8,4), %r8d
incl %edi
jmp 0x27da4
movl %edi, %r8d
cmpl %esi, %r8d
jle 0x27dc8
decl %r8d
movslq %ecx, %rcx
movl (%rdx,%rcx,4), %ecx
jmp 0x27db8
cmpl %edi, %esi
cmovll %esi, %edi
cmpl %edi, %esi
jle 0x27de5
decl %esi
cltq
movl (%rdx,%rax,4), %eax
jmp 0x27dcd
cltq
movl (%rdx,%rax,4), %eax
movslq %ecx, %rcx
movl (%rdx,%rcx,4), %ecx
cmpl %ecx, %eax
jne 0x27dda
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x2186d(%rip), %rdi     # 0x49888
leaq 0xa56f(%rip), %rsi      # 0x32591
callq 0x250fa
testb %al, %al
jne 0x28042
leaq 0x21856(%rip), %rdi     # 0x49888
leaq 0xa55c(%rip), %rsi      # 0x32595
callq 0x250fa
testb %al, %al
je 0x2804b
leaq 0xa6fb(%rip), %rsi      # 0x32744
jmp 0x28080
leaq 0x21836(%rip), %rdi     # 0x49888
leaq 0xa540(%rip), %rsi      # 0x32599
callq 0x250fa
testb %al, %al
jne 0x28079
leaq 0x2181f(%rip), %rdi     # 0x49888
leaq 0xa52d(%rip), %rsi      # 0x3259d
callq 0x250fa
testb %al, %al
je 0x28099
leaq 0xa6de(%rip), %rsi      # 0x3275e
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0xcfe2
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x7140
movq %rax, %rbx
leaq 0xa4f6(%rip), %rsi      # 0x325a1
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xcfe2
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x28786
xorl %ebp, %ebp
leaq 0x204cd(%rip), %rsi     # 0x485a0
leaq 0x6e2(%rip), %rdx       # 0x287bc
movq %rbx, %rdi
callq 0x73f0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x7478
testb %bpl, %bpl
jne 0x280f9
jmp 0x28101
movq %rax, %r14
movq %rbx, %rdi
callq 0x7190
movq %r14, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/solvers.cpp
// Function: lois::useDefaultSolver(int, int)
void useDefaultSolver(int i, int j) {
  aggressive_simplification_tries = j;
  solver = solverExhaustive(j, true) || solverCrash();
  if(i > 0) solver = solverExhaustive(i, false) || solver;
  solver = solverBasic() || solver;
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %edi, %ebx
leaq 0x216f6(%rip), %rax     # 0x49bd8
movl %esi, (%rax)
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0x281ae
leaq 0x18(%rsp), %rdi
callq 0x28148
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x28980
leaq 0x2135a(%rip), %rdi     # 0x49870
leaq 0x8(%rsp), %rsi
callq 0x2d242
leaq 0x10(%rsp), %rdi
callq 0xefce
leaq 0x20(%rsp), %rdi
callq 0xefce
leaq 0x30(%rsp), %rdi
callq 0xefce
testl %ebx, %ebx
jle 0x285a6
leaq 0x68(%rsp), %r14
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x281ae
leaq 0x21316(%rip), %rsi     # 0x49870
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
callq 0x28aca
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x28980
leaq 0x212f2(%rip), %rdi     # 0x49870
leaq 0x8(%rsp), %rsi
callq 0x2d242
leaq 0x10(%rsp), %rdi
callq 0xefce
leaq 0x60(%rsp), %rdi
callq 0xefce
leaq 0x70(%rsp), %rdi
callq 0xefce
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x2817b
leaq 0x212b6(%rip), %rsi     # 0x49870
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x28aca
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x28980
leaq 0x21292(%rip), %rdi     # 0x49870
leaq 0x8(%rsp), %rsi
callq 0x2d242
leaq 0x10(%rsp), %rdi
callq 0xefce
leaq 0x40(%rsp), %rdi
callq 0xefce
leaq 0x50(%rsp), %rdi
callq 0xefce
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xefce
leaq 0x70(%rsp), %rdi
jmp 0x2864d
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xefce
leaq 0x50(%rsp), %rdi
jmp 0x2864d
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xefce
jmp 0x28648
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *(%rax)
xorl %r12d, %r12d
leaq 0x9f44(%rip), %r14      # 0x325d6
pushq $0x4e
popq %rbp
pushq $0x1a
popq %r13
movslq 0x10(%rsp), %rax
cmpq %rax, %r12
jge 0x28713
movq 0x8(%rsp), %rax
movsbl (%rax,%r12), %r15d
movl %r15d, %edi
callq 0x7390
testl %eax, %eax
je 0x286c6
movq %rbx, %rdi
movl %r15d, %esi
callq 0x71f0
jmp 0x2870e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7430
testb %r15b, %r15b
jns 0x286e3
movq %rbx, %rdi
movl %ebp, %esi
callq 0x71f0
negl %r15d
testl %r15d, %r15d
jle 0x28703
movl %r15d, %eax
xorl %edx, %edx
divl %r13d
addb $0x61, %dl
movzbl %dl, %esi
movl %eax, %r15d
movq %rbx, %rdi
callq 0x71f0
jmp 0x286e3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7430
incq %r12
jmp 0x28699
leaq 0x8(%rsp), %rdi
callq 0x7478
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x28745
jmp 0x28738
jmp 0x28738
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x7478
movq %rbx, %rdi
callq 0x7478
movq %r14, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xf04a
movq %rbx, %rdi
callq 0x27e00
movl %eax, %ebp
leaq 0x18(%rsp), %rdi
callq 0xefce
pushq $0x1
popq %rbx
testb %bpl, %bpl
jne 0x29413
leaq 0x203e2(%rip), %rax     # 0x497a8
incl (%rax)
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movl 0x8(%r14), %eax
leaq 0x203c4(%rip), %r12     # 0x497a0
movl %eax, (%r12)
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl (%r12), %ecx
testl %ecx, %ecx
jle 0x29413
cmpb $0x1, 0xc(%r14)
movzbl %al, %ebx
jne 0x29411
movl 0x8(%r14), %edx
subl %ecx, %edx
leaq 0x91d0(%rip), %rdi      # 0x325d8
movl %ebx, %esi
xorl %eax, %eax
callq 0x7040
addl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
cmpl $0x1, %edx
jne 0x29477
movq %r15, %rdi
callq 0x72d0
leaq 0x1e56f(%rip), %rax     # 0x479a8
movq %rax, 0x8(%rsp)
movq %r15, %rdi
callq 0x7110
cmpb $0x1, 0xc(%r14)
jne 0x29459
leaq 0x9726(%rip), %rdi      # 0x32b7a
callq 0x7370
leaq 0x8(%rsp), %rdi
callq 0x7480
callq 0x73c0
jmp 0x29413
movq %rax, %r15
leaq 0x18(%rsp), %rdi
callq 0xefce
movq %r15, %rdi
callq 0x7410
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/solvers.cpp
// Function: lois::SolverIncremental::solve(lois::rbool)
virtual int solve(rbool phi) { 
  
    if(isNotInSMTLogic(phi)) return 1;

    OutputLanguage sav = outlan;

//    std::string s = readline();
//    if(s != "") printf("{%s}\n", s.c_str());

    outlan = SMT_INC;

    ofs << "(push 1)" << std::endl;
    ofs << "(assert\n    " << phi << std::endl << "    )" << std::endl;
    ofs << "(check-sat)" << std::endl;
    ofs << "(pop 1)" << std::endl;

    outlan = sav;
    if(crashed) return 1;
    pump();
    while(!crashed) {
      std::string s = readline();
      if(s == "sat") return 2;
      if(s == "unsat") return 0;
      if(s == "unknown") return 1;
      }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xf04a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a6c8
movl %eax, %r14d
leaq 0x30(%rsp), %rdi
callq 0xefce
pushq $0x1
popq %r15
testb %r14b, %r14b
jne 0x2a104
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x1f93f(%rip), %rax     # 0x498ec
movl (%rax), %ecx
movl %ecx, 0xc(%rsp)
movl $0x6, (%rax)
leaq 0x8(%rbx), %r14
leaq 0x86d4(%rip), %rsi      # 0x32698
movq %r14, %rdi
callq 0x7230
movq %rax, %rdi
callq 0x7130
leaq 0x86c6(%rip), %rsi      # 0x326a1
movq %r14, %rdi
callq 0x7230
movq %rax, %r13
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0xf04a
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1ef1c
movq %rax, %rdi
callq 0x7130
leaq 0x869e(%rip), %rsi      # 0x326ae
movq %rax, %rdi
callq 0x7230
movq %rax, %rdi
callq 0x7130
leaq 0x20(%rsp), %rdi
callq 0xefce
leaq 0x8683(%rip), %rsi      # 0x326b4
movq %r14, %rdi
callq 0x7230
movq %rax, %rdi
callq 0x7130
leaq 0x8678(%rip), %rsi      # 0x326c0
movq %r14, %rdi
callq 0x7230
movq %rax, %rdi
callq 0x7130
leaq 0x1f88d(%rip), %rax     # 0x498ec
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
cmpb $0x0, 0x25c(%rbx)
jne 0x2a104
movq %rbx, %rdi
callq 0x2a9e4
leaq 0x38(%rsp), %r14
leaq 0x8644(%rip), %r12      # 0x326ca
cmpb $0x0, 0x25c(%rbx)
jne 0x2a100
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2aaf2
movq %r14, %rdi
movq %r12, %rsi
callq 0x250fa
xorl %r15d, %r15d
testb %al, %al
je 0x2a0b5
xorl %r13d, %r13d
pushq $0x2
popq %r15
jmp 0x2a0ee
movq %r14, %rdi
leaq 0x8609(%rip), %rsi      # 0x326c8
callq 0x250fa
testb %al, %al
je 0x2a0cd
xorl %r13d, %r13d
jmp 0x2a0ee
movq %r14, %rdi
leaq 0x85f7(%rip), %rsi      # 0x326ce
callq 0x250fa
movl %eax, %r13d
testb %al, %al
pushq $0x1
popq %rax
cmovnel %eax, %ebp
xorb $0x1, %r13b
movl %ebp, %r15d
movq %r14, %rdi
callq 0x7478
movl %r15d, %ebp
testb %r13b, %r13b
jne 0x2a086
jmp 0x2a104
pushq $0x1
popq %r15
movl %r15d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x2a128
movq %rax, %rbx
movq 0x10(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/solvers.cpp
// Function: lois::SolverIncremental::pump()
void pump() {
    char buf[BUFSIZE];
    int numbytes = 0;
    while(true) {
      ofs.flush();
      int bytes = read(filepipe, buf, BUFSIZE);
      if(bytes <= 0) break;
      numbytes += bytes;
      if(write(solver_input[1], buf, bytes) != bytes)
        throw other_exception("writing to solver");
      }
    if(numbytes)
      printf("Sent %dB to the solver\n", numbytes);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5038, %rsp           # imm = 0x5038
movq %rdi, %r14
leaq 0x8(%rdi), %r15
xorl %ebx, %ebx
leaq 0x30(%rsp), %r12
movq %r15, %rdi
callq 0x7170
movl 0x21c(%r14), %edi
movl $0x5000, %edx           # imm = 0x5000
movq %r12, %rsi
callq 0x7330
movq %rax, %r13
testl %r13d, %r13d
jle 0x2aa93
movl 0x20c(%r14), %edi
movl %r13d, %ebp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movq %r12, %rsi
movq %rbp, %rdx
callq 0x70d0
addl %r13d, %ebx
cmpq %rbp, %rax
je 0x2aa03
pushq $0x28
popq %rdi
callq 0x7140
movq %rax, %rbx
leaq 0x7d06(%rip), %rsi      # 0x32762
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xcfe2
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x28786
xorl %ebp, %ebp
leaq 0x1db1c(%rip), %rsi     # 0x485a0
leaq -0x22cf(%rip), %rdx     # 0x287bc
movq %rbx, %rdi
callq 0x73f0
testl %ebx, %ebx
je 0x2aab8
leaq 0x7cd6(%rip), %rdi      # 0x32774
movl %ebx, %esi
xorl %eax, %eax
addq $0x5038, %rsp           # imm = 0x5038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7040
addq $0x5038, %rsp           # imm = 0x5038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x7478
testb %bpl, %bpl
jne 0x2aae1
jmp 0x2aae9
movq %rax, %r14
movq %rbx, %rdi
callq 0x7190
movq %r14, %rdi
callq 0x7410
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/solvers.cpp
// Function: lois::SolverIncremental::~SolverIncremental()
~SolverIncremental() {
    if(wearechild || crashed) {
      close(solver_input[1]);
      close(solver_output[0]);
      return;
      }
    ofs << "(exit)\n" << std::endl;
//  fprintf(stderr, "[exit %s]\n", buf);
    ofs.close();
//  fprintf(stderr, "[close %s]\n", buf);
    pump();
    int status;
    waitpid(child, &status, 0);
    close(filepipe);
    close(solver_input[1]);
    close(solver_output[0]);
//  kill(child, SIGTERM);
/*  while(true) {
      std::string s = readline();
      if(s == "") break;
      printf("bye %s\n", s.c_str());
      } */
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1dca8(%rip), %rax     # 0x488f8
movq %rax, (%rdi)
cmpb $0x0, 0x1ec26(%rip)     # 0x49880
jne 0x2ac65
cmpb $0x1, 0x25c(%rbx)
jne 0x2ac7d
movl 0x20c(%rbx), %edi
callq 0x7450
movl 0x210(%rbx), %edi
callq 0x7450
jmp 0x2acdb
leaq 0x8(%rbx), %r14
leaq 0x7b30(%rip), %rsi      # 0x327b8
movq %r14, %rdi
callq 0x7230
movq %rax, %rdi
callq 0x7130
movq %r14, %rdi
callq 0x7320
movq %rbx, %rdi
callq 0x2a9e4
movl 0x218(%rbx), %edi
leaq 0x4(%rsp), %rsi
xorl %edx, %edx
callq 0x71c0
movl 0x21c(%rbx), %edi
callq 0x7450
movl 0x20c(%rbx), %edi
callq 0x7450
movl 0x210(%rbx), %edi
callq 0x7450
leaq 0x268(%rbx), %rdi
callq 0xefce
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x7350
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0xef98
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/solvers.cpp
// Function: lois::SolverCompare::solve(lois::rbool)
virtual int solve(rbool phi) {
    int endr = 1;
    for(solveptr s: solvers) {
      int r = s->solve(phi);
      if(endr == 3) continue;
      else if(endr == 1) endr = r;
      else if(r != 1 && r != endr) endr = 3;
      }
    if(endr == 3) throw inconsistency_exception();
    return endr;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq 0x8(%rdi), %r12
movq 0x10(%rdi), %r13
pushq $0x1
popq %r14
leaq 0x18(%rsp), %rbx
cmpq %r13, %r12
je 0x2cd3d
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x28aca
movq 0x8(%rsp), %rbp
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf04a
movq (%rbp), %rax
movq %rbp, %rdi
movq %rbx, %rsi
callq *(%rax)
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0xefce
cmpl $0x1, %r14d
je 0x2cd2a
cmpl $0x3, %r14d
je 0x2cd2d
cmpl $0x1, %ebp
je 0x2cd2d
cmpl %r14d, %ebp
je 0x2cd2d
pushq $0x3
popq %r14
jmp 0x2cd2d
movl %ebp, %r14d
leaq 0x10(%rsp), %rdi
callq 0xefce
addq $0x10, %r12
jmp 0x2ccd4
cmpl $0x3, %r14d
je 0x2cd55
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x7140
leaq 0x1bebc(%rip), %rcx     # 0x48c20
movq %rcx, (%rax)
leaq 0x1be8a(%rip), %rsi     # 0x48bf8
movq 0x1c26b(%rip), %rdx     # 0x48fe0
movq %rax, %rdi
callq 0x73f0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xefce
leaq 0x10(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/solvers.cpp
// Function: lois::SolverNamed::solve(lois::rbool)
virtual int solve(rbool phi) {
//  std::cout << "trying " << name << ": " << phi << std::endl; fflush(stdout);
    long long t = getVa();
    int r = s->solve(phi);
    std::cout << ido;
    printf("result of %s: %d, %10lld \u03bcs\n", name.c_str(), r, getVa() - t);
    return r;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x27f90
movq %rax, %rbx
movq 0x28(%r14), %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xf04a
movq (%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *(%rax)
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0xefce
leaq 0x1c0fb(%rip), %rax     # 0x49268
movq (%rax), %rsi
movq 0x1be59(%rip), %rdi     # 0x48fd0
callq 0x2d27c
movq 0x8(%r14), %r14
callq 0x27f90
subq %rbx, %rax
leaq 0x59cd(%rip), %rdi      # 0x32b5c
movq %r14, %rsi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x7040
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xefce
movq %rbx, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/solvers.cpp
// Function: lois::SolverNamed::solveEnv()
virtual int solveEnv() {
//  std::cout << "trying " << name << ": " << emptycontext << std::endl; fflush(stdout);
    long long t = getVa();
    int r = s->solveEnv();
    std::cout << ido;
    printf("result of %s: %d, %10lld \u03bcs\n", name.c_str(), r, getVa() - t);
    return r;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x27f90
movq %rax, %r14
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %ebp
leaq 0x1c082(%rip), %rax     # 0x49268
movq (%rax), %rsi
movq 0x1bde0(%rip), %rdi     # 0x48fd0
callq 0x2d27c
movq 0x8(%rbx), %rbx
callq 0x27f90
subq %r14, %rax
leaq 0x5954(%rip), %rdi      # 0x32b5c
movq %rbx, %rsi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x7040
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/utils.cpp
// Function: lois::operator<<(std::ostream&, lois::indenter)
std::ostream& operator << (std::ostream& os, indenter a) { 
  indent += a.i;
  if(indent >= 0 && a.doit >= 2) os << std::endl; 
  if(indent >= 0 && a.doit >= 1) for(int i=0; i<indent; i++) os << " ";
  return os;
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, %r14
shrq $0x20, %r14
movl 0x1c658(%rip), %eax     # 0x498e8
addl %esi, %eax
movl %eax, 0x1c650(%rip)     # 0x498e8
setns %cl
cmpl $0x2, %r14d
setge %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x2d2b7
movq %rbx, %rdi
callq 0x7130
movl 0x1c631(%rip), %eax     # 0x498e8
testl %eax, %eax
setns %cl
testl %r14d, %r14d
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x2d2eb
xorl %ebp, %ebp
leaq 0x5537(%rip), %r14      # 0x32809
cmpl %eax, %ebp
jge 0x2d2eb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7230
incl %ebp
movl 0x1c5ff(%rip), %eax     # 0x498e8
jmp 0x2d2d2
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/utils.cpp
// Function: lois::initLois()
void initLois() { 
  sym.useUnicode();
  mainOrder = new RelOrder(sym.greater, sym.leq, sym.max, sym.min);
  useDefaultSolver(50000);
  smtLogic = "LRA";
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
leaq 0x1acfb(%rip), %rdi     # 0x498f0
callq 0x2db44
pushq $0x48
popq %rdi
callq 0x7250
movq %rax, %rbx
leaq 0x1ae64(%rip), %rsi     # 0x49a70
leaq 0x90(%rsp), %r14
movq %r14, %rdi
callq 0xd15a
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xd172
leaq 0x1ae10(%rip), %rsi     # 0x49a40
leaq 0x78(%rsp), %r14
movq %r14, %rdi
callq 0xd15a
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0xd172
leaq 0x1ae4f(%rip), %rsi     # 0x49aa0
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0xd15a
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xd172
leaq 0x1ae46(%rip), %rsi     # 0x49ab8
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0xd15a
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0xd172
leaq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x8(%rsp), %rcx
leaq 0x38(%rsp), %r8
movq %rbx, %rdi
callq 0x2f304
movq %rbx, 0x1aee1(%rip)     # 0x49b90
leaq 0x40(%rsp), %rdi
callq 0xefce
leaq 0x48(%rsp), %rdi
callq 0xd208
leaq 0x10(%rsp), %rdi
callq 0xefce
leaq 0x60(%rsp), %rdi
callq 0xd208
leaq 0x20(%rsp), %rdi
callq 0xefce
leaq 0x78(%rsp), %rdi
callq 0xd208
leaq 0x30(%rsp), %rdi
callq 0xefce
leaq 0x90(%rsp), %rdi
callq 0xd208
movl $0xc350, %edi           # imm = 0xC350
movl $0x77359400, %esi       # imm = 0x77359400
callq 0x284d2
leaq 0x1ab70(%rip), %rdi     # 0x49888
leaq 0x3872(%rip), %rsi      # 0x32591
callq 0x7440
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0xd208
leaq 0x10(%rsp), %rdi
callq 0xefce
jmp 0x2ed4b
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0xd208
leaq 0x20(%rsp), %rdi
callq 0xefce
jmp 0x2ed64
movq %rax, %r14
leaq 0x78(%rsp), %rdi
callq 0xd208
leaq 0x30(%rsp), %rdi
callq 0xefce
jmp 0x2ed7d
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0xd208
pushq $0x48
popq %rsi
movq %rbx, %rdi
callq 0x7260
movq %r14, %rdi
callq 0x7410
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/element.cpp
// Function: lois::Domain::getSet()
lsetof<term> Domain::getSet() {
  auto x = newvar(this);
  varlist v;
  v.push_back(x);
  lsetof<term> res;
  term tx = term(x);
  res.elts.push_back(std::make_shared<SimpleSetOf<term>>( v, ftrue, tx));
  return res;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x12a4f
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %r14, %rsi
callq 0x11466
leaq 0x38(%rsp), %r15
movq %rbx, %rdi
callq 0xd46c
leaq 0x30(%rsp), %r14
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x12f26
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x21596
leaq 0x38(%rsp), %rdi
callq 0xefce
leaq 0x1a286(%rip), %rdx     # 0x497b0
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
leaq 0x10(%rsp), %rcx
callq 0x18156
leaq 0x10(%rbx), %rdi
movq %rsp, %rsi
callq 0x18112
leaq 0x8(%rsp), %rdi
callq 0xefce
leaq 0x18(%rsp), %rdi
callq 0xefce
leaq 0x40(%rsp), %rdi
callq 0x114e6
leaq 0x28(%rsp), %rdi
callq 0xefce
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xefce
jmp 0x2f58f
movq %rax, %r14
leaq 0x18(%rsp), %r15
jmp 0x2f599
movq %rax, %r14
movq %r15, %rdi
callq 0xefce
movq %rbx, %rdi
callq 0xd420
jmp 0x2f5ae
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x114e6
leaq 0x28(%rsp), %rdi
callq 0xefce
movq %r14, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/pseudo.cpp
// Function: lois::branchset(std::shared_ptr<lois::Context>, std::shared_ptr<lois::Context>)
lsetof<lvector<term>> branchset(contextptr anccontext, contextptr nowcontext) {

  lsetof<lvector<term>> X;
  
  lvector<term> v;
  contextptr e = nowcontext;
  while(e != anccontext) {
    if(!e) throw env_exception();
    for(auto w: e->var) v.push_back(term(w));
    e = e->parent;
    }
  
  X.insert(v, anccontext);

  return X;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
callq 0x13604
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xf7c2
leaq 0xa0(%rsp), %rbp
leaq 0x70(%rsp), %rbx
leaq 0x60(%rsp), %r14
leaq 0x98(%rsp), %r15
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq (%rcx), %rax
je 0x303b6
testq %rax, %rax
je 0x30452
movq 0x20(%rax), %r12
movq 0x28(%rax), %r13
cmpq %r13, %r12
je 0x303a2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1160e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12f26
movq %r15, %rdi
movq %r14, %rsi
callq 0x21596
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0xd116
movq %rbp, %rdi
callq 0xefce
leaq 0x68(%rsp), %rdi
callq 0xefce
leaq 0x78(%rsp), %rdi
callq 0xefce
addq $0x10, %r12
jmp 0x3034d
movq 0x10(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x112d4
jmp 0x3032d
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x133be
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0xf7c2
leaq 0x1938f(%rip), %rsi     # 0x49770
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0xf7c2
leaq 0x80(%rsp), %rsi
movq (%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x13916
leaq 0x48(%rsp), %rdi
callq 0xefce
leaq 0x58(%rsp), %rdi
callq 0xefce
leaq 0x80(%rsp), %rdi
callq 0xd3c0
leaq 0x18(%rsp), %rdi
callq 0xefce
leaq 0x20(%rsp), %rdi
callq 0xd3c0
movq %r15, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x7140
leaq 0x170bf(%rip), %rcx     # 0x47520
movq %rcx, (%rax)
leaq 0x1708d(%rip), %rsi     # 0x474f8
movq 0x18b6e(%rip), %rdx     # 0x48fe0
movq %rax, %rdi
callq 0x73f0
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xefce
leaq 0x58(%rsp), %rdi
callq 0xefce
leaq 0x80(%rsp), %rdi
callq 0xd3c0
jmp 0x304c9
movq %rax, %rbx
jmp 0x304c9
movq %rax, %rbx
jmp 0x304b5
movq %rax, %rbx
movq %rbp, %rdi
callq 0xefce
leaq 0x68(%rsp), %rdi
callq 0xefce
leaq 0x78(%rsp), %rdi
callq 0xefce
leaq 0x18(%rsp), %rdi
callq 0xefce
leaq 0x20(%rsp), %rdi
callq 0xd3c0
movq (%rsp), %rdi
callq 0x105b4
movq %rbx, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: categorical(std::vector<double, std::allocator<double>>)
int categorical(vector<double> proportions) {
	// Sum all the elements and draw a random number for that
	double sum = 0;
	for(vector<double>::iterator it = proportions.begin(); it != proportions.end(); it++)
		sum += *it;
	double random_number = distribution(generator);
	double draw = sum * random_number;
	// Return the appropriate index based on the cumulative sum
	double cumsum = 0;
	int size = proportions.size();
	for(int idx = 0; idx < size; idx++) {
		cumsum += proportions[idx];
		if(draw < cumsum) {
			return idx;
		}
	}
	return size - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0x259f
addsd (%rax), %xmm0
addq $0x8, %rax
jmp 0x2590
leaq 0x9ff2(%rip), %rdi      # 0xc598
leaq 0x9fe3(%rip), %rsi      # 0xc590
movsd %xmm0, -0x10(%rbp)
callq 0x4dfc
movsd -0x10(%rbp), %xmm1
mulsd %xmm0, %xmm1
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
shrq $0x3, %rax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
xorpd %xmm0, %xmm0
cmpq %rcx, %rdx
je 0x25f5
addsd (%rsi,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
ja 0x25f3
incq %rcx
jmp 0x25de
movl %ecx, %edx
movslq %eax, %rsi
decl %eax
cmpq %rsi, %rcx
cmovll %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: HMMLDA::HMMLDA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int, int, int, int, double, double, double, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
HMMLDA::HMMLDA(string &vocab_filename, int topics, int classes, int start_word, int end_word, 
	double n_alpha, double n_beta, double n_gamma, double n_delta, string save_directory): 
	num_topics(topics), num_classes(classes), start_word_id(start_word), end_word_id(end_word), alpha(n_alpha),
	beta(n_beta), gamma(n_gamma), delta(n_delta), save_dir(save_directory), rng(rd()), topic_dist(0,topics-1), 
	class_dist(0, classes-3) {
	// All 2D vectors are empty at the moment
	START_WORD_CLASS = num_classes - 2;
	END_WORD_CLASS = num_classes - 1;
	vocab_size = this->read_vocabulary(vocab_filename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r15d
movl %edx, %r14d
movq %rsi, %r13
movq %rdi, %rbx
movq 0x10(%rbp), %rsi
movl %edx, (%rdi)
movl %ecx, 0x4(%rdi)
movl %r8d, 0x8(%rdi)
movl %r9d, 0xc(%rdi)
movsd %xmm0, 0x18(%rdi)
movsd %xmm1, 0x20(%rdi)
movsd %xmm2, 0x28(%rdi)
movsd %xmm3, 0x30(%rdi)
addq $0x38, %rdi
movq %rdi, -0x60(%rbp)
callq 0x2280
xorps %xmm0, %xmm0
andq $0x0, 0x68(%rbx)
movups %xmm0, 0x58(%rbx)
andl $0x0, 0x78(%rbx)
andq $0x0, 0x80(%rbx)
leaq 0x58(%rbx), %rax
movq %rax, -0x58(%rbp)
leaq 0x78(%rbx), %rax
movq %rax, 0x88(%rbx)
movq %rax, 0x90(%rbx)
andq $0x0, 0x98(%rbx)
leaq 0xa8(%rbx), %r12
movl $0xd8, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x2130
leaq 0x8b5a(%rip), %rdi      # 0xb208
callq 0x2290
leaq 0x180(%rbx), %rdi
movl %eax, %esi
callq 0x5662
decl %r14d
andl $0x0, 0x1508(%rbx)
movl %r14d, 0x150c(%rbx)
andl $0x0, 0x1510(%rbx)
addl $-0x3, %r15d
movl %r15d, 0x1514(%rbx)
movl 0x4(%rbx), %eax
leal -0x2(%rax), %ecx
movl %ecx, 0x10(%rbx)
decl %eax
movl %eax, 0x14(%rbx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x27ce
movl %eax, 0xa0(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x50(%rbp)
leaq 0x168(%rbx), %rdi
leaq 0x150(%rbx), %r14
leaq 0x138(%rbx), %r15
leaq 0x120(%rbx), %r13
leaq 0x108(%rbx), %rax
movq %rax, -0x30(%rbp)
leaq 0xf0(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq 0xd8(%rbx), %rax
movq %rax, -0x40(%rbp)
leaq 0xc0(%rbx), %rax
movq %rax, -0x48(%rbp)
addq $0x70, %rbx
callq 0x571a
movq %r14, %rdi
callq 0x571a
movq %r15, %rdi
callq 0x4e0a
movq %r13, %rdi
callq 0x4e0a
movq -0x30(%rbp), %rdi
callq 0x4e0a
movq -0x38(%rbp), %rdi
callq 0x4e0a
movq -0x40(%rbp), %rdi
callq 0x4e0a
movq -0x48(%rbp), %rdi
callq 0x4e0a
movq %r12, %rdi
callq 0x4e0a
movq %rbx, %rdi
callq 0x53f4
movq -0x58(%rbp), %rdi
callq 0x4e36
movq -0x60(%rbp), %rdi
callq 0x20f0
movq -0x50(%rbp), %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: HMMLDA::read_vocabulary(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int HMMLDA::read_vocabulary(string &vocab_filename) {
	ifstream file(vocab_filename, ios::in);
	string str;
	int i = 0;
	while(getline(file, str)) {
		vector<string> str_spl = split(str, ' ');
		vocab.push_back(str_spl[0]);
		vocab_dict[str_spl[0]] = i;
		i++;
	}
	return vocab.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rdi, %rbx
leaq -0x270(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x2330
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x58(%rbx), %r15
movq %rbx, -0x30(%rbp)
leaq 0x70(%rbx), %r12
xorl %r14d, %r14d
leaq -0x68(%rbp), %r13
leaq -0x48(%rbp), %rbx
leaq -0x270(%rbp), %rdi
movq %r13, %rsi
callq 0x2060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x286e
movq %rbx, %rdi
movq %r13, %rsi
pushq $0x20
popq %rdx
callq 0x29ee
movq -0x48(%rbp), %rsi
movq %r15, %rdi
callq 0x4e62
movq -0x48(%rbp), %rsi
movq %r12, %rdi
callq 0x4e9e
movl %r14d, (%rax)
incl %r14d
movq %rbx, %rdi
callq 0x4e36
jmp 0x281b
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rbx
subq 0x58(%rax), %rbx
shrq $0x5, %rbx
leaq -0x68(%rbp), %rdi
callq 0x20f0
leaq -0x270(%rbp), %rdi
callq 0x2090
movl %ebx, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28a9
movq %rax, %rbx
jmp 0x28ba
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x4e36
leaq -0x68(%rbp), %rdi
callq 0x20f0
leaq -0x270(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2380
nop