LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tdv[P]boss/boss/include/common/buffer.h
// Function: Boss::RawBuffer::RawBuffer(void const*, unsigned int)::'lambda'()::operator()() const
RawBuffer(void const *data, UInt bytes)
      : Buffer([&] ()
               {
                 return !bytes ? std::move(std::vector<char>()) :
                   std::move(std::vector<char>(reinterpret_cast<char const *>(data),
                                               reinterpret_cast<char const *>(data) + bytes)); 
               } ()
              )
    {
    }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x30(%rsp)
movq (%rax), %rax
movl (%rax), %eax
movb $0x0, 0x6f(%rsp)
movb $0x0, 0x4e(%rsp)
movb $0x0, 0x3b(%rsp)
cmpl $0x0, %eax
jne 0x1fed6
leaq 0x70(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x150d0
leaq 0x70(%rsp), %rdi
callq 0x20190
movb $0x1, 0x6f(%rsp)
leaq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x1ff30
movq 0x30(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movl (%rcx), %ecx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x25790
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movb $0x1, 0x4e(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x201a0
jmp 0x1ff21
movb $0x1, 0x3b(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20230
testb $0x1, 0x3b(%rsp)
jne 0x1ff48
jmp 0x1ff52
leaq 0x50(%rsp), %rdi
callq 0x1f640
testb $0x1, 0x4e(%rsp)
jne 0x1ff5b
jmp 0x1ff65
leaq 0x4f(%rsp), %rdi
callq 0x257b0
testb $0x1, 0x6f(%rsp)
jne 0x1ff6e
jmp 0x1ff78
leaq 0x70(%rsp), %rdi
callq 0x1f640
movq 0x28(%rsp), %rax
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
testb $0x1, 0x4e(%rsp)
jne 0x1ff9c
jmp 0x1ffa6
leaq 0x4f(%rsp), %rdi
callq 0x257b0
testb $0x1, 0x6f(%rsp)
jne 0x1ffaf
jmp 0x1ffb9
leaq 0x70(%rsp), %rdi
callq 0x1f640
jmp 0x1ffbb
movq 0x40(%rsp), %rdi
callq 0xc40a0
nopw %cs:(%rax,%rax)
nop
// File: tdv[P]boss/boss/include/plugin/module_holder.h
// Function: Boss::ModuleHolder::SetServiceLocator(Boss::IServiceLocator*)
void SetServiceLocator(IServiceLocator *locator)
    {
      typedef RetCode (*PFNBossSetServiceLocator)(IServiceLocator *);
      auto *BossSetServiceLocator = Dll.GetProc<PFNBossSetServiceLocator>("BossSetServiceLocator");
      RefObjPtr<IServiceLocator> Inst;
      if (BossSetServiceLocator(locator) != Status::Ok)
        throw ModuleHolderException("Failed to set ServiceLocator.");
    }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x25790
movq 0x28(%rsp), %rdx
leaq 0xa5225(%rip), %rsi     # 0xc75d1
leaq 0x50(%rsp), %rdi
callq 0x98c60
jmp 0x223b8
movq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x226f0
movq %rax, 0x18(%rsp)
jmp 0x223ce
leaq 0x50(%rsp), %rdi
callq 0x962e0
leaq 0x4f(%rsp), %rdi
callq 0x257b0
movq 0x18(%rsp), %rax
movq %rax, 0x70(%rsp)
xorl %eax, %eax
movl %eax, %esi
leaq 0x30(%rsp), %rdi
callq 0x19120
movq 0x70(%rsp), %rax
movq 0x78(%rsp), %rdi
callq *%rax
movl %eax, 0x14(%rsp)
jmp 0x2240c
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
je 0x224b7
movl $0x10, %edi
callq 0x23610
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0xa51b2(%rip), %rsi     # 0xc75e7
callq 0x228a0
jmp 0x2243c
movq 0x8(%rsp), %rdi
leaq 0xdf518(%rip), %rsi     # 0x101960
leaq -0x4b6f(%rip), %rdx     # 0x1d8e0
callq 0x24660
jmp 0x224dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x22481
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x962e0
leaq 0x4f(%rsp), %rdi
callq 0x257b0
jmp 0x224d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x224c9
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x23670
jmp 0x224c9
leaq 0x30(%rsp), %rdi
callq 0x19160
addq $0x88, %rsp
retq
leaq 0x30(%rsp), %rdi
callq 0x19160
movq 0x40(%rsp), %rdi
callq 0xc40a0
nopl (%rax)
// File: reddragon[P]packed-memory-array/impl1.cpp
// Function: main
int main() {
    
    PackedMemoryArray<int> pma(2);
    
    Timer t;
    t.start();
    for(int i = 3; i < 10000000; i++) {
        pma.insert_element(i);
    }
    double time_taken = t.stop();
    std::cout << "Head Inserts: " << time_taken/10000000.0 << std::endl;
    //pma.print();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
movl $0x2, %esi
callq 0x1410
leaq -0x80(%rbp), %rdi
callq 0x15c0
jmp 0x130b
leaq -0x80(%rbp), %rdi
callq 0x15d0
jmp 0x1316
movl $0x3, -0x90(%rbp)
cmpl $0x989680, -0x90(%rbp)  # imm = 0x989680
jge 0x1370
movl -0x90(%rbp), %esi
leaq -0x70(%rbp), %rdi
callq 0x15f0
jmp 0x133d
jmp 0x133f
movl -0x90(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x90(%rbp)
jmp 0x1320
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x16c0
jmp 0x1402
leaq -0x80(%rbp), %rdi
callq 0x1640
movsd %xmm0, -0xa0(%rbp)
jmp 0x1383
movsd -0xa0(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
movq 0x9c3e(%rip), %rdi      # 0xafd8
leaq 0x5caf(%rip), %rsi      # 0x7050
callq 0x10d0
movq %rax, -0xa8(%rbp)
jmp 0x13af
movq -0xa8(%rbp), %rdi
movsd -0x98(%rbp), %xmm0
movsd 0x5c42(%rip), %xmm1     # 0x7008
divsd %xmm1, %xmm0
callq 0x1190
movq %rax, -0xb0(%rbp)
jmp 0x13d8
movq -0xb0(%rbp), %rdi
movq 0x9be2(%rip), %rsi      # 0xafc8
callq 0x1100
jmp 0x13ed
leaq -0x70(%rbp), %rdi
callq 0x16c0
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x1170
nop
// File: reddragon[P]packed-memory-array/./include/timer.hpp
// Function: Timer::stop()
double
    stop() {
        // time_t now = time(NULL);
        // time_t diff = now - begin;
        timeval now;
        gettimeofday(&now, NULL);
        double l = begin.tv_sec * 1000000.0 + begin.tv_usec;
        double r = now.tv_sec * 1000000.0 + now.tv_usec;
        double diff = r - l;
        return diff;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1130
movq -0x38(%rbp), %rax
cvtsi2sdq (%rax), %xmm0
cvtsi2sdq 0x8(%rax), %xmm1
movsd 0x59a0(%rip), %xmm2     # 0x7018
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
cvtsi2sdq -0x18(%rbp), %xmm0
cvtsi2sdq -0x10(%rbp), %xmm1
movsd 0x597f(%rip), %xmm2     # 0x7018
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
// File: reddragon[P]packed-memory-array/impl1.cpp
// Function: PackedMemoryArray<int>::insert_element_at(int, int)
inline void PackedMemoryArray<E>::insert_element_at(E e, int index) {
    // There is no element at index 'index'
#ifndef OPTIMIZE
    assert(!ELEM_EXISTS_AT(index));
#endif
    // Actually putting the element
    store[index] = e;
    // Marking the entry in the bitmask
    exists[index] = 1;
    // The bitmask works fine
#ifndef OPTIMIZE
    assert(ELEM_EXISTS_AT(index));
#endif
    // Increase the size
    ++s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movslq -0x10(%rbp), %rsi
callq 0x4730
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rdi
movl %ecx, (%rax)
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0x4750
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x3910
movq -0x28(%rbp), %rax
movl 0x58(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x58(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: reddragon[P]packed-memory-array/impl1.cpp
// Function: PackedMemoryArray<int>::upper_bound(int)
int PackedMemoryArray<E>::upper_bound(E e) {
    int l = 0, r = ((int)store.size())/segment_size, pos; 
    while(l != r) {
        int m = l + (r - l + 1)/2;
        pos = upper_bound_in_segment(e, m);
        if (pos == -1) 
            r = m-1;
        else
            l = m; 
    }
    pos = upper_bound_in_segment(e, l);
    return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x0, -0x10(%rbp)
callq 0x1950
movq -0x28(%rbp), %rcx
cltd
idivl 0x5c(%rcx)
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x49b2
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %eax
subl -0x10(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x2c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x4aa0
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x49aa
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x49b0
movl -0x1c(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x495e
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x4aa0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: reddragon[P]packed-memory-array/impl1.cpp
// Function: PackedMemoryArray<int>::insert_element_after(int, int, int)
void PackedMemoryArray<E>::insert_element_after(E e, E after, int pos) {
    // Find where we can insert
    int loc;
    loc = pos;
#ifndef OPTIMIZE
    assert(loc != -1);
#endif
    int insert_at = ++loc;
    // Do we have space at the location we want to insert?
    if(insert_at < (int)store.size() && !ELEM_EXISTS_AT(insert_at)) {
        // Great! Now insert it there.
        insert_element_at(e, insert_at);
        return;
    }
    // The not so nice part begins here.
    int node_index, node_level;
    if(smallest_interval_in_balance(insert_at, &node_index, &node_level) == -1) {
        // No more space left in the PMA. Resize!
        expand_PMA(e);
    }
    else {
        // Rebalance one particular level
        rebalance(node_index, node_level, e);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
callq 0x1950
movl -0x40(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x39(%rbp)
jge 0x4a3f
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4750
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x38e0
xorb $-0x1, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x4a48
jmp 0x4a59
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x18e0
jmp 0x4a92
movq -0x48(%rbp), %rdi
movl -0x1c(%rbp), %esi
leaq -0x34(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x4b60
cmpl $-0x1, %eax
jne 0x4a80
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x4d10
jmp 0x4a92
movq -0x48(%rbp), %rdi
movl -0x34(%rbp), %esi
movl -0x38(%rbp), %edx
movl -0xc(%rbp), %ecx
callq 0x51c0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: reddragon[P]packed-memory-array/impl1.cpp
// Function: PackedMemoryArray<int>::upper_bound_in_segment(int, int)
int PackedMemoryArray<E>::upper_bound_in_segment(E e, int v) {
    int best = -1;
    for(int i = v*segment_size; i < (v+1)*segment_size; i++)
        if(ELEM_EXISTS_AT(i) && store[i] <= e) 
            return best = i;
    return best;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
imull 0x5c(%rcx), %eax
movl %eax, -0x20(%rbp)
movq -0x38(%rbp), %rdx
movl -0x20(%rbp), %eax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
imull 0x5c(%rdx), %ecx
cmpl %ecx, %eax
jge 0x4b49
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movslq -0x20(%rbp), %rsi
callq 0x4750
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x38e0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x39(%rbp)
jne 0x4b10
jmp 0x4b28
movq -0x38(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x4730
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
setle %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x4b31
jmp 0x4b3c
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl %eax, -0x4(%rbp)
jmp 0x4b4f
jmp 0x4b3e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4acb
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/main.cpp
// Function: solves_rikudo(std::basic_ifstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&)
void solves_rikudo(std::ifstream &ifile, std::ofstream &ofile)
{
    Graph graph(ifile);

    int begin, end;
    ifile >> begin >> end;

    graph.unique_sol(begin, end, ofile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x6a60
movq -0x8(%rbp), %rdi
leaq -0xbc(%rbp), %rsi
callq 0x3160
movq %rax, -0xd8(%rbp)
jmp 0x39fc
movq -0xd8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x3160
jmp 0x3a11
movl -0xbc(%rbp), %esi
movl -0xc0(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq -0xb8(%rbp), %rdi
callq 0xa120
jmp 0x3a2f
leaq -0xb8(%rbp), %rdi
callq 0x4690
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x4690
movq -0xc8(%rbp), %rdi
callq 0x3400
nop
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::backtracking(int, int, int, bool)
bool Graph::backtracking(int v,
                         int n,
                         int last,
                         bool count)
{
    visited[v] = true;
    path[n] = v;

    if (n == n_vertices - 1)
    {
        visited[v] = false;
        if(v == last){
            paths.push_back(path);
            return true;
        }
        
        return false;
    }

    for (int neighbor : adj_list[v])
    {
        if (!visited[neighbor] && backtracking(neighbor, n + 1, last, count) && !count)
            return true;
    }

    visited[v] = false;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x50, %rdi
movslq -0x14(%rbp), %rsi
callq 0xaea0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0xaf00
movq -0x88(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x8c(%rbp)
addq $0x90, %rdi
movslq -0x18(%rbp), %rsi
callq 0xaf50
movl -0x8c(%rbp), %edx
movq -0x88(%rbp), %rcx
movl %edx, (%rax)
movl -0x18(%rbp), %eax
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x6764
movq -0x88(%rbp), %rdi
addq $0x50, %rdi
movslq -0x14(%rbp), %rsi
callq 0xaea0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0xaf00
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x675b
movq -0x88(%rbp), %rsi
movq %rsi, %rdi
addq $0x78, %rdi
addq $0x90, %rsi
callq 0xaf70
movb $0x1, -0x1(%rbp)
jmp 0x6878
movb $0x0, -0x1(%rbp)
jmp 0x6878
movq -0x88(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4440
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x4700
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x4730
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4760
testb $0x1, %al
jne 0x67ac
jmp 0x684d
leaq -0x50(%rbp), %rdi
callq 0x47a0
movq -0x88(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
addq $0x50, %rdi
movslq -0x5c(%rbp), %rsi
callq 0xaea0
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xafe0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x8d(%rbp)
jne 0x682b
movq -0x88(%rbp), %rdi
movl -0x5c(%rbp), %esi
movl -0x18(%rbp), %edx
addl $0x1, %edx
movl -0x1c(%rbp), %ecx
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x6680
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x8d(%rbp)
jne 0x6820
jmp 0x682b
movb -0x1d(%rbp), %al
xorb $-0x1, %al
movb %al, -0x8d(%rbp)
movb -0x8d(%rbp), %al
testb $0x1, %al
jne 0x6837
jmp 0x683d
movb $0x1, -0x1(%rbp)
jmp 0x6878
jmp 0x683f
leaq -0x50(%rbp), %rdi
callq 0x47c0
jmp 0x6796
movq -0x88(%rbp), %rdi
addq $0x50, %rdi
movslq -0x14(%rbp), %rsi
callq 0xaea0
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0xaf00
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::Graph(std::basic_ifstream<char, std::char_traits<char>>&)
Graph::Graph(std::ifstream &file)
{
    int n_vertices;
    file >> n_vertices;

    if(n_vertices <= 0)
        throw "Number of vertices should be a positive integer.";

    this->n_vertices = n_vertices;
    adj_list.assign(static_cast<unsigned long>(n_vertices), std::vector<int>());

    while (true)
    {
        int a, b;
        file >> a;
        if (a < 0)
            break;
        file >> b;

        if(a >= n_vertices || b < 0 || b >= n_vertices)
            throw "Invalid vertex index";

        adj_list[a].push_back(b);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x8, %rdi
movq %rdi, -0x80(%rbp)
callq 0x4300
movq -0x58(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x78(%rbp)
callq 0x4300
movq -0x58(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x70(%rbp)
callq 0xb110
movq -0x58(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x68(%rbp)
callq 0xb130
movq -0x58(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x60(%rbp)
callq 0xb110
movq -0x58(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0x50(%rbp)
callq 0x4300
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x3160
jmp 0x6aef
cmpl $0x0, -0x14(%rbp)
jg 0x6b32
movl $0x8, %edi
callq 0x3120
movq %rax, %rdi
leaq 0xc5d5(%rip), %rax      # 0x130de
movq %rax, (%rdi)
movq 0x134ad(%rip), %rsi     # 0x19fc0
xorl %eax, %eax
movl %eax, %edx
callq 0x33e0
jmp 0x6c82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x6c43
movq -0x58(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
addq $0x38, %rax
movq %rax, -0x98(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x90(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4300
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0xb150
jmp 0x6b8c
leaq -0x40(%rbp), %rdi
callq 0x43e0
jmp 0x6b97
movq -0x10(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x3160
jmp 0x6ba6
cmpl $0x0, -0x44(%rbp)
jge 0x6bc8
jmp 0x6c3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x43e0
jmp 0x6c43
movq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3160
jmp 0x6bd7
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6bed
cmpl $0x0, -0x48(%rbp)
jl 0x6bed
movl -0x48(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x6c16
movl $0x8, %edi
callq 0x3120
movq %rax, %rdi
leaq 0xc50e(%rip), %rax      # 0x1310f
movq %rax, (%rdi)
movq 0x133b5(%rip), %rsi     # 0x19fc0
xorl %eax, %eax
movl %eax, %edx
callq 0x33e0
jmp 0x6c82
movq -0x58(%rbp), %rdi
addq $0x38, %rdi
movslq -0x44(%rbp), %rsi
callq 0x4440
movq %rax, %rdi
leaq -0x48(%rbp), %rsi
callq 0xb180
jmp 0x6c35
jmp 0x6b95
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x43e0
movq -0x60(%rbp), %rdi
callq 0x4630
movq -0x68(%rbp), %rdi
callq 0x4940
movq -0x70(%rbp), %rdi
callq 0x4630
movq -0x78(%rbp), %rdi
callq 0x43e0
movq -0x80(%rbp), %rdi
callq 0x43e0
movq -0x20(%rbp), %rdi
callq 0x3400
nopw %cs:(%rax,%rax)
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::condition1(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
void Graph::condition1(std::vector< std::vector<int> >& clauses){
    std::vector<int> clause;

     // every vertex visited
    for(int i = 0; i < n_vertices; i++){
        clause.clear();
        for(int j = 0; j < n_vertices; j++){
            int id = encode(j, i);
            clause.push_back(id);
        }
        clauses.push_back(clause);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4300
movl $0x0, -0x2c(%rbp)
movq -0x50(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x6e78
leaq -0x28(%rbp), %rdi
callq 0xb440
movl $0x0, -0x30(%rbp)
movq -0x50(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl (%rcx), %eax
jge 0x6e59
movq -0x50(%rbp), %rdi
movl -0x30(%rbp), %esi
movl -0x2c(%rbp), %edx
xorl %ecx, %ecx
callq 0x65f0
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xb180
jmp 0x6e35
jmp 0x6e37
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6e07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x43e0
jmp 0x6e87
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaf70
jmp 0x6e68
jmp 0x6e6a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6de8
leaq -0x28(%rbp), %rdi
callq 0x43e0
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3400
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::condition2(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
void Graph::condition2(std::vector< std::vector<int> >& clauses){
    std::vector<int> clause;
    for(int i = 0; i < n_vertices; i++){
        for(int j = 0; j < n_vertices; j++){
            for(int k = j + 1; k < n_vertices; k++){
                clause.clear();
                int id_1 = -encode(j, i);
                int id_2 = -encode(k, i);
                clause.push_back(id_1);
                clause.push_back(id_2);
                clauses.push_back(clause);                
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4300
movl $0x0, -0x2c(%rbp)
movq -0x58(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x6fa6
movl $0x0, -0x30(%rbp)
movq -0x58(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl (%rcx), %eax
jge 0x6f96
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x58(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
jge 0x6f86
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xb440
movq -0x58(%rbp), %rdi
movl -0x30(%rbp), %esi
movl -0x2c(%rbp), %edx
xorl %ecx, %ecx
movl %ecx, -0x64(%rbp)
callq 0x65f0
movq -0x58(%rbp), %rdi
movl -0x64(%rbp), %ecx
negl %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %esi
movl -0x2c(%rbp), %edx
callq 0x65f0
movq -0x60(%rbp), %rdi
negl %eax
movl %eax, -0x3c(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xb180
jmp 0x6f41
leaq -0x28(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0xb180
jmp 0x6f50
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaf70
jmp 0x6f5f
jmp 0x6f61
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6ee6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x43e0
jmp 0x6fb5
jmp 0x6f88
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6ece
jmp 0x6f98
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6eb8
leaq -0x28(%rbp), %rdi
callq 0x43e0
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3400
nop
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::condition3(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
void Graph::condition3(std::vector< std::vector<int> >& clauses){
    std::vector<int> clause;

    for(int i = 0; i < n_vertices; i++){
        clause.clear();
        for(int j = 0; j < n_vertices; j++){
            int id = encode(i, j);
            clause.push_back(id);
        }
        clauses.push_back(clause);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4300
movl $0x0, -0x2c(%rbp)
movq -0x50(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x7078
leaq -0x28(%rbp), %rdi
callq 0xb440
movl $0x0, -0x30(%rbp)
movq -0x50(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl (%rcx), %eax
jge 0x7059
movq -0x50(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
xorl %ecx, %ecx
callq 0x65f0
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xb180
jmp 0x7035
jmp 0x7037
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x7007
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x43e0
jmp 0x7087
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaf70
jmp 0x7068
jmp 0x706a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6fe8
leaq -0x28(%rbp), %rdi
callq 0x43e0
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3400
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::condition4(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
void Graph::condition4(std::vector< std::vector<int> >& clauses){
    std::vector<int> clause;
    for(int i = 0; i < n_vertices; i++){
        for(int j = 0; j < n_vertices; j++){
            for(int k = j+1; k < n_vertices; k++){
                clause.clear();
                int id_1 = -encode(i, j);
                int id_2 = -encode(i, k);
                clause.push_back(id_1);
                clause.push_back(id_2);
                clauses.push_back(clause); 
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4300
movl $0x0, -0x2c(%rbp)
movq -0x58(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x71a6
movl $0x0, -0x30(%rbp)
movq -0x58(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl (%rcx), %eax
jge 0x7196
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x58(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
jge 0x7186
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xb440
movq -0x58(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
xorl %ecx, %ecx
movl %ecx, -0x64(%rbp)
callq 0x65f0
movq -0x58(%rbp), %rdi
movl -0x64(%rbp), %ecx
negl %eax
movl %eax, -0x38(%rbp)
movl -0x2c(%rbp), %esi
movl -0x34(%rbp), %edx
callq 0x65f0
movq -0x60(%rbp), %rdi
negl %eax
movl %eax, -0x3c(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xb180
jmp 0x7141
leaq -0x28(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0xb180
jmp 0x7150
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaf70
jmp 0x715f
jmp 0x7161
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x70e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x43e0
jmp 0x71b5
jmp 0x7188
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x70ce
jmp 0x7198
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x70b8
leaq -0x28(%rbp), %rdi
callq 0x43e0
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3400
nop
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::condition5(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
void Graph::condition5(std::vector< std::vector<int> >& clauses){
    std::vector<int> clause;
    for (int ith = 0; ith < n_vertices - 1; ith++)
    {
        for (int vertex = 0; vertex < n_vertices; vertex++)
        {
            int var_id = encode(ith, vertex);
            clause.clear();
            clause.push_back(-var_id);
            for (int neighbor : adj_list[vertex])
            {
                int neighbor_id = encode(ith + 1, neighbor);
                clause.push_back(neighbor_id);
            }
            clauses.push_back(clause);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4300
movl $0x0, -0x2c(%rbp)
movq -0x70(%rbp), %rcx
movl -0x2c(%rbp), %eax
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x7315
movl $0x0, -0x30(%rbp)
movq -0x70(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl (%rcx), %eax
jge 0x7305
movq -0x70(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
xorl %ecx, %ecx
callq 0x65f0
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xb440
movq -0x78(%rbp), %rdi
movl -0x34(%rbp), %eax
negl %eax
movl %eax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x4460
jmp 0x724d
movq -0x70(%rbp), %rdi
addq $0x38, %rdi
movslq -0x30(%rbp), %rsi
callq 0x4440
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x4700
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x4730
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4760
testb $0x1, %al
jne 0x728f
jmp 0x72e6
leaq -0x58(%rbp), %rdi
callq 0x47a0
movq -0x70(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x64(%rbp)
movl -0x2c(%rbp), %esi
incl %esi
movl -0x64(%rbp), %edx
xorl %ecx, %ecx
callq 0x65f0
movl %eax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xb180
jmp 0x72c2
jmp 0x72c4
leaq -0x58(%rbp), %rdi
callq 0x47c0
jmp 0x727c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x43e0
jmp 0x7327
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaf70
jmp 0x72f5
jmp 0x72f7
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x7206
jmp 0x7307
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x71eb
leaq -0x28(%rbp), %rdi
callq 0x43e0
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3400
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::condition6(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&)
void Graph::condition6(std::vector< std::vector<int> >& clauses,
    const std::vector< std::pair<int,int> >& map)
{
    std::vector<int> clause;
    for(auto ith_vertex : map){
        clause.clear();
        int var_id = encode(ith_vertex.first, ith_vertex.second);
        clauses.push_back(clause);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4300
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xb010
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xb040
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb070
testb $0x1, %al
jne 0x738d
jmp 0x73f1
leaq -0x40(%rbp), %rdi
callq 0xb0b0
movq (%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xb440
movq -0x70(%rbp), %rdi
movl -0x50(%rbp), %esi
movl -0x4c(%rbp), %edx
xorl %ecx, %ecx
callq 0x65f0
movq -0x78(%rbp), %rsi
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaf70
jmp 0x73cd
jmp 0x73cf
leaq -0x40(%rbp), %rdi
callq 0xb0f0
jmp 0x737a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x43e0
jmp 0x7403
leaq -0x30(%rbp), %rdi
callq 0x43e0
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3400
nopl (%rax)
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::condition7(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&)
void Graph::condition7(std::vector< std::vector<int> >& clauses,
    const std::vector< std::pair<int,int> >& diamonds)
{
    std::vector<int> clause;
    for(auto vi_vj : diamonds){
        for(int ith = 0; ith < n_vertices; ith++){
            clause.clear();

            int vi_id = encode(ith, vi_vj.first);
            clause.push_back(-vi_id);
            if(ith > 0){
                int vj_id = encode(ith-1, vi_vj.second);
                clause.push_back(vj_id);
            }
            if(ith < n_vertices-1){
                int vj_id = encode(ith+1, vi_vj.second);
                clause.push_back(vj_id);
            }
            clauses.push_back(clause);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4300
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xb010
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xb040
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb070
testb $0x1, %al
jne 0x7470
jmp 0x757e
leaq -0x40(%rbp), %rdi
callq 0xb0b0
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movq -0x80(%rbp), %rcx
movl -0x54(%rbp), %eax
cmpl (%rcx), %eax
jge 0x756e
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xb440
movq -0x80(%rbp), %rdi
movl -0x54(%rbp), %esi
movl -0x50(%rbp), %edx
xorl %ecx, %ecx
callq 0x65f0
movq -0x88(%rbp), %rdi
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %eax
negl %eax
movl %eax, -0x5c(%rbp)
leaq -0x5c(%rbp), %rsi
callq 0x4460
jmp 0x74d4
cmpl $0x0, -0x54(%rbp)
jle 0x7518
movq -0x80(%rbp), %rdi
movl -0x54(%rbp), %esi
decl %esi
movl -0x4c(%rbp), %edx
xorl %ecx, %ecx
callq 0x65f0
movl %eax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xb180
jmp 0x74ff
jmp 0x7518
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x43e0
jmp 0x7590
movq -0x80(%rbp), %rcx
movl -0x54(%rbp), %eax
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x754f
movq -0x80(%rbp), %rdi
movl -0x54(%rbp), %esi
incl %esi
movl -0x4c(%rbp), %edx
xorl %ecx, %ecx
callq 0x65f0
movl %eax, -0x74(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x74(%rbp), %rsi
callq 0xb180
jmp 0x754d
jmp 0x754f
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xaf70
jmp 0x755e
jmp 0x7560
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x7487
jmp 0x7570
leaq -0x40(%rbp), %rdi
callq 0xb0f0
jmp 0x745a
leaq -0x30(%rbp), %rdi
callq 0x43e0
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3400
nopl (%rax)
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::condition8(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
void Graph::condition8(std::vector< std::vector<int> >& clauses){
    std::vector<int> clause;
    for(int i = 0; i < n_vertices; i++){
        for(int j = 0; j < n_vertices; j++){
            for(int k = 0; k < n_vertices; k++){
                if(i == j || i == k || j == k)    continue;
                int v1 = -encode(i, j, true);
                int v2 = -encode(j, k, true);
                int v3 = encode(i, k, true);
                clause.clear();
                clause.push_back(v1);
                clause.push_back(v2);
                clause.push_back(v3);
                clauses.push_back(clause);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4300
movl $0x0, -0x2c(%rbp)
movq -0x58(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x76f8
movl $0x0, -0x30(%rbp)
movq -0x58(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl (%rcx), %eax
jge 0x76e8
movl $0x0, -0x34(%rbp)
movq -0x58(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
jge 0x76d8
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
je 0x761b
movl -0x2c(%rbp), %eax
cmpl -0x34(%rbp), %eax
je 0x761b
movl -0x30(%rbp), %eax
cmpl -0x34(%rbp), %eax
jne 0x7620
jmp 0x76b3
movq -0x58(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
movl $0x1, %ecx
movl %ecx, -0x64(%rbp)
callq 0x65f0
movq -0x58(%rbp), %rdi
movl -0x64(%rbp), %ecx
negl %eax
movl %eax, -0x38(%rbp)
movl -0x30(%rbp), %esi
movl -0x34(%rbp), %edx
callq 0x65f0
movq -0x58(%rbp), %rdi
movl -0x64(%rbp), %ecx
negl %eax
movl %eax, -0x3c(%rbp)
movl -0x2c(%rbp), %esi
movl -0x34(%rbp), %edx
callq 0x65f0
movl %eax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xb440
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb180
jmp 0x7684
leaq -0x28(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0xb180
jmp 0x7693
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xb180
jmp 0x76a2
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaf70
jmp 0x76b1
jmp 0x76b3
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x75f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x43e0
jmp 0x7707
jmp 0x76da
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x75de
jmp 0x76ea
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x75c8
leaq -0x28(%rbp), %rdi
callq 0x43e0
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3400
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::condition9(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
void Graph::condition9(std::vector< std::vector<int> >& clauses){
    std::vector<int> clause;
    for(int i = 0; i < n_vertices; i++){
        for(int j = 0; j < n_vertices; j++){
            if(i == j)  continue;
            int v1 = encode(i, j, true);
            int v2 = encode(j, i, true);
            clause.clear();
            clause.push_back(v1);
            clause.push_back(v2);
            clauses.push_back(clause);
            clause.clear();
            clause.push_back(-v1);
            clause.push_back(-v2);
            clauses.push_back(clause);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4300
movl $0x0, -0x2c(%rbp)
movq -0x58(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x7854
movl $0x0, -0x30(%rbp)
movq -0x58(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl (%rcx), %eax
jge 0x7844
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jne 0x776a
jmp 0x781f
movq -0x58(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
movl $0x1, %ecx
movl %ecx, -0x64(%rbp)
callq 0x65f0
movq -0x58(%rbp), %rdi
movl -0x64(%rbp), %ecx
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %esi
movl -0x2c(%rbp), %edx
callq 0x65f0
movl %eax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xb440
movq -0x60(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xb180
jmp 0x77b5
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb180
jmp 0x77c4
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaf70
jmp 0x77d3
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xb440
movq -0x70(%rbp), %rdi
movl -0x34(%rbp), %eax
negl %eax
movl %eax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x4460
jmp 0x77f7
movl -0x38(%rbp), %eax
negl %eax
movl %eax, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x4460
jmp 0x780e
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaf70
jmp 0x781d
jmp 0x781f
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x774e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x43e0
jmp 0x7863
jmp 0x7846
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7738
leaq -0x28(%rbp), %rdi
callq 0x43e0
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3400
nopl (%rax)
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::condition10(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
void Graph::condition10(std::vector< std::vector<int> >& clauses){
    std::vector<int> clause;
    for(int t = 0; t < n_vertices - 1; t++){
        for(int u = 0; u < n_vertices; u++){
            for(int v = 0; v < n_vertices; v++){
                int v1 = -encode(t, u);
                int v2 = -encode(t+1, v);
                int v3 = encode(u, v, true);
                clause.clear();
                clause.push_back(v1);
                clause.push_back(v2);
                clause.push_back(v3);
                clauses.push_back(clause);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4300
movl $0x0, -0x2c(%rbp)
movq -0x58(%rbp), %rcx
movl -0x2c(%rbp), %eax
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x79b1
movl $0x0, -0x30(%rbp)
movq -0x58(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl (%rcx), %eax
jge 0x79a1
movl $0x0, -0x34(%rbp)
movq -0x58(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
jge 0x7991
movq -0x58(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
xorl %ecx, %ecx
movl %ecx, -0x64(%rbp)
callq 0x65f0
movl -0x64(%rbp), %ecx
movq -0x58(%rbp), %rdi
negl %eax
movl %eax, -0x38(%rbp)
movl -0x2c(%rbp), %esi
incl %esi
movl -0x34(%rbp), %edx
callq 0x65f0
movq -0x58(%rbp), %rdi
negl %eax
movl %eax, -0x3c(%rbp)
movl -0x30(%rbp), %esi
movl -0x34(%rbp), %edx
movl $0x1, %ecx
callq 0x65f0
movl %eax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xb440
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb180
jmp 0x793d
leaq -0x28(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0xb180
jmp 0x794c
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xb180
jmp 0x795b
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaf70
jmp 0x796a
jmp 0x796c
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x78c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x43e0
jmp 0x79c0
jmp 0x7993
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x78b3
jmp 0x79a3
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7898
leaq -0x28(%rbp), %rdi
callq 0x43e0
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3400
nopl (%rax)
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::condition11(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, int)
void Graph::condition11(std::vector< std::vector<int> >& clauses, int source){
    std::vector<int> clause;
    for(int i = 0; i < n_vertices; i++){
        if(i == source) continue;
        int v = encode(source, i, true);
        clause.clear();
        clause.push_back(v);
        clauses.push_back(clause);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4300
movl $0x0, -0x34(%rbp)
movq -0x50(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
jge 0x7a76
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x7a10
jmp 0x7a54
movq -0x50(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x34(%rbp), %edx
movl $0x1, %ecx
callq 0x65f0
movl %eax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xb440
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb180
jmp 0x7a43
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xaf70
jmp 0x7a52
jmp 0x7a54
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x79fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x43e0
jmp 0x7a85
leaq -0x30(%rbp), %rdi
callq 0x43e0
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3400
nop
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::condition12(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, int)
void Graph::condition12(std::vector< std::vector<int> >& clauses, int dest){
    std::vector<int> clause;
    for(int i = 0; i < n_vertices; i++){
        if(i == dest) continue;
        int v = encode(i, dest, true);
        clause.clear();
        clause.push_back(v);
        clauses.push_back(clause);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4300
movl $0x0, -0x34(%rbp)
movq -0x50(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
jge 0x7b36
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x7ad0
jmp 0x7b14
movq -0x50(%rbp), %rdi
movl -0x34(%rbp), %esi
movl -0x14(%rbp), %edx
movl $0x1, %ecx
callq 0x65f0
movl %eax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xb440
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb180
jmp 0x7b03
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xaf70
jmp 0x7b12
jmp 0x7b14
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7abb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x43e0
jmp 0x7b45
leaq -0x30(%rbp), %rdi
callq 0x43e0
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3400
nop
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::condition13(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, int)
void Graph::condition13(std::vector< std::vector<int> >& clauses, int source){
    std::vector<int> clause;
    clause.clear();
    int x = encode(0, source);
    clause.push_back(x);
    clauses.push_back(clause);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4300
movq -0x50(%rbp), %rdi
callq 0xb440
movq -0x58(%rbp), %rdi
movl -0x14(%rbp), %edx
xorl %ecx, %ecx
movl %ecx, %esi
callq 0x65f0
movq -0x50(%rbp), %rdi
movl %eax, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0xb180
jmp 0x7ba3
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xaf70
jmp 0x7bb2
leaq -0x30(%rbp), %rdi
callq 0x43e0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x43e0
movq -0x40(%rbp), %rdi
callq 0x3400
nop
// File: cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::condition14(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, int)
void Graph::condition14(std::vector< std::vector<int> >& clauses, int dest){
    std::vector<int> clause;
    clause.clear();
    int x = encode(n_vertices-1, dest);
    clause.push_back(x);
    clauses.push_back(clause);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4300
movq -0x50(%rbp), %rdi
callq 0xb440
movq -0x58(%rbp), %rdi
movl (%rdi), %esi
decl %esi
movl -0x14(%rbp), %edx
xorl %ecx, %ecx
callq 0x65f0
movq -0x50(%rbp), %rdi
movl %eax, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0xb180
jmp 0x7c35
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xaf70
jmp 0x7c44
leaq -0x30(%rbp), %rdi
callq 0x43e0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x43e0
movq -0x40(%rbp), %rdi
callq 0x3400
nopw %cs:(%rax,%rax)