LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2cb95
leaq 0x30(%rbx), %r14
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x2cb95
movq (%rsp), %r15
movq 0x10(%rsp), %r12
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3092c
callq 0x13308
cmpq %r12, %r15
jne 0x30995
movq 0x8(%r15), %rax
movq 0x18(%rbx), %rcx
movq (%rax), %r15
addq $0x10, %rax
cmpq %rcx, 0x8(%r15)
jne 0x30939
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 0x30986
callq 0x13308
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x7150
leaq 0x21232(%rip), %rcx     # 0x51bd8
movq %rcx, (%rax)
leaq 0x21038(%rip), %rsi     # 0x519e8
movq 0x22629(%rip), %rdx     # 0x52fe0
movq %rax, %rdi
callq 0x7400
jmp 0x309c3
jmp 0x309c3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x309d5
callq 0x13308
movq %rbx, %rdi
callq 0x7430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31dd0
movb 0x18(%r12), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
movl %eax, %ecx
andl %ebp, %ecx
je 0x31e06
cmpl %eax, %ecx
je 0x31de9
cmpl $-0x2, %ebp
je 0x31df7
cmpl $-0x1, %ebp
jne 0x31e31
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d28d
testb %al, %al
je 0x31df2
leaq 0x219c0(%rip), %rax     # 0x537b0
jmp 0x31e0d
cmpl $-0x2, %ebp
jne 0x31e31
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d28d
testb %al, %al
je 0x31e31
leaq 0x219b3(%rip), %rax     # 0x537c0
movq (%rax), %rcx
movq %rcx, (%rbx)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x31e4a
movq 0x211a1(%rip), %rcx     # 0x52fc8
cmpb $0x0, (%rcx)
je 0x31e46
incl 0x8(%rax)
jmp 0x31e4a
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x2c18e
jmp 0x31e4a
lock
incl 0x8(%rax)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %ebp
movl %r8d, %r13d
movq %rcx, 0x10(%rsp)
movl %edx, 0x4(%rsp)
movq %rsi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rdi), %rax
subq 0x10(%rdi), %rax
shrq $0x2, %rax
cmpl %r8d, %eax
jg 0x33977
leal 0x1(%r13), %eax
movslq %eax, %rsi
movq 0x8(%rsp), %rdi
callq 0x33b0c
movl %r13d, %r14d
shrl $0x1f, %r14d
testl %r13d, %r13d
js 0x33a12
movl %r13d, %r15d
incl %ebp
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl $0x0, (%rax,%r15,4)
movq %rbx, %rdi
movl 0x4(%rsp), %esi
movq 0x10(%rsp), %rdx
movl %r13d, %ecx
movl %ebp, %r8d
callq 0x2b9a6
movl %eax, %ecx
movb 0x10(%rbx), %al
cmpb %cl, %al
jne 0x33a0b
movl %r13d, %r14d
negl %r14d
movl $0x1, %r12d
leal (%r14,%r12), %eax
cmpl $0x1, %eax
je 0x33a0f
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl %r12d, (%rax,%r15,4)
movq %rbx, %rdi
movl 0x4(%rsp), %esi
movq 0x10(%rsp), %rdx
movl %r13d, %ecx
movl %ebp, %r8d
callq 0x2b9a6
movl %eax, %ecx
movb 0x10(%rbx), %al
incl %r12d
cmpb %cl, %al
je 0x339c8
addl $-0x2, %r12d
cmpl %r13d, %r12d
setge %r14b
xorb $0x1, %al
jmp 0x33a12
movb $0x1, %r14b
testb %r14b, %r14b
je 0x33a1a
movb 0x10(%rbx), %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_O1/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 0x33a37
cmpl $0x2, %esi
sete %al
retq
pushq %r14
pushq %rbx
movslq %edx, %rax
movq 0x10(%rdi), %rdi
movl (%rdi,%rax,4), %r10d
movslq %ecx, %r9
jge 0x33a70
movslq %ecx, %r11
movq %rax, %rbx
xorl %r8d, %r8d
cmpl %r10d, 0x4(%rdi,%rbx,4)
leaq 0x1(%rbx), %r14
setle %r8b
addl %r10d, %r8d
movq %r14, %rbx
movl %r8d, %r10d
cmpq %r14, %r11
jne 0x33a50
jmp 0x33a73
movl %r10d, %r8d
movl (%rdi,%r9,4), %r10d
cmpl %edx, %ecx
jge 0x33a99
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 0x33a7b
jmp 0x33a9c
movl %r10d, %ecx
cmpl $0x2, %esi
sete %dl
cmpl %ecx, %r8d
setg %al
xorb %dl, %al
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movl %r9d, 0x10(%rsp)
movl %r8d, %r14d
movq %rcx, 0x20(%rsp)
movl %edx, 0x14(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rax
subq 0x10(%rdi), %rax
leaq 0x10(%rdi), %rcx
movq %rcx, 0x18(%rsp)
shrq $0x2, %rax
leal 0x1(%r14), %ebp
cmpl %r8d, %eax
jg 0x340a8
movslq %ebp, %rsi
movq 0x18(%rsp), %rdi
callq 0x33b0c
cmpl $0x2, 0x28(%r15)
cmovnel %r14d, %ebp
xorl %ecx, %ecx
cmpl $0x1, 0x2c(%r15)
cmovel %r14d, %ecx
addl %ebp, %ecx
movl $0x1, %ebp
shll %cl, %ebp
movl $0x1, %r12d
cmpl $0x1f, %ecx
setne %cl
je 0x34173
movb %cl, 0xf(%rsp)
movslq %r14d, %r15
movl 0x10(%rsp), %r8d
incl %r8d
cmpl $0x2, %ebp
cmovgel %ebp, %r12d
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl $0x0, (%rax,%r15,4)
movq %rbx, %rdi
movl 0x14(%rsp), %esi
movq 0x20(%rsp), %rdx
movl %r14d, %ecx
movl %r8d, %r13d
callq 0x2b9a6
movl %eax, %ecx
movb 0x10(%rbx), %al
cmpb %cl, %al
jne 0x34164
movl %ebp, 0x10(%rsp)
movl $0x1, %ebp
cmpl %ebp, %r12d
je 0x3416c
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl %ebp, (%rax,%r15,4)
movq %rbx, %rdi
movl 0x14(%rsp), %esi
movq 0x20(%rsp), %rdx
movl %r14d, %ecx
movl %r13d, %r8d
callq 0x2b9a6
movl %eax, %ecx
movb 0x10(%rbx), %al
incl %ebp
cmpb %cl, %al
je 0x34126
decl %ebp
cmpl 0x10(%rsp), %ebp
setl 0xf(%rsp)
xorb $0x1, %al
movb 0xf(%rsp), %cl
jmp 0x34173
cmpl 0x10(%rsp), %ebp
setl %cl
testb %cl, %cl
jne 0x3417a
movb 0x10(%rbx), %al
andb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x341a1
movl 0x28(%rdi), %eax
cmpl $0x1, %eax
je 0x341ec
testl %eax, %eax
jne 0x341a1
cmpl $0x2, %esi
jmp 0x341ef
cmpl %ecx, %edx
jle 0x341cf
movl 0x2c(%rdi), %eax
cmpl $0x1, %eax
jne 0x341bd
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 0x341d3
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_O1/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 $0x28, %rsp
movl %r9d, %ebp
movq %rcx, 0x18(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rdi), %rax
subq 0x10(%rdi), %rax
sarq $0x2, %rax
movq %r8, 0x20(%rsp)
leal 0x1(%r8), %ecx
movslq %ecx, %rsi
cmpq %rsi, %rax
jae 0x342c4
movq 0x10(%rsp), %rdi
callq 0x33b0c
cmpl $0x0, 0x28(%r13)
setg %r12b
jle 0x3434c
movq 0x20(%rsp), %rcx
movslq %ecx, %r15
incl %ebp
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl $0x0, (%rax,%r15,4)
movq %rbx, %rdi
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdx
movl %ebp, %r14d
movl %ebp, %r8d
callq 0x2b9a6
movl %eax, %ecx
movb 0x10(%rbx), %al
cmpb %cl, %al
jne 0x34348
movl $0x1, %ebp
cmpl 0x28(%r13), %ebp
setl %r12b
jge 0x3434c
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl %ebp, (%rax,%r15,4)
movq %rbx, %rdi
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl %r14d, %r8d
callq 0x2b9a6
movl %eax, %ecx
movb 0x10(%rbx), %al
incl %ebp
cmpb %cl, %al
je 0x3430e
xorb $0x1, %al
jmp 0x3434c
testb %r12b, %r12b
jne 0x34354
movb 0x10(%rbx), %al
andb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34384
cmpl $-0x1, %esi
jne 0x34398
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 0x343ad
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 0x1de71(%rip), %rcx     # 0x52230
movq %rcx, (%rax)
leaq 0x1ce9f(%rip), %rsi     # 0x51268
movq 0x1ec10(%rip), %rdx     # 0x52fe0
movq %rax, %rdi
callq 0x7400
// File: /workspace/github_cpp_makefile_star2_O1/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 0x347a8
movq 0x10(%rdi), %rdi
cmpl %edx, %ecx
je 0x347a3
movslq %ecx, %rcx
movl (%rdi,%rcx,4), %ecx
cmpl $-0x1, %ecx
jne 0x34792
jmp 0x347a8
movl $0x1, %eax
cmpl %esi, %eax
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %edx, %edx
movl $0x0, %esi
cmpl $-0x1, %eax
je 0x347d4
movq 0x10(%rdi), %r8
xorl %esi, %esi
movl %eax, %r9d
movslq %r9d, %r9
movl (%r8,%r9,4), %r9d
incl %esi
cmpl $-0x1, %r9d
jne 0x347c5
cmpl $-0x1, %ecx
je 0x347f1
movq 0x10(%rdi), %r8
xorl %edx, %edx
movl %ecx, %r9d
movslq %r9d, %r9
movl (%r8,%r9,4), %r9d
incl %edx
cmpl $-0x1, %r9d
jne 0x347e2
cmpl %esi, %edx
jle 0x34808
movq 0x10(%rdi), %r8
decl %edx
movslq %ecx, %rcx
movl (%r8,%rcx,4), %ecx
cmpl %esi, %edx
jg 0x347f9
movl %esi, %edx
cmpl %edx, %esi
jle 0x3481c
movq 0x10(%rdi), %r8
decl %esi
cltq
movl (%r8,%rax,4), %eax
cmpl %edx, %esi
jg 0x34810
cmpl %ecx, %eax
je 0x34833
movq 0x10(%rdi), %rdx
cltq
movl (%rdx,%rax,4), %eax
movslq %ecx, %rcx
movl (%rdx,%rcx,4), %ecx
cmpl %ecx, %eax
jne 0x34824
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ed61(%rip), %rdi     # 0x53880
leaq 0xca8f(%rip), %rsi      # 0x415b5
callq 0x70c0
testl %eax, %eax
je 0x34b8b
leaq 0x1ed4a(%rip), %rdi     # 0x53880
leaq 0xca7c(%rip), %rsi      # 0x415b9
callq 0x70c0
testl %eax, %eax
je 0x34b8b
leaq 0x1ed33(%rip), %rdi     # 0x53880
leaq 0xca69(%rip), %rsi      # 0x415bd
callq 0x70c0
testl %eax, %eax
je 0x34b74
leaq 0x1ed1c(%rip), %rdi     # 0x53880
leaq 0xca56(%rip), %rsi      # 0x415c1
callq 0x70c0
testl %eax, %eax
jne 0x34bb6
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xcc00(%rip), %rsi      # 0x41782
leaq 0xcbfc(%rip), %rdx      # 0x41785
jmp 0x34ba0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xcbcf(%rip), %rsi      # 0x41768
leaq 0xcbcc(%rip), %rdx      # 0x4176c
movq %rbx, %rdi
callq 0x1c6d0
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 0xc9f2(%rip), %rsi      # 0x415c5
leaq 0xca00(%rip), %rdx      # 0x415da
leaq 0x8(%rsp), %rdi
callq 0x1c6d0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3560a
xorl %ebp, %ebp
leaq 0x1d9a3(%rip), %rsi     # 0x525a0
leaq 0xa50(%rip), %rdx       # 0x35654
movq %rbx, %rdi
callq 0x7400
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x34c2e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7280
jmp 0x34c2e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x34c3b
movq %rbx, %rdi
callq 0x71b0
movq %r14, %rdi
callq 0x7430
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3559a
xorl %r12d, %r12d
leaq 0xc0f2(%rip), %r14      # 0x415fa
movq 0x8(%rsp), %rax
movsbl (%rax,%r12), %ebp
movl %ebp, %edi
callq 0x73a0
testl %eax, %eax
je 0x35529
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7220
jmp 0x35589
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7450
testb %bpl, %bpl
jns 0x35548
movq %rbx, %rdi
movl $0x4e, %esi
callq 0x7220
negl %ebp
testl %ebp, %ebp
jle 0x3557e
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 0x3554c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7450
incq %r12
movslq 0x10(%rsp), %rax
cmpq %rax, %r12
jl 0x35508
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x355b5
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 0x355ee
jmp 0x355d0
jmp 0x355d0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x355ee
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7280
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x35601
movq (%r15), %rsi
incq %rsi
callq 0x7280
movq %r14, %rdi
callq 0x7430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35eaf
movq 0x1d127(%rip), %rcx     # 0x52fc8
cmpb $0x0, (%rcx)
je 0x35eab
incl 0x8(%rax)
jmp 0x35eaf
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x34834
movl %eax, %r15d
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x35ecb
callq 0x13308
movl $0x1, %ebp
testb %r15b, %r15b
jne 0x35f24
leaq 0x1d8cc(%rip), %rax     # 0x537a8
incl (%rax)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movl 0x8(%rbx), %eax
leaq 0x1d8af(%rip), %r15     # 0x537a0
movl %eax, (%r15)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl (%r15), %ecx
testl %ecx, %ecx
jle 0x35f24
cmpb $0x1, 0xc(%rbx)
movzbl %al, %ebp
jne 0x35f22
movl 0x8(%rbx), %edx
subl %ecx, %edx
leaq 0xb6e3(%rip), %rdi      # 0x415fc
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 0x35f5a
movq %r14, %rdi
movl %edx, %esi
movq %rbx, %rdx
callq 0x7623
jmp 0x35f24
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x35f5a
callq 0x13308
movq %r14, %rdi
callq 0x7430
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x5028, %rsp           # imm = 0x5028
movq %rdi, %r14
leaq 0x8(%rdi), %r15
xorl %ebx, %ebx
leaq 0x20(%rsp), %r12
movq %r15, %rdi
callq 0x7190
movl 0x21c(%r14), %edi
movl $0x5000, %edx           # imm = 0x5000
movq %r12, %rsi
callq 0x7340
movq %rax, %r13
testl %r13d, %r13d
jle 0x37bd2
movl 0x20c(%r14), %edi
movl %r13d, %ebp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movq %r12, %rsi
movq %rbp, %rdx
callq 0x70e0
cmpq %rbp, %rax
jne 0x37c0e
addl %r13d, %ebx
testl %r13d, %r13d
jg 0x37b8b
testl %ebx, %ebx
je 0x37bfc
leaq 0x9bb6(%rip), %rdi      # 0x41798
movl %ebx, %esi
xorl %eax, %eax
addq $0x5028, %rsp           # imm = 0x5028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7050
addq $0x5028, %rsp           # imm = 0x5028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x7150
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9b5b(%rip), %rsi      # 0x41786
leaq 0x9b65(%rip), %rdx      # 0x41797
movq %rsp, %rdi
callq 0x1c6d0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3560a
xorl %ebp, %ebp
leaq 0x1a94f(%rip), %rsi     # 0x525a0
leaq -0x2604(%rip), %rdx     # 0x35654
movq %rbx, %rdi
callq 0x7400
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x37c81
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7280
jmp 0x37c81
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x37c8e
movq %rbx, %rdi
callq 0x71b0
movq %r14, %rdi
callq 0x7430
// File: /workspace/github_cpp_makefile_star2_O1/eryxcc[P]lois/src/solvers.cpp
// Function: lois::SolverIncremental::readline[abi:cxx11]()
std::string readline() {
    std::string ans;
    while(true) {
      int status;
      int wpr = waitpid(child, &status, WNOHANG);
      if(wpr == child) {
        crashed = true;
        return "";
        }

      char buf;
      int bytes = read(solver_output[0], &buf, 1);
      if(bytes<0 && errno == EAGAIN) {
        // printf("AGAIN\n");
        continue;
        }
      if(bytes > 0) {
        if(buf == 10) return ans;
        else ans += buf;
        }
      if(bytes < 0) { crashed = true; return ""; }
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x10(%rdi), %r13
leaq 0x34(%rsp), %r12
movl 0x218(%r14), %edi
movq %r12, %rsi
movl $0x1, %edx
callq 0x71e0
cmpl 0x218(%r14), %eax
jne 0x37d0c
movb $0x1, 0x25c(%r14)
movq %r13, (%rbx)
movl $0x1, %r15d
movq %rbx, %rdi
leaq 0x9991(%rip), %rdx      # 0x41690
movq %rdx, %rsi
callq 0x1c6d0
jmp 0x37dcc
movl 0x210(%r14), %edi
movl $0x1, %edx
leaq 0xf(%rsp), %rsi
callq 0x7340
movq %rax, %rbp
testl %ebp, %ebp
jns 0x37d3d
callq 0x7040
movl $0x2, %r15d
cmpl $0xb, (%rax)
je 0x37dcc
testl %ebp, %ebp
jle 0x37d76
movb 0xf(%rsp), %al
cmpb $0xa, %al
jne 0x37d69
movq %r13, (%rbx)
movq 0x10(%rsp), %rax
leaq 0x20(%rsp), %rcx
cmpq %rcx, %rax
je 0x37da2
movq %rax, (%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x37daa
movsbl %al, %esi
leaq 0x10(%rsp), %rdi
callq 0x7220
xorl %r15d, %r15d
testl %ebp, %ebp
jns 0x37dcc
movb $0x1, 0x25c(%r14)
movq %r13, (%rbx)
movl $0x1, %r15d
movq %rbx, %rdi
leaq 0x98f8(%rip), %rdx      # 0x41690
movq %rdx, %rsi
callq 0x1c6d0
jmp 0x37dcc
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rcx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movl $0x1, %r15d
testb $0x1, %r15b
je 0x37cc7
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x37df2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x7280
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37e0a
jmp 0x37e0a
jmp 0x37e0a
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq 0x10(%rsp), %rdi
cmpq %rax, %rdi
je 0x37e29
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x7280
movq %rbx, %rdi
callq 0x7430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1aab8(%rip), %rax     # 0x528f8
movq %rax, (%rdi)
cmpb $0x0, 0x1ba2e(%rip)     # 0x53878
jne 0x37e55
cmpb $0x1, 0x25c(%rbx)
jne 0x37e70
movl 0x20c(%rbx), %edi
callq 0x7460
movl 0x210(%rbx), %edi
callq 0x7460
jmp 0x37ef2
leaq 0x8(%rbx), %r14
leaq 0x9961(%rip), %rsi      # 0x417dc
movl $0x7, %edx
movq %r14, %rdi
callq 0x72c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x7250
movsbl %al, %esi
movq %r14, %rdi
callq 0x7030
movq %rax, %rdi
callq 0x7190
movq %r14, %rdi
callq 0x7330
movq %rbx, %rdi
callq 0x37b6c
movl 0x218(%rbx), %edi
leaq 0x4(%rsp), %rsi
xorl %edx, %edx
callq 0x71e0
movl 0x21c(%rbx), %edi
callq 0x7460
movl 0x20c(%rbx), %edi
callq 0x7460
movl 0x210(%rbx), %edi
callq 0x7460
movq 0x268(%rbx), %rdi
testq %rdi, %rdi
je 0x37f03
callq 0x13308
movq 0x1b0b6(%rip), %rax     # 0x52fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
movq %rcx, 0x8(%rbx)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rbx,%rcx)
leaq 0x10(%rbx), %rdi
callq 0x7200
addq $0x100, %rbx            # imm = 0x100
movq %rbx, %rdi
callq 0x70d0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x132d9
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x73b0
movq (%r15), %r12
movq 0x8(%r15), %r15
movq 0x28(%rbx), %rdi
movq (%r14), %rax
movq %rax, (%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x3afda
movq 0x17ffc(%rip), %rcx     # 0x52fc8
cmpb $0x0, (%rcx)
je 0x3afd6
incl 0x8(%rax)
jmp 0x3afda
lock
incl 0x8(%rax)
movq (%rdi), %rax
movq %rsp, %rsi
callq *(%rax)
movl %eax, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3aff3
callq 0x13308
leaq 0x1826e(%rip), %rax     # 0x53268
movq (%rax), %rsi
movq 0x17fcc(%rip), %rdi     # 0x52fd0
callq 0x3b148
movq 0x8(%rbx), %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x73b0
movq (%r14), %rax
subq %r12, %rax
movq 0x8(%r14), %rdx
subq %r15, %rdx
imulq $0xf4240, %rax, %rcx    # imm = 0xF4240
addq %rdx, %rcx
leaq 0x6b46(%rip), %rdi      # 0x41b80
movq %rbx, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x7050
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3b067
callq 0x13308
movq %rbx, %rdi
callq 0x7430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x73b0
movq (%rbx), %r12
movq 0x8(%rbx), %r13
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %ebx
leaq 0x181c1(%rip), %rax     # 0x53268
movq (%rax), %rsi
movq 0x17f1f(%rip), %rdi     # 0x52fd0
callq 0x3b148
movq 0x8(%r14), %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x73b0
movq (%r15), %rax
subq %r12, %rax
movq 0x8(%r15), %rdx
subq %r13, %rdx
imulq $0xf4240, %rax, %rcx    # imm = 0xF4240
addq %rdx, %rcx
leaq 0x6a9b(%rip), %rdi      # 0x41b80
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x7050
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
addl %esi, 0x18784(%rip)     # 0x538e0
setns %al
cmpl $0x2, %r14d
setge %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x3b194
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7250
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7030
movq %rax, %rdi
callq 0x7190
testl %r14d, %r14d
setg %al
cmpl $0x0, 0x1873f(%rip)     # 0x538e0
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x3b1ce
xorl %ebp, %ebp
leaq 0x6679(%rip), %r14      # 0x4182d
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72c0
incl %ebp
cmpl 0x18714(%rip), %ebp     # 0x538e0
jl 0x3b1b4
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x30(%rsp), %r14
movq %r12, (%r14)
movl $0x78, %edi
callq 0x7270
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x13649(%rip), %rcx     # 0x51590
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x13aab(%rip), %rdx     # 0x51a00
addq $0x10, %rdx
movq %rdx, 0x10(%rax)
movq %r15, 0x20(%rax)
leaq 0x68(%rax), %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movq %rdx, 0x58(%rax)
movq %r12, 0x60(%rax)
movb $0x0, 0x68(%rax)
movl $0x0, 0x50(%rax)
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movq %rax, 0x8(%r14)
movq %rcx, (%r14)
leaq 0x50(%rsp), %rdi
movq %r12, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq %r14, %rsi
callq 0x162a6
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x20(%rbx)
leaq 0x157b2(%rip), %rsi     # 0x53770
movq (%rsi), %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
addq $0x8, %rsi
callq 0x16086
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x3dfff
movq 0x14fd7(%rip), %rcx     # 0x52fc8
cmpb $0x0, (%rcx)
je 0x3dffb
incl 0x8(%rax)
jmp 0x3dfff
lock
incl 0x8(%rax)
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2cfaa
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x3e01d
callq 0x13308
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x1577f(%rip), %r8      # 0x537b0
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rdx
leaq 0x50(%rsp), %rcx
leaq 0x40(%rsp), %r9
callq 0x1f1c2
leaq 0x10(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1eeac
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3e067
callq 0x13308
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x3e076
callq 0x13308
leaq 0x50(%rsp), %rdi
callq 0x16384
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x3e08f
callq 0x13308
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3e0b5
callq 0x13308
jmp 0x3e0b5
movq %rax, %r14
movq 0x48(%rsp), %rdi
jmp 0x3e0c4
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x3e0ce
callq 0x13308
movq %rbx, %rdi
callq 0x10992
jmp 0x3e0db
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x16384
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x3e0f4
callq 0x13308
movq %r14, %rdi
callq 0x7430
// File: /workspace/github_cpp_makefile_star2_O1/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 0x263f
addsd (%rax), %xmm0
addq $0x8, %rax
jmp 0x2630
movsd %xmm0, -0x10(%rbp)
leaq 0x9f4d(%rip), %rdi      # 0xc598
callq 0x62a3
movq (%rbx), %rdx
movq 0x8(%rbx), %rax
subq %rdx, %rax
shrq $0x3, %rax
xorl %ecx, %ecx
testl %eax, %eax
setg %sil
jle 0x26d6
movsd 0x9f38(%rip), %xmm1     # 0xc5a8
movsd 0x9f28(%rip), %xmm2     # 0xc5a0
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
movsd -0x10(%rbp), %xmm2
mulsd %xmm0, %xmm2
movsd (%rdx), %xmm0
ucomisd %xmm2, %xmm0
ja 0x26d6
movl %eax, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
xorpd %xmm1, %xmm1
addsd %xmm1, %xmm0
leaq -0x1(%rsi), %rdi
xorl %ecx, %ecx
cmpq %rcx, %rdi
je 0x26ca
addsd 0x8(%rdx,%rcx,8), %xmm0
incq %rcx
ucomisd %xmm2, %xmm0
jbe 0x26ad
cmpq %rsi, %rcx
setb %sil
jmp 0x26d6
incq %rcx
cmpq %rsi, %rcx
setb %sil
movl %eax, %ecx
decl %eax
testb %sil, %sil
cmovnel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x258, %rsp            # imm = 0x258
movq %rdi, %rbx
leaq -0x278(%rbp), %rdi
movl $0x8, %edx
callq 0x2340
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x58(%rbx), %rax
movq %rax, -0x38(%rbp)
movq %rbx, -0x30(%rbp)
leaq 0x70(%rbx), %r12
xorl %r14d, %r14d
leaq -0x58(%rbp), %r13
leaq -0x70(%rbp), %rbx
movq -0x278(%rbp), %rax
movq -0x18(%rax), %rdi
leaq -0x278(%rbp), %r15
addq %r15, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x23b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x29fe
movq %rbx, %rdi
movq %r13, %rsi
movl $0x20, %edx
callq 0x2baa
movq -0x70(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x5b3c
movq -0x70(%rbp), %rsi
movq %r12, %rdi
callq 0x5b88
movl %r14d, (%rax)
incl %r14d
movq %rbx, %rdi
callq 0x5aee
jmp 0x298a
movq -0x30(%rbp), %rax
movq 0x58(%rax), %r14
movq 0x60(%rax), %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x2a1c
callq 0x2210
subq %r14, %rbx
shrq $0x5, %rbx
leaq -0x278(%rbp), %rdi
callq 0x2080
movl %ebx, %eax
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a53
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x5aee
jmp 0x2a56
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x58(%rbp), %rdi
cmpq %rax, %rdi
je 0x2a68
callq 0x2210
leaq -0x278(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: HMMLDA::~HMMLDA()
HMMLDA::~HMMLDA() {
	// Free up the 2d vectors
	int n_documents = documents.size();
	for(int document_idx = 0; document_idx < n_documents; document_idx++){
		documents[document_idx].clear();
		class_assignments[document_idx].clear();
		topic_assignments[document_idx].clear();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xa8(%rdi), %rax
movq 0xb0(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rsi
testl %esi, %esi
jle 0x2b04
movq 0xc0(%rbx), %rcx
movq 0xd8(%rbx), %rdx
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
shlq $0x3, %rsi
leaq (%rsi,%rsi,2), %rsi
xorl %edi, %edi
movq (%rax,%rdi), %r8
cmpq %r8, 0x8(%rax,%rdi)
je 0x2adb
movq %r8, 0x8(%rax,%rdi)
movq (%rdx,%rdi), %r8
cmpq %r8, 0x8(%rdx,%rdi)
je 0x2aeb
movq %r8, 0x8(%rdx,%rdi)
movq (%rcx,%rdi), %r8
cmpq %r8, 0x8(%rcx,%rdi)
je 0x2afb
movq %r8, 0x8(%rcx,%rdi)
addq $0x18, %rdi
cmpq %rdi, %rsi
jne 0x2acb
movq 0x168(%rbx), %rdi
testq %rdi, %rdi
je 0x2b15
callq 0x2210
leaq 0xa8(%rbx), %r14
movq 0x150(%rbx), %rdi
testq %rdi, %rdi
je 0x2b2d
callq 0x2210
leaq 0x138(%rbx), %rdi
callq 0x5aa4
leaq 0x120(%rbx), %rdi
callq 0x5aa4
leaq 0x108(%rbx), %rdi
callq 0x5aa4
leaq 0xf0(%rbx), %rdi
callq 0x5aa4
leaq 0xd8(%rbx), %rdi
callq 0x5aa4
leaq 0xc0(%rbx), %rdi
callq 0x5aa4
movq %r14, %rdi
callq 0x5aa4
leaq 0x70(%rbx), %rdi
callq 0x606a
leaq 0x58(%rbx), %rdi
callq 0x5aee
movq 0x38(%rbx), %rdi
addq $0x48, %rbx
cmpq %rbx, %rdi
je 0x2ba5
popq %rbx
popq %r14
popq %rbp
jmp 0x2210
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: HMMLDA::add_document(std::vector<int, std::allocator<int>>)
void HMMLDA::add_document(vector<int> document) {
	documents.push_back(document);
	// Sample random topics and classes for the words
	vector<int> topic_assignment(document.size(), 0);
	vector<int> class_assignment(document.size(), 0);
	int doc_size = document.size();
	for(int i = 0; i < doc_size; i++) {
		topic_assignment[i] = topic_dist(rng);
		if(document[i] == start_word_id)
			class_assignment[i] = START_WORD_CLASS;
		else if(document[i] ==  end_word_id)
			class_assignment[i] = END_WORD_CLASS;
		else
			class_assignment[i] = class_dist(rng);
	}
	// cout << "Printing topic assignments of a document" << endl;
	// print_vector<int>(topic_assignment);
	topic_assignments.push_back(topic_assignment);
	class_assignments.push_back(class_assignment);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %rbx
addq $0xa8, %rdi
callq 0x5c08
movq 0x8(%r12), %rsi
subq (%r12), %rsi
sarq $0x2, %rsi
xorl %r14d, %r14d
leaq -0x58(%rbp), %rdx
movl %r14d, (%rdx)
leaq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rcx
callq 0x5c44
movq 0x8(%r12), %rsi
subq (%r12), %rsi
sarq $0x2, %rsi
movl %r14d, (%r15)
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rdx
leaq -0x29(%rbp), %rcx
callq 0x5c44
movq 0x8(%r12), %r13
movq %r12, -0x40(%rbp)
subq (%r12), %r13
shrq $0x2, %r13
testl %r13d, %r13d
jle 0x2ce2
leaq 0x1508(%rbx), %r15
leaq 0x180(%rbx), %r12
leaq 0x1510(%rbx), %rax
movq %rax, -0x38(%rbp)
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movq %r15, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x6c3e
movq -0x70(%rbp), %rcx
movl %eax, (%rcx,%r14,4)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movl (%rax,%r14,4), %eax
cmpl 0x8(%rbx), %eax
jne 0x2cb9
movl 0x10(%rbx), %eax
jmp 0x2cd2
cmpl 0xc(%rbx), %eax
jne 0x2cc3
movl 0x14(%rbx), %eax
jmp 0x2cd2
movq -0x38(%rbp), %rdi
movq %r12, %rsi
movq %rdi, %rdx
callq 0x6c3e
movq -0x58(%rbp), %rcx
movl %eax, (%rcx,%r14,4)
incq %r14
cmpq %r14, %r13
jne 0x2c8e
leaq 0xc0(%rbx), %rdi
leaq -0x70(%rbp), %rsi
callq 0x5c08
addq $0xd8, %rbx
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x5c08
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x2d13
callq 0x2210
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x2d21
callq 0x2210
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2d48
jmp 0x2d37
movq %rax, %rbx
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x2d48
callq 0x2210
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x2d56
callq 0x2210
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: HMMLDA::train(int, int)
void HMMLDA::train(int iterations, int save_freq) {
	save_assignments(0);
	// Run Gibbs sampling
	// iterations = number of full samplings of the corpus
	int n_documents = documents.size();
	for(int i = 1; i <= iterations; i++) {
		std::clock_t start = std::clock();
		for(int document_idx = 0; document_idx < n_documents; document_idx++) {
			int doc_size = documents[document_idx].size();
			for(int word_idx = 0; word_idx < doc_size; word_idx++) {
				draw_class(document_idx, word_idx, doc_size);
				draw_topic(document_idx, word_idx, doc_size);
			}
		}
		std::cout << "Time for iteration " << i <<": " << (std::clock() - start) / (double)(CLOCKS_PER_SEC) << " s" << endl;
		if((i%save_freq) == 0)
			save_assignments(i);
		// cout << endl << endl << endl << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, -0x30(%rbp)
movl %esi, %ebx
movq %rdi, %r15
xorl %esi, %esi
callq 0x3720
movl %ebx, -0x2c(%rbp)
testl %ebx, %ebx
jle 0x3710
movq 0xb0(%r15), %rax
subq 0xa8(%r15), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r12
movq %r12, -0x38(%rbp)
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
movl $0x1, %eax
movq %rax, -0x48(%rbp)
callq 0x2140
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x38(%rbp)
jle 0x364c
xorl %r14d, %r14d
movq 0xa8(%r15), %rax
leaq (%r14,%r14,2), %rcx
movq 0x8(%rax,%rcx,8), %r13
subq (%rax,%rcx,8), %r13
shrq $0x2, %r13
testl %r13d, %r13d
jle 0x3644
xorl %ebx, %ebx
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
movl %r13d, %ecx
callq 0x3f4e
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x45de
incl %ebx
cmpl %ebx, %r13d
jne 0x3620
incq %r14
cmpq %r12, %r14
jne 0x3601
movl $0x13, %edx
movq 0x7980(%rip), %rbx      # 0xafd8
movq %rbx, %rdi
leaq 0x4a43(%rip), %rsi      # 0x80a5
callq 0x2270
movq %rbx, %rdi
movq -0x48(%rbp), %r14
movl %r14d, %esi
callq 0x2380
movq %rax, %rbx
movl $0x2, %edx
movq %rax, %rdi
leaq 0x49fa(%rip), %rsi      # 0x8082
callq 0x2270
callq 0x2140
subq -0x40(%rbp), %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x4962(%rip), %xmm0     # 0x8008
movq %rbx, %rdi
callq 0x2330
movq %rax, %rbx
movl $0x2, %edx
movq %rax, %rdi
leaq 0x49f9(%rip), %rsi      # 0x80b9
callq 0x2270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movl %r14d, %eax
cltd
idivl -0x30(%rbp)
testl %edx, %edx
jne 0x3702
movq %r15, %rdi
movl %r14d, %esi
callq 0x3720
leal 0x1(%r14), %eax
cmpl -0x2c(%rbp), %r14d
jne 0x35eb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: HMMLDA::add_counts_for_new_document(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, int)
void HMMLDA::add_counts_for_new_document(vector<int> &document, vector<int> &topic_assignment, vector<int> &class_assignment, vector<int> &num_words_in_document_assigned_to_topic, int doc_size) {
	int previous_class = -1;
	for(int word_idx = 0; word_idx < doc_size; word_idx++) {
		int word = document[word_idx];
		if(class_assignment[word_idx] == 0) {		// Count the topic only when the class is 0
			//TODO: Think about how to implement num_words_in_doc_assigned_to_topic for a new document
			num_words_in_document_assigned_to_topic[topic_assignment[word_idx]]++;
			num_same_words_assigned_to_topic[word][topic_assignment[word_idx]]++;
			num_words_assigned_to_topic[topic_assignment[word_idx]]++;
		}
		num_same_words_assigned_to_class[word][class_assignment[word_idx]]++;
		num_words_assigned_to_class[class_assignment[word_idx]]++;
		int current_class = class_assignment[word_idx];
		if(previous_class != -1)
			num_transitions[previous_class][current_class]++;
		previous_class = current_class;
	}
}

// Assembly:
testl %r9d, %r9d
jle 0x4906
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rsi), %rax
movq (%rcx), %rcx
movq (%rdx), %rdx
movq (%r8), %rsi
movq %rsi, -0x30(%rbp)
movq 0x108(%rdi), %r8
movq 0x120(%rdi), %r10
movq 0x150(%rdi), %r11
movq 0x168(%rdi), %rbx
movq 0x138(%rdi), %rdi
movl %r9d, %r9d
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
xorl %r14d, %r14d
movslq (%rax,%r14,4), %r12
cmpl $0x0, (%rcx,%r14,4)
leaq (%r12,%r12,2), %r12
jne 0x48c2
movslq (%rdx,%r14,4), %r13
movq -0x30(%rbp), %rsi
incl (%rsi,%r13,4)
movslq (%rdx,%r14,4), %r13
movq (%r8,%r12,8), %rsi
incl (%rsi,%r13,4)
movslq (%rdx,%r14,4), %rsi
incl (%r11,%rsi,4)
movslq (%rcx,%r14,4), %rsi
movq (%r10,%r12,8), %r12
incl (%r12,%rsi,4)
movslq (%rcx,%r14,4), %rsi
incl (%rbx,%rsi,4)
movl (%rcx,%r14,4), %r12d
cmpl $-0x1, %r15d
je 0x48f1
movslq %r12d, %rsi
movslq %r15d, %r15
leaq (%r15,%r15,2), %r15
movq (%rdi,%r15,8), %r15
incl (%r15,%rsi,4)
incq %r14
movl %r12d, %r15d
cmpq %r14, %r9
jne 0x4893
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop