LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r12d
movq %rdi, %r11
movabsq $-0x8000000000000000, %r10 # imm = 0x8000000000000000
movslq %esi, %rcx
leaq 0x3f(%rcx), %r14
testq %rcx, %rcx
cmovnsq %rcx, %r14
sarq $0x6, %r14
shlq $0x3, %r14
movq 0x50(%rdi), %rax
addq %r14, %rax
leaq 0x3f(%r10), %r9
andq %rcx, %r9
xorl %edi, %edi
cmpq %r10, %r9
setbe %dil
movq -0x8(%rax,%rdi,8), %r15
movq %r15, %r9
btsq %rcx, %r9
movq %r9, -0x8(%rax,%rdi,8)
movl %edx, -0x2c(%rbp)
movslq %edx, %r9
movq 0x90(%r11), %r10
movl %ecx, (%r10,%r9,4)
movl $0x1, %edx
shlq %cl, %rdx
leaq -0x8(,%rdi,8), %r10
movl (%r11), %edi
decl %edi
cmpl %r9d, %edi
jne 0x3693
notq %rdx
andq %rdx, %r15
movq %r15, (%rax,%r10)
cmpl %r12d, %esi
jne 0x3771
leaq 0x90(%r11), %rsi
addq $0x78, %r11
movq %r11, %rdi
callq 0x74f4
movb $0x1, %al
jmp 0x3773
movq %r10, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %r14, -0x48(%rbp)
movq 0x38(%r11), %rax
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %r14
movq 0x8(%rax,%rcx,8), %r9
cmpq %r9, %r14
sete %r13b
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
je 0x375a
incl -0x2c(%rbp)
leaq 0x3f(%rdi), %r10
movzbl %r8b, %eax
movl %eax, -0x30(%rbp)
movq %r11, -0x58(%rbp)
movq %r10, -0x50(%rbp)
movl -0x30(%rbp), %ebx
movslq (%r14), %rsi
leaq 0x3f(%rsi), %rax
testq %rsi, %rsi
cmovnsq %rsi, %rax
sarq $0x6, %rax
shlq $0x3, %rax
addq 0x50(%r11), %rax
movq %rsi, %rcx
andq %r10, %rcx
xorl %edx, %edx
cmpq %rdi, %rcx
setbe %dl
movq -0x8(%rax,%rdx,8), %rax
btq %rsi, %rax
jb 0x374d
movq %r11, %rdi
movl -0x2c(%rbp), %edx
movl %r12d, %ecx
movl %ebx, %r8d
movl %r12d, %r15d
movq %r9, %r12
callq 0x35dc
movq -0x50(%rbp), %r10
movq -0x58(%rbp), %r11
movq %r12, %r9
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
movl %r15d, %r12d
xorb $0x1, %al
movl %ebx, %ecx
orb %al, %cl
cmpb $0x1, %cl
jne 0x3782
addq $0x4, %r14
cmpq %r9, %r14
sete %r13b
jne 0x36e0
movq -0x48(%rbp), %rax
addq 0x50(%r11), %rax
movq -0x40(%rbp), %rcx
notq %rcx
movq -0x38(%rbp), %rdx
andq %rcx, (%rdx,%rax)
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
testb $0x1, %r13b
jne 0x375a
jmp 0x3773
// File: /workspace/github_cpp_makefile_star2_O1/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::valid(std::vector<int, std::allocator<int>> const&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&)
bool Graph::valid(const std::vector<int> &candidate,
                  const std::vector< std::pair<int,int> >& map,
                  const std::vector< std::pair<int,int> >& diamonds)
{    
    for(auto pair : map){
        int ith = pair.first;
        int vertex = pair.second;
        if(candidate[ith] != vertex)    return false;
    }

    for(auto pair : diamonds){
        int u = pair.first;
        int v = pair.second;
        for(int ith = 0; ith < candidate.size(); ith++)
            if(candidate[ith] == u){
                if(ith > 0 && candidate[ith-1] == v)    continue;
                if(ith < candidate.size() - 1 && candidate[ith+1] == v) continue;
                return false;
            }
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdx), %rdi
movq 0x8(%rdx), %rax
cmpq %rax, %rdi
sete %r8b
je 0x37e1
movq (%rsi), %rdx
movslq (%rdi), %r9
movl (%rdx,%r9,4), %r9d
cmpl 0x4(%rdi), %r9d
jne 0x37d8
addq $0x8, %rdi
cmpq %rax, %rdi
sete %r8b
je 0x37e1
movslq (%rdi), %r9
movl (%rdx,%r9,4), %r9d
leaq 0x8(%rdi), %r10
cmpl 0x4(%rdi), %r9d
movq %r10, %rdi
je 0x37bb
testb %r8b, %r8b
je 0x3868
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
cmpq %rcx, %rdx
sete %al
je 0x386a
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
movq %rsi, %r8
subq %rdi, %r8
setne %r9b
sarq $0x2, %r8
leaq -0x1(%r8), %r10
cmpq $0x1, %r8
movq %r8, %r11
adcq $0x0, %r11
cmpq %rdi, %rsi
je 0x385a
movl (%rdx), %ebx
movl 0x4(%rdx), %r14d
xorl %r15d, %r15d
movl %r9d, %r12d
cmpl %ebx, (%rdi,%r15,4)
jne 0x3843
testq %r15, %r15
je 0x3837
cmpl %r14d, -0x4(%rdi,%r15,4)
je 0x3843
cmpq %r15, %r10
jbe 0x3854
cmpl %r14d, 0x4(%rdi,%r15,4)
jne 0x3854
incq %r15
cmpq %r15, %r8
seta %r12b
cmpq %r15, %r11
jne 0x3825
jmp 0x385a
testb $0x1, %r12b
jne 0x386a
addq $0x8, %rdx
cmpq %rcx, %rdx
sete %al
jne 0x3814
jmp 0x386a
xorl %eax, %eax
andb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
xorl %eax, %eax
movq %rax, 0x60(%rdi)
movl %eax, 0x68(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movl %eax, 0x58(%rdi)
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x80(%rdi)
movups %xmm0, 0x90(%rdi)
movq %rax, 0xa0(%rdi)
leaq -0x2c(%rbp), %rsi
movq %r15, %rdi
movq %rbx, -0x38(%rbp)
callq 0x2130
movslq -0x2c(%rbp), %rsi
testq %rsi, %rsi
jle 0x39b2
movl %esi, (%rbx)
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq %r14, %rdi
callq 0x7cb0
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3914
callq 0x21d0
leaq -0x50(%rbp), %r12
leaq -0x30(%rbp), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x2130
movl -0x50(%rbp), %ebx
testl %ebx, %ebx
js 0x397c
movq %r15, %rdi
movq %r13, %rsi
callq 0x2130
movslq -0x50(%rbp), %rax
movl -0x2c(%rbp), %edx
cmpl %edx, %eax
jge 0x398b
movl -0x30(%rbp), %ecx
testl %ecx, %ecx
js 0x398b
cmpl %edx, %ecx
jge 0x398b
movq (%r14), %rdx
leaq (%rax,%rax,2), %rax
leaq (%rdx,%rax,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x3970
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x3978
movq %r13, %rdx
callq 0x7dec
testl %ebx, %ebx
jns 0x391c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x2100
leaq 0x579d(%rip), %rcx      # 0x9139
movq %rcx, (%rax)
movq 0x960a(%rip), %rsi      # 0xcfb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x2360
jmp 0x39d7
movl $0x8, %edi
callq 0x2100
leaq 0x5745(%rip), %rcx      # 0x9108
movq %rcx, (%rax)
movq 0x95e3(%rip), %rsi      # 0xcfb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x2360
movq %rax, %r15
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x39f1
callq 0x21d0
jmp 0x39f1
jmp 0x39ee
jmp 0x39ee
movq %rax, %r15
movq -0x38(%rbp), %rax
leaq 0x50(%rax), %r12
leaq 0x78(%rax), %r13
movq 0x90(%rax), %rdi
testq %rdi, %rdi
je 0x3a0e
callq 0x21d0
movq %r13, %rdi
callq 0x3136
movq %r12, %rdi
callq 0x31e2
movq -0x38(%rbp), %rsi
leaq 0x8(%rsi), %rdx
addq $0x20, %rsi
movq %r14, %rdi
callq 0x2421
movq %r15, %rdi
callq 0x2380
movq %rax, %rdi
callq 0x3212
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x58(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
cmpl $0x0, (%rdi)
jle 0x3be7
movq %rdi, %r14
xorl %r13d, %r13d
leaq -0x50(%rbp), %r15
movq -0x50(%rbp), %rax
cmpq %rax, -0x48(%rbp)
je 0x3b8f
movq %rax, -0x48(%rbp)
movl (%r14), %eax
testl %eax, %eax
jle 0x3bd3
leal 0x1(%r13), %ebx
xorl %r12d, %r12d
imull %r12d, %eax
addl %ebx, %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x3bbc
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3bc8
movq %r15, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x7dec
incl %r12d
movl (%r14), %eax
cmpl %eax, %r12d
jl 0x3b9d
movq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x74f4
incl %r13d
cmpl (%r14), %r13d
jl 0x3b81
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3bf5
callq 0x21d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c06
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3c17
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
cmpl $0x0, (%rdi)
jle 0x3d2b
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, -0x2c(%rbp)
cmpl $0x0, (%r14)
jle 0x3d1a
movl -0x2c(%rbp), %r12d
notl %r12d
xorl %eax, %eax
movl %eax, %r13d
leal 0x1(%r13), %ecx
movl (%r14), %eax
movl %ecx, -0x30(%rbp)
cmpl %eax, %ecx
jge 0x3d0e
movl -0x30(%rbp), %r15d
movq -0x50(%rbp), %rcx
cmpq %rcx, -0x48(%rbp)
je 0x3c90
movq %rcx, -0x48(%rbp)
movl %eax, %edx
imull %r13d, %edx
movl %r12d, %ecx
subl %edx, %ecx
movl %ecx, -0x54(%rbp)
imull %r15d, %eax
movl %r12d, %edx
subl %eax, %edx
movl %edx, -0x34(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x3cc0
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3ccd
leaq -0x50(%rbp), %rdi
leaq -0x54(%rbp), %rdx
callq 0x7dec
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x3ce6
movl -0x34(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3cf3
leaq -0x50(%rbp), %rdi
leaq -0x34(%rbp), %rdx
callq 0x7dec
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0x74f4
incl %r15d
movl (%r14), %eax
cmpl %eax, %r15d
jl 0x3c82
movl -0x30(%rbp), %eax
cmpl (%r14), %eax
jl 0x3c69
movl -0x2c(%rbp), %eax
incl %eax
movl %eax, -0x2c(%rbp)
cmpl (%r14), %eax
jl 0x3c56
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3d39
callq 0x21d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3d59
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x58(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
cmpl $0x0, (%rdi)
jle 0x3df9
movq %rdi, %r14
xorl %r13d, %r13d
leaq -0x50(%rbp), %r15
leaq -0x2c(%rbp), %r12
movq -0x50(%rbp), %rax
cmpq %rax, -0x48(%rbp)
je 0x3da7
movq %rax, -0x48(%rbp)
movl (%r14), %eax
testl %eax, %eax
jle 0x3de5
xorl %ebx, %ebx
imull %r13d, %eax
addl %ebx, %eax
incl %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x3dd1
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3ddc
movq %r15, %rdi
movq %r12, %rdx
callq 0x7dec
incl %ebx
movl (%r14), %eax
cmpl %eax, %ebx
jl 0x3db0
movq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x74f4
incl %r13d
cmpl (%r14), %r13d
jl 0x3d99
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3e07
callq 0x21d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e18
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3e29
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x60(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
cmpl $0x0, (%rdi)
jle 0x3f48
movq %rdi, %r14
movl $0x0, -0x34(%rbp)
xorl %r13d, %r13d
cmpl $0x0, (%r14)
jle 0x3f39
xorl %eax, %eax
movl $0xfffffffe, -0x2c(%rbp) # imm = 0xFFFFFFFE
movl %eax, %r15d
leal 0x1(%r15), %ecx
movl (%r14), %eax
movl %ecx, -0x30(%rbp)
cmpl %eax, %ecx
jge 0x3f2a
notl %r15d
movl -0x2c(%rbp), %ebx
movl -0x30(%rbp), %r12d
movq -0x50(%rbp), %rcx
cmpq %rcx, -0x48(%rbp)
je 0x3eac
movq %rcx, -0x48(%rbp)
movl -0x34(%rbp), %edx
imull %eax, %edx
imull %r13d, %eax
movl %r15d, %ecx
subl %eax, %ecx
movl %ecx, -0x54(%rbp)
addl %ebx, %edx
movl %edx, -0x38(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x3ed9
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3ee6
leaq -0x50(%rbp), %rdi
leaq -0x54(%rbp), %rdx
callq 0x7dec
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x3eff
movl -0x38(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3f0c
leaq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x7dec
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x74f4
incl %r12d
movl (%r14), %eax
decl %ebx
cmpl %eax, %r12d
jl 0x3e9e
decl -0x2c(%rbp)
movl -0x30(%rbp), %eax
cmpl (%r14), %eax
jl 0x3e7f
incl %r13d
decl -0x34(%rbp)
cmpl (%r14), %r13d
jl 0x3e6c
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3f56
callq 0x21d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3f76
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x58(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
cmpl $0x2, (%rdi)
jl 0x4087
movq %rdi, %r14
xorl %r15d, %r15d
leal 0x1(%r15), %ebx
xorl %r13d, %r13d
movq %r15, -0x60(%rbp)
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x4077
movq -0x50(%rbp), %rcx
cmpq %rcx, -0x48(%rbp)
je 0x3fd6
movq %rcx, -0x48(%rbp)
imull %r15d, %eax
movl %r13d, %ecx
notl %ecx
subl %eax, %ecx
movl %ecx, -0x2c(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x3ffa
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x4007
leaq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x3402
movq 0x38(%r14), %rax
leaq (,%r13,2), %rcx
addq %r13, %rcx
movq (%rax,%rcx,8), %r12
movq 0x8(%rax,%rcx,8), %r15
cmpq %r15, %r12
je 0x405e
movl (%r12), %eax
movl (%r14), %ecx
imull %ebx, %ecx
addl %ecx, %eax
incl %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x404b
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x4058
leaq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x7dec
addq $0x4, %r12
jmp 0x401f
incq %r13
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x74f4
movq -0x60(%rbp), %r15
jmp 0x3fbc
movl (%r14), %eax
decl %eax
movl %ebx, %r15d
cmpl %eax, %ebx
jl 0x3fb1
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4095
callq 0x21d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x40a8
jmp 0x40a8
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x40b9
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq (%rdx), %r15
movq 0x8(%rdx), %r12
cmpq %r12, %r15
je 0x4115
movq %rsi, %rbx
leaq -0x40(%rbp), %r14
movq -0x40(%rbp), %rax
cmpq %rax, -0x38(%rbp)
je 0x4101
movq %rax, -0x38(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x74f4
addq $0x8, %r15
cmpq %r12, %r15
jne 0x40f3
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x4123
callq 0x21d0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x4141
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq %rax, -0x58(%rbp)
movq %rcx, -0x60(%rbp)
cmpq %rcx, %rax
je 0x4286
movq %rsi, %rbx
movq %rdi, %r14
movl (%r14), %eax
testl %eax, %eax
jle 0x4270
movq -0x58(%rbp), %rcx
movl (%rcx), %r12d
movl 0x4(%rcx), %r13d
notl %r12d
incl %r13d
xorl %r15d, %r15d
movq -0x50(%rbp), %rcx
cmpq %rcx, -0x48(%rbp)
je 0x41b5
movq %rcx, -0x48(%rbp)
imull %r15d, %eax
movl %r12d, %ecx
subl %eax, %ecx
movl %ecx, -0x2c(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x41d7
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x41e4
leaq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x3402
testl %r15d, %r15d
je 0x421a
leal -0x1(%r15), %eax
imull (%r14), %eax
addl %r13d, %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x420d
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x421a
leaq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x7dec
movl (%r14), %eax
leal -0x1(%rax), %ecx
cmpl %ecx, %r15d
jge 0x4255
leal 0x1(%r15), %ecx
imull %ecx, %eax
addl %r13d, %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x4248
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x4255
leaq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x7dec
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0x74f4
incl %r15d
movl (%r14), %eax
cmpl %eax, %r15d
jl 0x41a7
movq -0x58(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
cmpq -0x60(%rbp), %rax
jne 0x4188
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4294
callq 0x21d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x42a9
jmp 0x42a9
jmp 0x42a9
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x42ba
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x58(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
cmpl $0x0, (%rdi)
jle 0x441e
movq %rdi, %r14
xorl %r13d, %r13d
cmpl $0x0, (%r14)
jle 0x4412
xorl %r12d, %r12d
movl (%r14), %eax
testl %eax, %eax
jle 0x4406
movl %r12d, %ecx
notl %ecx
movl %ecx, -0x4c(%rbp)
xorl %r15d, %r15d
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl %r15d, %r12d
je 0x43f5
cmpl %r12d, %r13d
je 0x43f5
cmpl %r15d, %r13d
je 0x43f5
movl %eax, %ecx
imull %r13d, %ecx
movl %eax, %edx
imull %eax, %edx
addl %ecx, %edx
movl -0x4c(%rbp), %ecx
subl %edx, %ecx
movl %ecx, -0x50(%rbp)
leal (%r12,%rax), %edx
imull %eax, %edx
movl %ebx, %esi
subl %edx, %esi
movl %esi, -0x48(%rbp)
leal (%rax,%r13), %edx
imull %eax, %edx
leal (%r15,%rdx), %eax
incl %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rax
cmpq %rax, -0x38(%rbp)
je 0x4379
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x438f
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x439c
leaq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x7dec
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x43b5
movl -0x48(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x43c2
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x7dec
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x43db
movl -0x44(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x43e8
leaq -0x40(%rbp), %rdi
leaq -0x44(%rbp), %rdx
callq 0x7dec
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x74f4
incl %r15d
movl (%r14), %eax
decl %ebx
cmpl %eax, %r15d
jl 0x431d
incl %r12d
cmpl (%r14), %r12d
jl 0x4302
incl %r13d
cmpl (%r14), %r13d
jl 0x42f5
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x442c
callq 0x21d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x444c
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
cmpl $0x0, (%rdi)
jle 0x45b0
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
leaq -0x50(%rbp), %r15
movl (%r14), %eax
testl %eax, %eax
jle 0x45a4
leal 0x1(%r13), %ecx
movl %ecx, -0x58(%rbp)
xorl %r12d, %r12d
cmpl %r12d, %r13d
je 0x4595
movl %eax, %edx
imull %eax, %edx
leal (%rax,%r13), %ecx
imull %eax, %ecx
addl %r12d, %ecx
incl %ecx
movl %ecx, -0x54(%rbp)
imull %r12d, %eax
addl -0x58(%rbp), %eax
addl %edx, %eax
movl %eax, -0x30(%rbp)
movq -0x50(%rbp), %rax
cmpq %rax, -0x48(%rbp)
je 0x44d6
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x44ec
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x44f8
movq %r15, %rdi
leaq -0x54(%rbp), %rdx
callq 0x7dec
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x4511
movl -0x30(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x451d
movq %r15, %rdi
leaq -0x30(%rbp), %rdx
callq 0x7dec
movq %rbx, %rdi
movq %r15, %rsi
callq 0x74f4
movq -0x50(%rbp), %rax
cmpq %rax, -0x48(%rbp)
je 0x4536
movq %rax, -0x48(%rbp)
xorl %eax, %eax
subl -0x54(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x4554
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x4560
movq %r15, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x3402
xorl %eax, %eax
subl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x457e
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x458a
movq %r15, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x3402
movq %rbx, %rdi
movq %r15, %rsi
callq 0x74f4
incl %r12d
movl (%r14), %eax
cmpl %eax, %r12d
jl 0x449f
incl %r13d
cmpl (%r14), %r13d
jl 0x448a
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x45be
callq 0x21d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x45d1
jmp 0x45d1
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x45e2
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, -0x68(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
cmpl $0x2, (%rdi)
jl 0x4736
movl $0x0, -0x2c(%rbp)
movl $0xffffffff, -0x54(%rbp) # imm = 0xFFFFFFFF
cmpl $0x0, (%rdi)
jle 0x471f
xorl %ebx, %ebx
movq %rdi, %r15
movl (%rdi), %eax
testl %eax, %eax
jle 0x4711
movl %ebx, %r13d
notl %r13d
xorl %r12d, %r12d
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %eax, %edx
imull -0x2c(%rbp), %edx
movl %r13d, %ecx
subl %edx, %ecx
movl %ecx, -0x60(%rbp)
movl -0x54(%rbp), %edx
imull %eax, %edx
addl %r14d, %edx
movl %edx, -0x5c(%rbp)
leal (%rbx,%rax), %edx
imull %eax, %edx
leal (%r12,%rdx), %eax
incl %eax
movl %eax, -0x58(%rbp)
movq -0x50(%rbp), %rax
cmpq %rax, -0x48(%rbp)
je 0x4683
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x4699
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x46a6
leaq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x7dec
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x46bf
movl -0x5c(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x46cc
leaq -0x50(%rbp), %rdi
leaq -0x5c(%rbp), %rdx
callq 0x7dec
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x46e5
movl -0x58(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x46f2
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x7dec
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x74f4
incl %r12d
movl (%r15), %eax
decl %r14d
cmpl %eax, %r12d
jl 0x464c
incl %ebx
movq %r15, %rdi
cmpl (%r15), %ebx
jl 0x4630
movl -0x2c(%rbp), %ecx
incl %ecx
movl (%rdi), %eax
decl %eax
decl -0x54(%rbp)
movl %ecx, -0x2c(%rbp)
cmpl %eax, %ecx
jl 0x4625
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4744
callq 0x21d0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4764
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movl (%rdi), %eax
testl %eax, %eax
jle 0x47fb
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
leaq -0x50(%rbp), %r12
cmpl %r13d, %ebx
je 0x47f0
leal (%rax,%rbx), %ecx
imull %eax, %ecx
leal (%rcx,%r13), %eax
incl %eax
movl %eax, -0x2c(%rbp)
movq -0x50(%rbp), %rcx
cmpq %rcx, -0x48(%rbp)
je 0x47c3
movq %rcx, -0x48(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x47d9
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x47e5
movq %r12, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x7dec
movq %r14, %rdi
movq %r12, %rsi
callq 0x74f4
incl %r13d
movl (%r15), %eax
cmpl %eax, %r13d
jl 0x47a1
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4809
callq 0x21d0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4829
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movl (%rdi), %eax
testl %eax, %eax
jle 0x48c1
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leal 0x1(%rbx), %r13d
xorl %r12d, %r12d
cmpl %r12d, %ebx
je 0x48b6
leal (%rax,%r12), %ecx
imull %eax, %ecx
addl %r13d, %ecx
movl %ecx, -0x44(%rbp)
movq -0x40(%rbp), %rax
cmpq %rax, -0x38(%rbp)
je 0x4887
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x489d
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x48aa
leaq -0x40(%rbp), %rdi
leaq -0x44(%rbp), %rdx
callq 0x7dec
movq %r14, %rdi
leaq -0x40(%rbp), %rsi
callq 0x74f4
incl %r12d
movl (%r15), %eax
cmpl %eax, %r12d
jl 0x4867
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x48cf
callq 0x21d0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x48ef
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4922
movq $0x0, -0x28(%rbp)
incl %edx
movl %edx, -0xc(%rbp)
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x493d
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x494a
leaq -0x30(%rbp), %rdi
leaq -0xc(%rbp), %rdx
callq 0x7dec
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x74f4
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x4964
callq 0x21d0
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x497c
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x49ae
movq $0x0, -0x28(%rbp)
movl (%rdi), %eax
leal -0x1(%rax), %ecx
imull %eax, %ecx
leal (%rdx,%rcx), %eax
incl %eax
movl %eax, -0xc(%rbp)
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x49d4
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x49e1
leaq -0x30(%rbp), %rdi
leaq -0xc(%rbp), %rdx
callq 0x7dec
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x74f4
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x49fb
callq 0x21d0
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x4a13
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::construct_sat(int, int, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&)
void Graph::construct_sat(int source, int dest,
                          const std::vector< std::pair<int,int> >& map,
                          const std::vector< std::pair<int,int> >& diamonds)
{
    std::vector<int> clause;
    std::vector< std::vector<int> > clauses;

    condition1(clauses);
    condition2(clauses);
    condition3(clauses);
    condition4(clauses); // useful
    condition5(clauses);
    condition6(clauses, map);
    condition7(clauses, diamonds);
    condition13(clauses, source); // not useful
    condition14(clauses, dest); // not useful
    // order relation 
    
    condition8(clauses);
    condition9(clauses);
    condition10(clauses);
    condition11(clauses, source);
    condition12(clauses, dest);
    
    

    write_sat(clauses);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movq %rcx, %r13
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x3b4e
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3c20
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3d62
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3e32
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3f7e
leaq -0x40(%rbp), %rsi
movq %r13, %rdx
callq 0x40c2
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x414a
leaq -0x40(%rbp), %rsi
movl %r15d, %edx
callq 0x48f8
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x4984
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x42c2
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x4454
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x45ea
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
movl %r15d, %edx
callq 0x476c
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x4832
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x4b34
leaq -0x40(%rbp), %rdi
callq 0x3136
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3136
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: get_path(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string get_path(std::string file_name){
    char buffer[1024];  
    int buffer_size = 1024;
    
    readlink("/proc/self/exe", buffer, buffer_size);
    std::string path(dirname(buffer));
    path = path + "/" + file_name;
    return path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x440, %rsp            # imm = 0x440
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4407(%rip), %rdi      # 0x919c
leaq -0x460(%rbp), %r15
movl $0x400, %edx            # imm = 0x400
movq %r15, %rsi
callq 0x2210
movq %r15, %rdi
callq 0x20e0
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x20c0
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x3220
leaq 0x43cd(%rip), %rsi      # 0x91af
leaq -0x40(%rbp), %rdi
callq 0x23c0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq -0x40(%rbp), %rdi
callq 0x2090
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4e20
movq %rdx, -0x60(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x50(%rbp)
jmp 0x4e28
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq -0x60(%rbp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2280
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x4e5b
callq 0x21d0
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x4e69
callq 0x21d0
movq %rbx, %rax
addq $0x440, %rsp            # imm = 0x440
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4e7e
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x4e94
callq 0x21d0
jmp 0x4e94
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x4ea5
callq 0x21d0
movq %r14, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::ham_path_sat(int, int, bool, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&)
std::vector< std::vector<int> >&
Graph::ham_path_sat(int first,
                    int last,
                    bool count,
                    const std::vector< std::pair<int,int> >& map,
                    const std::vector< std::pair<int,int> >& diamonds)
{
    paths.clear();
    construct_sat(first, last, map, diamonds);
    solve_sat();
    path = read_sol();

    while(!path.empty()){
        paths.push_back(path);
        
        if(!count)  break;

        int nvars, nclauses;
        auto ban = create_ban(path);
        extend_sat(ban, nvars, nclauses);
        recopy(nvars, nclauses);
        solve_sat();
        path = read_sol();
    }
    
    return paths;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rbx
movq %r8, -0x40(%rbp)
movl %ecx, -0x2c(%rbp)
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %r15
leaq 0x78(%rdi), %r14
movq %r14, %rdi
callq 0x769a
movq %r15, %rdi
movl %r13d, %esi
movl %r12d, %edx
movq -0x40(%rbp), %rcx
movq %rbx, %r8
callq 0x4a1c
callq 0x52fe
movq %r15, %rdi
callq 0x4eae
leaq 0x90(%r15), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x76dc
movq 0x90(%r15), %rax
cmpq 0x98(%r15), %rax
je 0x52bc
leaq -0x70(%rbp), %rbx
leaq -0x80(%rbp), %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x74f4
cmpb $0x0, -0x2c(%rbp)
je 0x52bc
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x59f2
movq %rbx, -0x80(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x3220
movq %r13, %rsi
leaq -0x34(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x5c18
movq -0x80(%rbp), %rdi
cmpq %rbx, %rdi
je 0x5273
callq 0x21d0
movl -0x34(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0x5fe6
callq 0x52fe
movq %r15, %rdi
callq 0x4eae
movq %r12, %rdi
movq %rax, %rsi
callq 0x76dc
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x52a8
callq 0x21d0
movq 0x90(%r15), %rax
cmpq 0x98(%r15), %rax
jne 0x521a
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x80(%rbp), %rdi
cmpq %rbx, %rdi
je 0x52e4
callq 0x21d0
jmp 0x52e4
movq %rax, %r14
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x52f6
callq 0x21d0
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::ham_cycle_sat(bool, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&)
std::vector< std::vector<int> >&
Graph::ham_cycle_sat(bool count,
                     const std::vector< std::pair<int,int> >& map,
                     const std::vector< std::pair<int,int> >& diamonds)
{
    int min_deg_v = INT_MAX;
    int min_deg = -1;
    for(int i = 0; i < adj_list.size(); i++){
        if(adj_list[i].size() < min_deg){
            min_deg = adj_list[i].size();
            min_deg_v = i;
        }
    }
    std::vector< std::vector<int> > sol;

    for(int source : adj_list[min_deg_v]){
        paths = ham_path_sat(source, min_deg_v, count, map, diamonds);
        sol.insert(sol.begin(), paths.begin(), paths.end());
        if(!count && !sol.empty())  break;
    }
    
    paths = sol;
    return paths;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rdx
subq %rax, %rdx
je 0x6340
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
leaq 0x8(%rax), %rdx
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %edi, %edi
movq (%rdx), %r8
subq -0x8(%rdx), %r8
sarq $0x2, %r8
movslq %r9d, %r9
cmpq %r9, %r8
cmovbl %r8d, %r9d
cmovbl %edi, %r13d
incq %rdi
addq $0x18, %rdx
cmpq %rdi, %rcx
jne 0x6319
jmp 0x6346
movl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movslq %r13d, %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %r12
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
cmpq %rax, %r12
je 0x63e2
leaq 0x78(%rbx), %rax
movq %rax, -0x48(%rbp)
addq $0x4, %r12
movl %esi, %r14d
movzbl %r14b, %r15d
xorb $0x1, %r14b
movl -0x4(%r12), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl %r15d, %ecx
movq -0x58(%rbp), %r8
movq -0x60(%rbp), %r9
callq 0x519a
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x7530
movq -0x40(%rbp), %rsi
movq 0x78(%rbx), %rdx
movq 0x80(%rbx), %rcx
leaq -0x40(%rbp), %rdi
callq 0x8138
movq -0x38(%rbp), %rax
cmpq %rax, -0x40(%rbp)
setne %al
testb %al, %r14b
jne 0x63e2
leaq 0x4(%r12), %rax
cmpq -0x50(%rbp), %r12
movq %rax, %r12
jne 0x6385
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq -0x40(%rbp), %rdi
callq 0x3136
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6411
jmp 0x6411
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3136
movq %rbx, %rdi
callq 0x2380
nop