LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x5881d
movq -0x28(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x58800
cmpl $0x2, -0x14(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x588b5
movq -0x28(%rbp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x5881b
cmpl $0x1, -0x14(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x588b5
jmp 0x5881d
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x5886f
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x44e80
movq -0x28(%rbp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0x5885a
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x18(%rbp), %ecx
movl %ecx, -0x18(%rbp)
cmpl $0x2, 0x28(%rax)
jne 0x58858
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5885a
movq -0x28(%rbp), %rax
cmpl $0x2, 0x2c(%rax)
jne 0x5886d
movl -0x14(%rbp), %eax
xorl $0x3, %eax
movl %eax, -0x14(%rbp)
jmp 0x5886f
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x44e60
movl (%rax), %eax
movl -0x18(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1d(%rbp)
cmpl $0x2, -0x14(%rbp)
jne 0x588ad
movb -0x1d(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x588b5
movb -0x1d(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x10, %rdi
callq 0x4a5e0
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jae 0x59394
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x55e80
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x59411
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, -0x44(%rbp)
addq $0x10, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x44e60
movl -0x44(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r8d
addl $0x1, %r8d
callq 0x42c70
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movb 0x10(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x59404
movq -0x18(%rbp), %rax
movb 0x10(%rax), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5941d
jmp 0x59406
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5939b
movq -0x18(%rbp), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x5948f
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movslq -0x18(%rbp), %rsi
callq 0x44e60
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
addq $0x10, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x44e60
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl (%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5953b
cmpl $-0x2, -0x14(%rbp)
jne 0x594ce
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movslq -0x18(%rbp), %rsi
callq 0x44e60
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x30(%rbp)
addq $0x10, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x44e60
movq %rax, %rcx
movl -0x30(%rbp), %eax
cmpl (%rcx), %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5953b
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x59513
movl $0x8, %edi
callq 0x8160
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x8190
movq -0x38(%rbp), %rdi
callq 0x15890
movq -0x38(%rbp), %rdi
leaq 0x49c09(%rip), %rsi     # 0xa3110
leaq -0x43bce(%rip), %rdx    # 0x15940
callq 0x84b0
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movslq -0x18(%rbp), %rsi
callq 0x44e60
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x5a371
cmpl $0x2, -0x14(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5a39f
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x5a387
cmpl $0x1, -0x14(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5a39f
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x44e60
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x5a35d
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x5a401
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x44e60
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5a3da
movl $0x0, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
je 0x5a435
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movslq -0x24(%rbp), %rsi
callq 0x44e60
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5a40e
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x5a46a
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
addq $0x10, %rdi
movslq -0x24(%rbp), %rsi
callq 0x44e60
movl (%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x5a441
jmp 0x5a46c
movl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x5a495
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
addq $0x10, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x44e60
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x5a46c
jmp 0x5a497
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x5a4cd
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x44e60
movq -0x30(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
addq $0x10, %rdi
movslq -0x24(%rbp), %rsi
callq 0x44e60
movl (%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x5a497
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x4adff(%rip), %rdi     # 0xa5900
leaq 0x18aca(%rip), %rsi     # 0x735d2
callq 0x50ce0
testb $0x1, %al
jne 0x5ab2a
leaq 0x4ade8(%rip), %rdi     # 0xa5900
leaq 0x18ab7(%rip), %rsi     # 0x735d6
callq 0x50ce0
testb $0x1, %al
jne 0x5ab2a
jmp 0x5ab75
leaq -0x9(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x84e0
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x18c51(%rip), %rsi     # 0x73797
callq 0x10f40
jmp 0x5ab4d
leaq -0x9(%rbp), %rdi
callq 0x8320
jmp 0x5ac90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x8320
jmp 0x5ac9d
leaq 0x4ad84(%rip), %rdi     # 0xa5900
leaq 0x18a57(%rip), %rsi     # 0x735da
callq 0x50ce0
testb $0x1, %al
jne 0x5aba5
leaq 0x4ad6d(%rip), %rdi     # 0xa5900
leaq 0x18a44(%rip), %rsi     # 0x735de
callq 0x50ce0
testb $0x1, %al
jne 0x5aba5
jmp 0x5abf0
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x84e0
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x18bf0(%rip), %rsi     # 0x737b1
callq 0x10f40
jmp 0x5abc8
leaq -0x1d(%rbp), %rdi
callq 0x8320
jmp 0x5ac90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x8320
jmp 0x5ac9d
movb $0x1, -0x42(%rbp)
movl $0x28, %edi
callq 0x8160
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x84e0
movq -0x70(%rbp), %rdx
leaq 0x189c8(%rip), %rsi     # 0x735e2
leaq -0x40(%rbp), %rdi
callq 0x10f40
jmp 0x5ac25
movq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5b840
jmp 0x5ac34
movq -0x78(%rbp), %rdi
movb $0x0, -0x42(%rbp)
leaq 0x4993d(%rip), %rsi     # 0xa4580
leaq 0xc66(%rip), %rdx       # 0x5b8b0
callq 0x84b0
jmp 0x5aca6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x5ac74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8578
leaq -0x41(%rbp), %rdi
callq 0x8320
testb $0x1, -0x42(%rbp)
jne 0x5ac85
jmp 0x5ac8e
movq -0x78(%rbp), %rdi
callq 0x8200
jmp 0x5ac9d
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x84d0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %ecx
leaq 0x4aa35(%rip), %rax     # 0xa5c50
movl %ecx, (%rax)
movl -0x8(%rbp), %esi
leaq -0x28(%rbp), %rdi
movl $0x1, %edx
callq 0x5ad80
leaq -0x38(%rbp), %rdi
callq 0x5ad00
jmp 0x5b239
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x5c3a0
jmp 0x5b24c
leaq 0x4a695(%rip), %rdi     # 0xa58e8
leaq -0x18(%rbp), %rsi
callq 0x5c440
leaq -0x18(%rbp), %rdi
callq 0x5b6a0
leaq -0x38(%rbp), %rdi
callq 0x5b6a0
leaq -0x28(%rbp), %rdi
callq 0x5b6a0
cmpl $0x0, -0x4(%rbp)
jle 0x5b347
movl -0x4(%rbp), %esi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
xorl %edx, %edx
callq 0x5ad80
leaq 0x4a64b(%rip), %rsi     # 0xa58e8
leaq -0x78(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x5c200
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x5c3a0
jmp 0x5b2c6
leaq 0x4a61b(%rip), %rdi     # 0xa58e8
leaq -0x58(%rbp), %rsi
callq 0x5c440
leaq -0x58(%rbp), %rdi
callq 0x5b6a0
leaq -0x78(%rbp), %rdi
callq 0x5b6a0
leaq -0x68(%rbp), %rdi
callq 0x5b6a0
jmp 0x5b347
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5b316
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5b6a0
leaq -0x28(%rbp), %rdi
callq 0x5b6a0
jmp 0x5b3f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5b6a0
leaq -0x68(%rbp), %rdi
callq 0x5b6a0
jmp 0x5b3f4
leaq -0x98(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x5ad40
leaq 0x4a587(%rip), %rsi     # 0xa58e8
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x5c200
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x5c3a0
jmp 0x5b390
leaq 0x4a551(%rip), %rdi     # 0xa58e8
leaq -0x88(%rbp), %rsi
callq 0x5c440
leaq -0x88(%rbp), %rdi
callq 0x5b6a0
leaq -0xa8(%rbp), %rdi
callq 0x5b6a0
leaq -0x98(%rbp), %rdi
callq 0x5b6a0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x5b6a0
leaq -0x98(%rbp), %rdi
callq 0x5b6a0
movq -0x40(%rbp), %rdi
callq 0x84d0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x83e0
movq -0x58(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x29690
jmp 0x5b43a
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x81e0
movq %rax, %rcx
movl -0x6c(%rbp), %eax
cmpl %ecx, %eax
jge 0x5b59f
movslq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8560
movq %rax, -0x78(%rbp)
jmp 0x5b471
movq -0x78(%rbp), %rax
movsbl (%rax), %edi
callq 0x8460
cmpl $0x0, %eax
je 0x5b4d7
movslq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8560
movq %rax, -0x80(%rbp)
jmp 0x5b495
movq -0x68(%rbp), %rdi
movq -0x80(%rbp), %rax
movsbl (%rax), %esi
callq 0x81b0
jmp 0x5b4a7
jmp 0x5b58f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5b5c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8578
jmp 0x5b5c8
movslq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8560
movq %rax, -0x88(%rbp)
jmp 0x5b4ed
movq -0x68(%rbp), %rdi
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x4c(%rbp)
leaq 0x18112(%rip), %rsi     # 0x73617
callq 0x82a0
jmp 0x5b50c
cmpl $0x0, -0x4c(%rbp)
jge 0x5b52a
movq -0x68(%rbp), %rdi
movl $0x4e, %esi
callq 0x81b0
jmp 0x5b522
xorl %eax, %eax
subl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0x5b52c
cmpl $0x0, -0x4c(%rbp)
jle 0x5b57b
movq -0x68(%rbp), %rdi
movslq -0x4c(%rbp), %rcx
movl %ecx, %eax
imulq $0x4ec4ec4f, %rcx, %rdx # imm = 0x4EC4EC4F
movq %rdx, %rcx
shrq $0x3f, %rcx
sarq $0x23, %rdx
addl %ecx, %edx
movl %edx, %ecx
leal (%rcx,%rcx,4), %esi
movl %esi, %ecx
leal (%rcx,%rcx,4), %ecx
addl %edx, %ecx
subl %ecx, %eax
addl $0x61, %eax
movsbl %al, %esi
callq 0x81b0
jmp 0x5b56b
movl -0x4c(%rbp), %eax
movl $0x1a, %ecx
cltd
idivl %ecx
movl %eax, -0x4c(%rbp)
jmp 0x5b52c
movq -0x68(%rbp), %rdi
leaq 0x18091(%rip), %rsi     # 0x73617
callq 0x82a0
jmp 0x5b58d
jmp 0x5b58f
jmp 0x5b591
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x5b441
movb $0x1, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8578
testb $0x1, -0x11(%rbp)
jne 0x5b5bb
movq -0x68(%rbp), %rdi
callq 0x8578
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x8578
movq -0x40(%rbp), %rdi
callq 0x84d0
nopw (%rax,%rax)
// File: eryxcc[P]lois/src/solvers.cpp
// Function: lois::SolverBasic::solveEnv()
virtual int solveEnv() {
    rbool phi = outenv();
    if(phi.isTrue()) return 2;
    if(phi.isFalse()) return 0;
    return 1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x464da(%rip), %rsi     # 0xa5830
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x11030
leaq 0x46476(%rip), %rsi     # 0xa57e0
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x173b0
leaq 0x46472(%rip), %rsi     # 0xa57f0
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x173b0
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rcx
movq -0x68(%rbp), %r8
leaq -0x20(%rbp), %rdi
xorl %edx, %edx
callq 0x3e180
jmp 0x5f3a4
leaq -0x50(%rbp), %rdi
callq 0x14b20
leaq -0x40(%rbp), %rdi
callq 0x14b20
leaq -0x30(%rbp), %rdi
callq 0x11060
leaq -0x20(%rbp), %rdi
callq 0x29750
testb $0x1, %al
jne 0x5f3ce
jmp 0x5f407
movl $0x2, -0x4(%rbp)
movl $0x1, -0x60(%rbp)
jmp 0x5f434
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x14b20
leaq -0x40(%rbp), %rdi
callq 0x14b20
leaq -0x30(%rbp), %rdi
callq 0x11060
jmp 0x5f449
leaq -0x20(%rbp), %rdi
callq 0x45150
testb $0x1, %al
jne 0x5f416
jmp 0x5f426
movl $0x0, -0x4(%rbp)
movl $0x1, -0x60(%rbp)
jmp 0x5f434
movl $0x1, -0x4(%rbp)
movl $0x1, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x11060
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x84d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x11030
movq -0x50(%rbp), %rdi
callq 0x5a6e0
movb %al, -0x41(%rbp)
jmp 0x5fed7
leaq -0x28(%rbp), %rdi
callq 0x11060
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x5fee9
jmp 0x5ff0f
movl $0x1, -0x4(%rbp)
jmp 0x60059
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x11060
jmp 0x60062
movq -0x60(%rbp), %rdi
leaq 0x4590e(%rip), %rax     # 0xa5828
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
callq 0x3ece0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rdi
movl 0x8(%rax), %ecx
leaq 0x458dd(%rip), %rax     # 0xa5820
movl %ecx, (%rax)
callq 0x3ece0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movb %al, -0x61(%rbp)
jmp 0x5ff5b
movb -0x61(%rbp), %al
andb $0x1, %al
movb %al, -0x35(%rbp)
leaq 0x458b6(%rip), %rax     # 0xa5820
cmpl $0x0, (%rax)
jle 0x6001b
movq -0x58(%rbp), %rax
testb $0x1, 0xc(%rax)
je 0x60006
movq -0x58(%rbp), %rax
movzbl -0x35(%rbp), %esi
andl $0x1, %esi
movl 0x8(%rax), %edx
leaq 0x4588a(%rip), %rax     # 0xa5820
movl (%rax), %eax
subl %eax, %edx
leaq 0x13678(%rip), %rdi     # 0x73619
xorl %eax, %eax
callq 0x8050
jmp 0x5ffaa
jmp 0x60006
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x60062
movq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x83b0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x60080
movq -0x70(%rbp), %rdi
callq 0x8120
movq -0x58(%rbp), %rax
testb $0x1, 0xc(%rax)
je 0x60039
leaq 0x1363c(%rip), %rdi     # 0x73637
xorl %eax, %eax
callq 0x8050
jmp 0x60004
jmp 0x60039
movb -0x35(%rbp), %dl
xorl %eax, %eax
movl $0x2, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x60059
jmp 0x60052
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3ee80
callq 0x8490
jmp 0x60050
movl $0x1, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3ee80
callq 0x8490
jmp 0x60059
jmp 0x60062
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x84d0
movq %rax, %rdi
callq 0x14770
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x5070, %rsp           # imm = 0x5070
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x5058(%rbp)
movl $0x0, -0x5014(%rbp)
movq -0x5058(%rbp), %rdi
addq $0x8, %rdi
callq 0x81c0
movq -0x5058(%rbp), %rax
movl 0x21c(%rax), %edi
leaq -0x5010(%rbp), %rsi
movl $0x5000, %edx           # imm = 0x5000
callq 0x8410
movl %eax, -0x5018(%rbp)
cmpl $0x0, -0x5018(%rbp)
jg 0x63346
jmp 0x63466
movq -0x5058(%rbp), %rax
movl -0x5018(%rbp), %ecx
addl -0x5014(%rbp), %ecx
movl %ecx, -0x5014(%rbp)
movl 0x20c(%rax), %edi
leaq -0x5010(%rbp), %rsi
movslq -0x5018(%rbp), %rdx
callq 0x80f0
movslq -0x5018(%rbp), %rcx
cmpq %rcx, %rax
je 0x63461
movb $0x1, -0x504d(%rbp)
movl $0x28, %edi
callq 0x8160
movq %rax, -0x5068(%rbp)
leaq -0x5039(%rbp), %rdi
movq %rdi, -0x5060(%rbp)
callq 0x84e0
movq -0x5060(%rbp), %rdx
leaq 0x103f4(%rip), %rsi     # 0x737b5
leaq -0x5038(%rbp), %rdi
callq 0x10f40
jmp 0x633cf
movq -0x5068(%rbp), %rdi
leaq -0x5038(%rbp), %rsi
callq 0x5b840
jmp 0x633e4
movq -0x5068(%rbp), %rdi
movb $0x0, -0x504d(%rbp)
leaq 0x41187(%rip), %rsi     # 0xa4580
leaq -0x7b50(%rip), %rdx     # 0x5b8b0
callq 0x84b0
jmp 0x63498
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x5048(%rbp)
movl %eax, -0x504c(%rbp)
jmp 0x6343c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x5048(%rbp)
movl %eax, -0x504c(%rbp)
leaq -0x5038(%rbp), %rdi
callq 0x8578
leaq -0x5039(%rbp), %rdi
callq 0x8320
testb $0x1, -0x504d(%rbp)
jne 0x63453
jmp 0x6345f
movq -0x5068(%rbp), %rdi
callq 0x8200
jmp 0x6348c
jmp 0x63304
cmpl $0x0, -0x5014(%rbp)
je 0x63483
movl -0x5014(%rbp), %esi
leaq 0x1034b(%rip), %rdi     # 0x737c7
movb $0x0, %al
callq 0x8050
addq $0x5070, %rsp           # imm = 0x5070
popq %rbp
retq
movq -0x5048(%rbp), %rdi
callq 0x84d0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x83e0
jmp 0x634d1
movq -0x60(%rbp), %rax
movl 0x218(%rax), %edi
leaq -0x34(%rbp), %rsi
movl $0x1, %edx
callq 0x8230
movl %eax, -0x74(%rbp)
jmp 0x634ee
movq -0x60(%rbp), %rcx
movl -0x74(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl 0x218(%rcx), %eax
jne 0x63571
movq -0x60(%rbp), %rax
movb $0x1, 0x25c(%rax)
leaq -0x45(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x84e0
movq -0x70(%rbp), %rdi
movq -0x80(%rbp), %rdx
leaq 0x10195(%rip), %rsi     # 0x736bf
callq 0x10f40
jmp 0x63531
leaq -0x45(%rbp), %rdi
callq 0x8320
movl $0x1, -0x4c(%rbp)
jmp 0x63651
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x63667
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x45(%rbp), %rdi
callq 0x8320
jmp 0x63667
movq -0x60(%rbp), %rax
movl 0x210(%rax), %edi
leaq -0x4d(%rbp), %rsi
movl $0x1, %edx
callq 0x8410
movq %rax, -0x88(%rbp)
jmp 0x63592
movq -0x88(%rbp), %rax
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jge 0x635b1
callq 0x8040
cmpl $0xb, (%rax)
jne 0x635b1
jmp 0x634cf
cmpl $0x0, -0x54(%rbp)
jle 0x635e9
movsbl -0x4d(%rbp), %eax
cmpl $0xa, %eax
jne 0x635d6
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x81a0
movl $0x1, -0x4c(%rbp)
jmp 0x63651
movsbl -0x4d(%rbp), %esi
leaq -0x30(%rbp), %rdi
callq 0x81b0
jmp 0x635e5
jmp 0x635e7
jmp 0x635e9
cmpl $0x0, -0x54(%rbp)
jge 0x6364c
movq -0x60(%rbp), %rax
movb $0x1, 0x25c(%rax)
leaq -0x55(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x84e0
movq -0x70(%rbp), %rdi
movq -0x90(%rbp), %rdx
leaq 0x100a3(%rip), %rsi     # 0x736bf
callq 0x10f40
jmp 0x63623
leaq -0x55(%rbp), %rdi
callq 0x8320
movl $0x1, -0x4c(%rbp)
jmp 0x63651
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x55(%rbp), %rdi
callq 0x8320
jmp 0x63667
jmp 0x634cf
leaq -0x30(%rbp), %rdi
callq 0x8578
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x8578
movq -0x40(%rbp), %rdi
callq 0x84d0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x4115d(%rip), %rcx     # 0xa48e8
addq $0x10, %rcx
movq %rcx, (%rax)
testb $0x1, 0x4215f(%rip)     # 0xa58f8
jne 0x637a8
movq -0x18(%rbp), %rax
testb $0x1, 0x25c(%rax)
je 0x637d6
movq -0x18(%rbp), %rax
movl 0x20c(%rax), %edi
callq 0x8530
jmp 0x637b9
movq -0x18(%rbp), %rax
movl 0x210(%rax), %edi
callq 0x8530
jmp 0x637ca
movl $0x1, -0xc(%rbp)
jmp 0x6386d
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq 0x1002c(%rip), %rsi     # 0x73811
callq 0x82b0
movq %rax, -0x20(%rbp)
jmp 0x637f0
movq -0x20(%rbp), %rdi
movq 0x417b5(%rip), %rsi     # 0xa4fb0
callq 0x8300
jmp 0x63802
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x8400
jmp 0x63811
movq -0x18(%rbp), %rdi
callq 0x632e0
jmp 0x6381c
movq -0x18(%rbp), %rax
movl 0x218(%rax), %edi
leaq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x8230
jmp 0x63833
movq -0x18(%rbp), %rax
movl 0x21c(%rax), %edi
callq 0x8530
jmp 0x63844
movq -0x18(%rbp), %rax
movl 0x20c(%rax), %edi
callq 0x8530
jmp 0x63855
movq -0x18(%rbp), %rax
movl 0x210(%rax), %edi
callq 0x8530
jmp 0x63866
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
addq $0x260, %rdi            # imm = 0x260
callq 0x14b20
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x8430
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x14770
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, -0x14(%rbp)
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5cfa0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5ce20
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x69cd0
testb $0x1, %al
jne 0x6996a
jmp 0x69a55
leaq -0x28(%rbp), %rdi
callq 0x69d10
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x5c200
movq -0x90(%rbp), %rdi
callq 0x20350
movq -0x70(%rbp), %rsi
movq %rax, -0x88(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x11030
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, -0x74(%rbp)
jmp 0x699c2
leaq -0x58(%rbp), %rdi
callq 0x11060
movl -0x74(%rbp), %eax
movl %eax, -0x44(%rbp)
cmpl $0x3, -0x14(%rbp)
jne 0x69a03
movl $0x3, -0x68(%rbp)
jmp 0x69a31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x11060
leaq -0x40(%rbp), %rdi
callq 0x5b6a0
jmp 0x69aad
cmpl $0x1, -0x14(%rbp)
jne 0x69a11
movl -0x44(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x69a28
cmpl $0x1, -0x44(%rbp)
je 0x69a26
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x69a26
movl $0x3, -0x14(%rbp)
jmp 0x69a28
jmp 0x69a2a
movl $0x0, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5b6a0
movl -0x68(%rbp), %eax
testl %eax, %eax
je 0x69a45
jmp 0x69a43
jmp 0x69a47
jmp 0x69a47
leaq -0x28(%rbp), %rdi
callq 0x69d30
jmp 0x69954
cmpl $0x3, -0x14(%rbp)
jne 0x69aa1
movl $0x8, %edi
callq 0x8160
movq %rax, %rdi
movq %rdi, -0x98(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x8190
movq -0x98(%rbp), %rdi
callq 0x69d50
movq -0x98(%rbp), %rdi
leaq 0x3b163(%rip), %rsi     # 0xa4bf8
leaq 0x2f4(%rip), %rdx       # 0x69d90
callq 0x84b0
movl -0x14(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x84d0
nopw %cs:(%rax,%rax)
// File: eryxcc[P]lois/src/solvers.cpp
// Function: lois::SolverCompare::solveEnv()
virtual int solveEnv() {
    int endr = 1;
    for(solveptr s: solvers) {
      int r = s->solveEnv();
      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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, -0xc(%rbp)
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5cfa0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5ce20
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x69cd0
testb $0x1, %al
jne 0x69b0f
jmp 0x69bc3
leaq -0x20(%rbp), %rdi
callq 0x69d10
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x5c200
movq -0x60(%rbp), %rdi
callq 0x20350
movq %rax, %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movl %eax, -0x54(%rbp)
jmp 0x69b42
movl -0x54(%rbp), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x3, -0xc(%rbp)
jne 0x69b71
movl $0x3, -0x50(%rbp)
jmp 0x69b9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5b6a0
jmp 0x69c0f
cmpl $0x1, -0xc(%rbp)
jne 0x69b7f
movl -0x3c(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x69b96
cmpl $0x1, -0x3c(%rbp)
je 0x69b94
movl -0x3c(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x69b94
movl $0x3, -0xc(%rbp)
jmp 0x69b96
jmp 0x69b98
movl $0x0, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5b6a0
movl -0x50(%rbp), %eax
testl %eax, %eax
je 0x69bb3
jmp 0x69bb1
jmp 0x69bb5
jmp 0x69bb5
leaq -0x20(%rbp), %rdi
callq 0x69d30
jmp 0x69af9
cmpl $0x3, -0xc(%rbp)
jne 0x69c06
movl $0x8, %edi
callq 0x8160
movq %rax, %rdi
movq %rdi, -0x68(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x8190
movq -0x68(%rbp), %rdi
callq 0x69d50
movq -0x68(%rbp), %rdi
leaq 0x3affe(%rip), %rsi     # 0xa4bf8
leaq 0x18f(%rip), %rdx       # 0x69d90
callq 0x84b0
movl -0xc(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x84d0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x5aa10
movq -0x68(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x28, %rdi
callq 0x20350
movq -0x60(%rbp), %rsi
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x11030
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, -0x48(%rbp)
jmp 0x6ab1f
leaq -0x30(%rbp), %rdi
callq 0x11060
movl -0x48(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq 0x3a7b3(%rip), %rax     # 0xa52e8
movq (%rax), %rax
movq %rax, -0x44(%rbp)
movq -0x44(%rbp), %rsi
movq 0x3a491(%rip), %rdi     # 0xa4fd8
callq 0x6afb0
movq -0x68(%rbp), %rdi
addq $0x8, %rdi
callq 0x8130
movq %rax, -0x78(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x6c(%rbp)
callq 0x5aa10
movq -0x78(%rbp), %rsi
movl -0x6c(%rbp), %edx
movq %rax, %rcx
subq -0x18(%rbp), %rcx
leaq 0x904d(%rip), %rdi      # 0x73bca
movb $0x0, %al
callq 0x8050
movl -0x1c(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x11060
movq -0x38(%rbp), %rdi
callq 0x84d0
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x5aa10
movq -0x30(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x28, %rdi
callq 0x20350
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, -0x14(%rbp)
leaq 0x3a6fb(%rip), %rax     # 0xa52e8
movq (%rax), %rax
movq %rax, -0x1c(%rbp)
movq -0x1c(%rbp), %rsi
movq 0x3a3d9(%rip), %rdi     # 0xa4fd8
callq 0x6afb0
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x8130
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
callq 0x5aa10
movq -0x28(%rbp), %rsi
movl -0x20(%rbp), %edx
movq %rax, %rcx
subq -0x10(%rbp), %rcx
leaq 0x8f95(%rip), %rdi      # 0x73bca
movb $0x0, %al
callq 0x8050
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl 0x3a997(%rip), %eax     # 0xa5960
movl %eax, 0x3a991(%rip)     # 0xa5960
cmpl $0x0, 0x3a98a(%rip)     # 0xa5960
jl 0x6afee
cmpl $0x2, -0x4(%rbp)
jl 0x6afee
movq -0x10(%rbp), %rdi
movq 0x39fc7(%rip), %rsi     # 0xa4fb0
callq 0x8300
cmpl $0x0, 0x3a96b(%rip)     # 0xa5960
jl 0x6b02c
cmpl $0x1, -0x4(%rbp)
jl 0x6b02c
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x3a953(%rip), %eax     # 0xa5960
jge 0x6b02a
movq -0x10(%rbp), %rdi
leaq 0x8848(%rip), %rsi      # 0x73862
callq 0x82b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6b004
jmp 0x6b02c
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
leaq 0x37286(%rip), %rdi     # 0xa5968
callq 0x6c270
movl $0x48, %edi
callq 0x82d0
movq %rax, -0xc8(%rbp)
movb $0x1, -0xb1(%rbp)
leaq 0x373e2(%rip), %rsi     # 0xa5ae8
leaq -0x28(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x11380
movq -0xc0(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x113d0
jmp 0x6e728
leaq 0x37389(%rip), %rsi     # 0xa5ab8
leaq -0x60(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x11380
movq -0xd0(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x113d0
jmp 0x6e751
leaq 0x373c0(%rip), %rsi     # 0xa5b18
leaq -0x88(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x11380
movq -0xd8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x113d0
jmp 0x6e77d
leaq 0x373ac(%rip), %rsi     # 0xa5b30
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x11380
movq -0xe0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x113d0
jmp 0x6e7ac
movq -0xc8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x70(%rbp), %rcx
leaq -0x98(%rbp), %r8
callq 0x6f0a0
jmp 0x6e7cd
movq -0xc8(%rbp), %rax
movb $0x0, -0xb1(%rbp)
movq %rax, 0x37426(%rip)     # 0xa5c08
leaq -0x98(%rbp), %rdi
callq 0x114d0
leaq -0xb0(%rbp), %rdi
callq 0x114f0
leaq -0x70(%rbp), %rdi
callq 0x114d0
leaq -0x88(%rbp), %rdi
callq 0x114f0
leaq -0x48(%rbp), %rdi
callq 0x114d0
leaq -0x60(%rbp), %rdi
callq 0x114f0
leaq -0x10(%rbp), %rdi
callq 0x114d0
leaq -0x28(%rbp), %rdi
callq 0x114f0
movl $0xc350, %edi           # imm = 0xC350
movl $0x77359400, %esi       # imm = 0x77359400
callq 0x5b200
leaq 0x370b7(%rip), %rdi     # 0xa5900
leaq 0x4d82(%rip), %rsi      # 0x735d2
callq 0x83c0
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x6e8ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x6e8d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x6e8c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x6e8ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x114d0
leaq -0xb0(%rbp), %rdi
callq 0x114f0
leaq -0x70(%rbp), %rdi
callq 0x114d0
leaq -0x88(%rbp), %rdi
callq 0x114f0
leaq -0x48(%rbp), %rdi
callq 0x114d0
leaq -0x60(%rbp), %rdi
callq 0x114f0
leaq -0x10(%rbp), %rdi
callq 0x114d0
leaq -0x28(%rbp), %rdi
callq 0x114f0
testb $0x1, -0xb1(%rbp)
jne 0x6e8fe
jmp 0x6e90f
movq -0xc8(%rbp), %rdi
movl $0x48, %esi
callq 0x82e0
jmp 0x6e911
movq -0x30(%rbp), %rdi
callq 0x84d0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x20170
leaq -0x38(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x1af40
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x1b320
jmp 0x6f617
movq -0x98(%rbp), %rdi
movb $0x0, -0x45(%rbp)
callq 0x119e0
jmp 0x6f629
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x20220
movq -0xa0(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x445f0
jmp 0x6f64f
leaq -0x68(%rbp), %rdi
callq 0x14cf0
movq -0x98(%rbp), %rax
addq $0x10, %rax
movq %rax, -0xa8(%rbp)
leaq 0x361bf(%rip), %rdx     # 0xa5830
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rcx
callq 0x2faa0
jmp 0x6f684
movq -0xa8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x70610
jmp 0x6f696
leaq -0x78(%rbp), %rdi
callq 0x17070
movb $0x1, -0x45(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x11360
testb $0x1, -0x45(%rbp)
jne 0x6f713
jmp 0x6f707
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6f741
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x14cf0
jmp 0x6f735
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6f6fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x17070
leaq -0x58(%rbp), %rdi
callq 0x11360
jmp 0x6f735
movq -0x98(%rbp), %rdi
callq 0x11960
leaq -0x38(%rbp), %rdi
callq 0x1b4c0
leaq -0x20(%rbp), %rdi
callq 0x10f20
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x11960
leaq -0x38(%rbp), %rdi
callq 0x1b4c0
leaq -0x20(%rbp), %rdi
callq 0x10f20
movq -0x40(%rbp), %rdi
callq 0x84d0
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x8850
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rdi
callq 0x88c0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8880
testb $0x1, %al
jne 0x36c1
jmp 0x36e9
leaq -0x20(%rbp), %rdi
callq 0x88f0
movsd (%rax), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x8910
movq %rax, -0x30(%rbp)
jmp 0x36a1
leaq 0x17f00(%rip), %rdi     # 0x1b5f0
leaq 0x17ef1(%rip), %rsi     # 0x1b5e8
callq 0x8950
movq -0x58(%rbp), %rdi
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
callq 0x8980
movl %eax, -0x4c(%rbp)
movl $0x0, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jge 0x3773
movq -0x58(%rbp), %rdi
movslq -0x50(%rbp), %rsi
callq 0x89a0
movsd (%rax), %xmm0
addsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm1
movsd -0x48(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3766
movl -0x50(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x377c
jmp 0x3768
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x372b
movl -0x4c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x270(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x33a0
leaq -0x238(%rbp), %rdi
callq 0x3300
movl $0x0, -0x23c(%rbp)
leaq -0x218(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3070
movq %rax, -0x278(%rbp)
jmp 0x3ab5
movq -0x278(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x32d0
movb %al, -0x279(%rbp)
jmp 0x3ad3
movb -0x279(%rbp), %al
testb $0x1, %al
jne 0x3ae2
jmp 0x3bd8
leaq -0x268(%rbp), %rdi
leaq -0x238(%rbp), %rsi
movl $0x20, %edx
callq 0x3d90
jmp 0x3afc
movq -0x270(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x288(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x268(%rbp), %rdi
callq 0x8cc0
movq -0x288(%rbp), %rdi
movq %rax, %rsi
callq 0x8c50
jmp 0x3b2f
movq -0x270(%rbp), %rax
movl -0x23c(%rbp), %ecx
movl %ecx, -0x29c(%rbp)
addq $0x70, %rax
movq %rax, -0x298(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x268(%rbp), %rdi
callq 0x8cc0
movq -0x298(%rbp), %rdi
movq %rax, %rsi
callq 0x8ce0
movq %rax, -0x290(%rbp)
jmp 0x3b75
movq -0x290(%rbp), %rax
movl -0x29c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x23c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x23c(%rbp)
leaq -0x268(%rbp), %rdi
callq 0x8b80
jmp 0x3a99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
jmp 0x3c15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x268(%rbp), %rdi
callq 0x8b80
jmp 0x3c15
movq -0x270(%rbp), %rdi
addq $0x58, %rdi
callq 0x8dc0
movl %eax, -0x2a0(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x3160
leaq -0x218(%rbp), %rdi
callq 0x3090
movl -0x2a0(%rbp), %eax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
leaq -0x238(%rbp), %rdi
callq 0x3160
leaq -0x218(%rbp), %rdi
callq 0x3090
movq -0x248(%rbp), %rdi
callq 0x3400
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0xa8, %rdi
callq 0x8be0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3cd1
movq -0x18(%rbp), %rdi
addq $0xa8, %rdi
movslq -0x10(%rbp), %rsi
callq 0x8c10
movq %rax, %rdi
callq 0x8c30
movq -0x18(%rbp), %rdi
addq $0xd8, %rdi
movslq -0x10(%rbp), %rsi
callq 0x8c10
movq %rax, %rdi
callq 0x8c30
movq -0x18(%rbp), %rdi
addq $0xc0, %rdi
movslq -0x10(%rbp), %rsi
callq 0x8c10
movq %rax, %rdi
callq 0x8c30
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3c6a
movq -0x18(%rbp), %rdi
addq $0x168, %rdi            # imm = 0x168
callq 0x8aa0
movq -0x18(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
callq 0x8aa0
movq -0x18(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x8b00
movq -0x18(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0x8b00
movq -0x18(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x8b00
movq -0x18(%rbp), %rdi
addq $0xf0, %rdi
callq 0x8b00
movq -0x18(%rbp), %rdi
addq $0xd8, %rdi
callq 0x8b00
movq -0x18(%rbp), %rdi
addq $0xc0, %rdi
callq 0x8b00
movq -0x18(%rbp), %rdi
addq $0xa8, %rdi
callq 0x8b00
movq -0x18(%rbp), %rdi
addq $0x70, %rdi
callq 0x8b60
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
callq 0x8b80
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x3160
addq $0x20, %rsp
popq %rbp
retq
nop