LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
callq 0x2130
movslq -0x2c(%rbp), %rsi
testq %rsi, %rsi
jle 0x393d
movl %esi, (%rbx)
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq %r14, %rdi
callq 0x7bfc
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x38a2
callq 0x21d0
leaq -0x50(%rbp), %r12
leaq -0x30(%rbp), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x2130
cmpl $0x0, -0x50(%rbp)
js 0x3907
movq %r15, %rdi
movq %r13, %rsi
callq 0x2130
movslq -0x50(%rbp), %rax
movl -0x2c(%rbp), %edx
cmpl %edx, %eax
jge 0x3916
movl -0x30(%rbp), %ecx
testl %ecx, %ecx
js 0x3916
cmpl %edx, %ecx
jge 0x3916
movq (%r14), %rdx
leaq (%rax,%rax,2), %rax
leaq (%rdx,%rax,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x38fd
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x38aa
movq %r13, %rdx
callq 0x7d42
jmp 0x38aa
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x2100
leaq 0x582a(%rip), %rcx      # 0x9151
movq %rcx, (%rax)
movq 0x967f(%rip), %rsi      # 0xcfb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x2360
jmp 0x3962
movl $0x8, %edi
callq 0x2100
leaq 0x57d2(%rip), %rcx      # 0x9120
movq %rcx, (%rax)
movq 0x9658(%rip), %rsi      # 0xcfb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x2360
movq %rax, %r15
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x397c
callq 0x21d0
jmp 0x397c
jmp 0x3979
jmp 0x3979
movq %rax, %r15
leaq 0x50(%rbx), %r12
leaq 0x78(%rbx), %r13
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x3995
callq 0x21d0
movq %r13, %rdi
callq 0x3122
movq %r12, %rdi
callq 0x31d8
leaq 0x8(%rbx), %rdx
addq $0x20, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2421
movq %r15, %rdi
callq 0x2380
movq %rax, %rdi
callq 0x3208
// File: /workspace/github_cpp_makefile_star2_O3/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)
movl (%rdi), %eax
testl %eax, %eax
jle 0x3b7c
movq %rdi, %r14
xorl %r13d, %r13d
leaq -0x50(%rbp), %r15
movq -0x50(%rbp), %rcx
cmpq %rcx, -0x48(%rbp)
je 0x3b16
movq %rcx, -0x48(%rbp)
testl %eax, %eax
jle 0x3b57
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 0x3b40
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3b4c
movq %r15, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x7d42
incl %r12d
movl (%r14), %eax
cmpl %eax, %r12d
jl 0x3b21
movq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x73fa
incl %r13d
movl (%r14), %eax
cmpl %eax, %r13d
jl 0x3b08
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3b7c
callq 0x21d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b8d
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3b9e
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/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)
movl (%rdi), %eax
testl %eax, %eax
jle 0x3cbb
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
testl %eax, %eax
movl %r12d, -0x54(%rbp)
jle 0x3c9d
notl %r12d
xorl %ecx, %ecx
movl %ecx, %r13d
leal 0x1(%r13), %r15d
cmpl %eax, %r15d
movl %r15d, -0x58(%rbp)
jge 0x3c92
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rsi
cmpq %rcx, %rsi
je 0x3c12
movq %rcx, -0x48(%rbp)
movq %rcx, %rsi
movl %eax, %edx
imull %r13d, %edx
movl %r12d, %ecx
subl %edx, %ecx
movl %ecx, -0x5c(%rbp)
imull %r15d, %eax
movl %r12d, %edx
subl %eax, %edx
movl %edx, -0x2c(%rbp)
movq -0x40(%rbp), %rax
cmpq %rax, %rsi
je 0x3c41
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3c56
leaq -0x50(%rbp), %rdi
leaq -0x5c(%rbp), %rdx
callq 0x7d42
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rax
cmpq %rax, %rsi
je 0x3c6a
movl -0x2c(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3c77
leaq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x7d42
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0x73fa
incl %r15d
movl (%r14), %eax
cmpl %eax, %r15d
jl 0x3bfe
movl -0x58(%rbp), %ecx
cmpl %eax, %ecx
jl 0x3bea
movl -0x54(%rbp), %r12d
incl %r12d
cmpl %eax, %r12d
jl 0x3bd9
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3cbb
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 0x3cdb
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
movl (%rdi), %eax
testl %eax, %eax
jle 0x3d8a
movq %rdi, %r14
xorl %r13d, %r13d
leaq -0x50(%rbp), %r15
leaq -0x2c(%rbp), %r12
movq -0x50(%rbp), %rcx
cmpq %rcx, -0x48(%rbp)
je 0x3d2a
movq %rcx, -0x48(%rbp)
testl %eax, %eax
jle 0x3d65
xorl %ebx, %ebx
imull %r13d, %eax
addl %ebx, %eax
incl %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x3d51
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3d5c
movq %r15, %rdi
movq %r12, %rdx
callq 0x7d42
incl %ebx
movl (%r14), %eax
cmpl %eax, %ebx
jl 0x3d30
movq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x73fa
incl %r13d
movl (%r14), %eax
cmpl %eax, %r13d
jl 0x3d1c
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3d8a
callq 0x21d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3d9b
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3dac
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x48, %rsp
movq %rsi, -0x70(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq %rdi, -0x68(%rbp)
movl (%rdi), %eax
testl %eax, %eax
jle 0x3ed9
xorl %r12d, %r12d
xorl %r13d, %r13d
testl %eax, %eax
jle 0x3ebc
xorl %ecx, %ecx
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
movl %ecx, %r15d
leal 0x1(%r15), %r14d
cmpl %eax, %r14d
movl %ebx, -0x58(%rbp)
movl %r14d, -0x54(%rbp)
jge 0x3eac
notl %r15d
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rsi
cmpq %rcx, %rsi
je 0x3e29
movq %rcx, -0x48(%rbp)
movq %rcx, %rsi
movl %r12d, %edx
imull %eax, %edx
imull %r13d, %eax
movl %r15d, %ecx
subl %eax, %ecx
movl %ecx, -0x5c(%rbp)
addl %ebx, %edx
movl %edx, -0x2c(%rbp)
movq -0x40(%rbp), %rax
cmpq %rax, %rsi
je 0x3e55
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3e6a
leaq -0x50(%rbp), %rdi
leaq -0x5c(%rbp), %rdx
callq 0x7d42
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rax
cmpq %rax, %rsi
je 0x3e7e
movl -0x2c(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3e8b
leaq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x7d42
movq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x73fa
incl %r14d
movq -0x68(%rbp), %rax
movl (%rax), %eax
decl %ebx
cmpl %eax, %r14d
jl 0x3e15
movl -0x58(%rbp), %ebx
decl %ebx
movl -0x54(%rbp), %ecx
cmpl %eax, %ecx
jl 0x3dfb
incl %r13d
decl %r12d
cmpl %eax, %r13d
jl 0x3dec
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3ed9
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 0x3ef9
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4018
movq %rdi, %r14
xorl %r15d, %r15d
leal 0x1(%r15), %ebx
xorl %r13d, %r13d
movq %r15, -0x60(%rbp)
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x3ffd
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rsi
cmpq %rcx, %rsi
je 0x3f60
movq %rcx, -0x48(%rbp)
movq %rcx, %rsi
imull %r15d, %eax
movl %r13d, %ecx
notl %ecx
subl %eax, %ecx
movl %ecx, -0x2c(%rbp)
cmpq -0x40(%rbp), %rsi
je 0x3f80
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3f8d
leaq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x33fc
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 0x3fe4
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 0x3fd1
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3fde
leaq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x7d42
addq $0x4, %r12
jmp 0x3fa5
incq %r13
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x73fa
movq -0x60(%rbp), %r15
jmp 0x3f40
decl %eax
movl %ebx, %r15d
cmpl %eax, %ebx
jl 0x3f35
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4018
callq 0x21d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x402b
jmp 0x402b
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x403c
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40a5
movq %rsi, %rbx
leaq -0x40(%rbp), %r14
movq -0x40(%rbp), %rax
cmpq %rax, -0x38(%rbp)
je 0x4083
movq %rax, -0x38(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73fa
addq $0x8, %r15
cmpq %r12, %r15
jne 0x4075
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x40a5
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 0x40c3
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rcx
movq 0x8(%rdx), %rax
movq %rax, -0x58(%rbp)
cmpq %rax, %rcx
je 0x420f
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
testl %eax, %eax
movq %rcx, -0x60(%rbp)
jle 0x41ef
movl (%rcx), %r13d
movl 0x4(%rcx), %r12d
notl %r13d
incl %r12d
xorl %r15d, %r15d
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rsi
cmpq %rcx, %rsi
je 0x4138
movq %rcx, -0x48(%rbp)
movq %rcx, %rsi
imull %r15d, %eax
movl %r13d, %ecx
subl %eax, %ecx
movl %ecx, -0x2c(%rbp)
cmpq -0x40(%rbp), %rsi
je 0x4156
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x4163
leaq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x33fc
testl %r15d, %r15d
je 0x4199
leal -0x1(%r15), %eax
imull (%r14), %eax
addl %r12d, %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x418c
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x4199
leaq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x7d42
movl (%r14), %eax
leal -0x1(%rax), %ecx
cmpl %ecx, %r15d
jge 0x41d4
leal 0x1(%r15), %ecx
imull %ecx, %eax
addl %r12d, %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x41c7
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x41d4
leaq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x7d42
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0x73fa
incl %r15d
movl (%r14), %eax
cmpl %eax, %r15d
jl 0x4124
movq -0x60(%rbp), %rcx
addq $0x8, %rcx
cmpq -0x58(%rbp), %rcx
jne 0x4108
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x420f
callq 0x21d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4224
jmp 0x4224
jmp 0x4224
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4235
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x48, %rsp
movq %rsi, -0x68(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq %rdi, -0x60(%rbp)
movl (%rdi), %eax
testl %eax, %eax
jle 0x43a1
xorl %r13d, %r13d
leaq -0x50(%rbp), %r15
testl %eax, %eax
jle 0x4387
xorl %r12d, %r12d
testl %eax, %eax
jle 0x437b
movl %r12d, %ebx
notl %ebx
xorl %r14d, %r14d
cmpl %r14d, %r12d
je 0x42fc
cmpl %r12d, %r13d
je 0x42fc
cmpl %r14d, %r13d
je 0x42fc
movl %eax, %edx
imull %r13d, %edx
movl %eax, %esi
imull %esi, %esi
movl %ebx, %ecx
subl %esi, %ecx
subl %edx, %ecx
movl %ecx, -0x54(%rbp)
movl %r14d, %edi
notl %edi
leal (%rax,%r12), %r8d
imull %eax, %r8d
subl %r8d, %edi
movl %edi, -0x30(%rbp)
leal (%r14,%rdx), %eax
incl %eax
addl %esi, %eax
movl %eax, -0x2c(%rbp)
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rsi
cmpq %rax, %rsi
je 0x42e7
movq %rax, -0x48(%rbp)
movq %rax, %rsi
movq -0x40(%rbp), %rax
cmpq %rax, %rsi
je 0x4301
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x4315
incl %r14d
jmp 0x4372
movq %r15, %rdi
leaq -0x54(%rbp), %rdx
callq 0x7d42
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rax
cmpq %rax, %rsi
je 0x4329
movl -0x30(%rbp), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x433d
movq %r15, %rdi
leaq -0x30(%rbp), %rdx
callq 0x7d42
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rax
cmpq %rax, %rsi
je 0x4351
movl -0x2c(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x435d
movq %r15, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x7d42
movq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x73fa
incl %r14d
movq -0x60(%rbp), %rax
movl (%rax), %eax
cmpl %eax, %r14d
jl 0x4292
incl %r12d
cmpl %eax, %r12d
jl 0x4282
incl %r13d
cmpl %eax, %r13d
jl 0x4277
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x43a1
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 0x43c1
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq %rdi, -0x60(%rbp)
movl (%rdi), %eax
testl %eax, %eax
jle 0x4548
movq %rsi, %rbx
xorl %r13d, %r13d
leaq -0x50(%rbp), %r15
leal 0x1(%r13), %r12d
testl %eax, %eax
jle 0x452e
xorl %r14d, %r14d
cmpl %r14d, %r13d
jne 0x441e
incl %r14d
jmp 0x4525
movl %eax, %ecx
imull %r13d, %ecx
movl %eax, %edx
imull %eax, %edx
addl %r14d, %ecx
incl %ecx
addl %edx, %ecx
movl %ecx, -0x54(%rbp)
imull %r14d, %eax
addl %r12d, %eax
addl %edx, %eax
movl %eax, -0x30(%rbp)
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rsi
cmpq %rax, %rsi
je 0x4453
movq %rax, -0x48(%rbp)
movq %rax, %rsi
movq -0x40(%rbp), %rax
cmpq %rax, %rsi
je 0x4468
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x447c
movq %r15, %rdi
leaq -0x54(%rbp), %rdx
callq 0x7d42
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rax
cmpq %rax, %rsi
je 0x4490
movl -0x30(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x449c
movq %r15, %rdi
leaq -0x30(%rbp), %rdx
callq 0x7d42
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73fa
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rsi
cmpq %rax, %rsi
je 0x44bb
movq %rax, -0x48(%rbp)
movq %rax, %rsi
xorl %ecx, %ecx
subl -0x54(%rbp), %ecx
movl %ecx, -0x2c(%rbp)
movq -0x40(%rbp), %rax
cmpq %rax, %rsi
je 0x44d8
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x44ec
movq %r15, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x33fc
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rax
xorl %ecx, %ecx
subl -0x30(%rbp), %ecx
movl %ecx, -0x2c(%rbp)
cmpq %rax, %rsi
je 0x4505
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x4511
movq %r15, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x33fc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73fa
incl %r14d
movq -0x60(%rbp), %rax
movl (%rax), %eax
cmpl %eax, %r14d
jl 0x4411
movl %r12d, %r13d
cmpl %eax, %r12d
jl 0x4402
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4548
callq 0x21d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x455b
jmp 0x455b
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x456c
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq %rdi, -0x60(%rbp)
movl (%rdi), %eax
cmpl $0x2, %eax
jl 0x46d7
movl $0x0, -0x2c(%rbp)
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
leaq -0x50(%rbp), %r15
testl %eax, %eax
jle 0x46b3
xorl %ebx, %ebx
testl %eax, %eax
jle 0x46a9
movl %ebx, %r14d
notl %r14d
xorl %r13d, %r13d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl %eax, %edx
imull -0x2c(%rbp), %edx
movl %r14d, %ecx
subl %edx, %ecx
movl %ecx, -0x54(%rbp)
movl -0x30(%rbp), %edx
imull %eax, %edx
addl %r12d, %edx
movl %edx, -0x38(%rbp)
leal (%rbx,%rax), %edx
imull %eax, %edx
leal (%rdx,%r13), %eax
incl %eax
movl %eax, -0x34(%rbp)
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rsi
cmpq %rax, %rsi
je 0x4617
movq %rax, -0x48(%rbp)
movq %rax, %rsi
movq -0x40(%rbp), %rax
cmpq %rax, %rsi
je 0x462c
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x4640
movq %r15, %rdi
leaq -0x54(%rbp), %rdx
callq 0x7d42
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rax
cmpq %rax, %rsi
je 0x4654
movl -0x38(%rbp), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x4668
movq %r15, %rdi
leaq -0x38(%rbp), %rdx
callq 0x7d42
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rax
cmpq %rax, %rsi
je 0x467c
movl -0x34(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x4688
movq %r15, %rdi
leaq -0x34(%rbp), %rdx
callq 0x7d42
movq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x73fa
incl %r13d
movq -0x60(%rbp), %rax
movl (%rax), %eax
decl %r12d
cmpl %eax, %r13d
jl 0x45da
incl %ebx
cmpl %eax, %ebx
jl 0x45c3
movl -0x2c(%rbp), %edx
incl %edx
leal -0x1(%rax), %ecx
decl -0x30(%rbp)
movl %edx, -0x2c(%rbp)
cmpl %ecx, %edx
jl 0x45b9
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x46d7
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 0x46f7
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x47a4
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
leaq -0x50(%rbp), %r12
cmpl %ebx, %r13d
jne 0x473f
incl %r13d
jmp 0x4791
leal (%rax,%rbx), %ecx
imull %eax, %ecx
leal (%rcx,%r13), %eax
incl %eax
movl %eax, -0x2c(%rbp)
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rsi
cmpq %rcx, %rsi
je 0x4762
movq %rcx, -0x48(%rbp)
movq %rcx, %rsi
cmpq -0x40(%rbp), %rsi
je 0x4774
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x4780
movq %r12, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x7d42
movq %r14, %rdi
movq %r12, %rsi
callq 0x73fa
incl %r13d
movl (%r15), %eax
cmpl %eax, %r13d
jl 0x4735
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x47a4
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 0x47c4
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movl (%rdi), %eax
testl %eax, %eax
jle 0x486b
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leal 0x1(%rbx), %r13d
xorl %r12d, %r12d
cmpl %r12d, %ebx
je 0x4855
leal (%rax,%r12), %ecx
imull %eax, %ecx
addl %r13d, %ecx
movl %ecx, -0x2c(%rbp)
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rsi
cmpq %rax, %rsi
je 0x4827
movq %rax, -0x48(%rbp)
movq %rax, %rsi
cmpq -0x40(%rbp), %rsi
je 0x4839
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x4846
leaq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x7d42
movq %r14, %rdi
leaq -0x50(%rbp), %rsi
callq 0x73fa
movl (%r15), %eax
incl %r12d
cmpl %eax, %r12d
jl 0x4801
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x486b
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 0x488b
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq -0x30(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
incl %edx
leaq -0xc(%rbp), %rax
movl %edx, (%rax)
xorl %esi, %esi
movq %rax, %rdx
callq 0x7d42
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x73fa
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x48de
callq 0x21d0
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x48f6
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq -0x30(%rbp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movl (%rdi), %ecx
leal -0x1(%rcx), %esi
imull %ecx, %esi
leal (%rdx,%rsi), %ecx
incl %ecx
leaq -0xc(%rbp), %rdx
movl %ecx, (%rdx)
movq %rax, %rdi
xorl %esi, %esi
callq 0x7d42
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x73fa
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x4953
callq 0x21d0
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x496b
callq 0x21d0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3ad4
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3ba6
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3ce4
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3db4
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3f02
leaq -0x40(%rbp), %rsi
movq %r13, %rdx
callq 0x4044
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x40cc
leaq -0x40(%rbp), %rsi
movl %r15d, %edx
callq 0x4894
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x48fe
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x423e
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x43ca
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x4574
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
movl %r15d, %edx
callq 0x4700
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x47cc
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x4a8c
leaq -0x40(%rbp), %rdi
callq 0x3122
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3122
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x44c7(%rip), %rdi      # 0x91b4
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 0x3216
leaq 0x448d(%rip), %rsi      # 0x91c7
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 0x4d78
movq %rdx, -0x60(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x50(%rbp)
jmp 0x4d80
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 0x4db3
callq 0x21d0
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x4dc1
callq 0x21d0
movq %rbx, %rax
addq $0x440, %rsp            # imm = 0x440
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4dd6
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x4dec
callq 0x21d0
jmp 0x4dec
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x4dfd
callq 0x21d0
movq %r14, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x75e2
movq %r15, %rdi
movl %r13d, %esi
movl %r12d, %edx
movq -0x40(%rbp), %rcx
movq %rbx, %r8
callq 0x4974
callq 0x5256
movq %r15, %rdi
callq 0x4e06
leaq 0x90(%r15), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x7624
movq 0x90(%r15), %rax
cmpq 0x98(%r15), %rax
je 0x5214
leaq -0x70(%rbp), %rbx
leaq -0x80(%rbp), %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x73fa
cmpb $0x0, -0x2c(%rbp)
je 0x5214
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5944
movq %rbx, -0x80(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x3216
movq %r13, %rsi
leaq -0x34(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x5b6a
movq -0x80(%rbp), %rdi
cmpq %rbx, %rdi
je 0x51cb
callq 0x21d0
movl -0x34(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0x5f26
callq 0x5256
movq %r15, %rdi
callq 0x4e06
movq %r12, %rdi
movq %rax, %rsi
callq 0x7624
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x5200
callq 0x21d0
movq 0x90(%r15), %rax
cmpq 0x98(%r15), %rax
jne 0x5172
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 0x523c
callq 0x21d0
jmp 0x523c
movq %rax, %r14
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x524e
callq 0x21d0
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6280
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 0x6259
jmp 0x6286
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 0x6322
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 0x50f2
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x7436
movq -0x40(%rbp), %rsi
movq 0x78(%rbx), %rdx
movq 0x80(%rbx), %rcx
leaq -0x40(%rbp), %rdi
callq 0x8078
movq -0x38(%rbp), %rax
cmpq %rax, -0x40(%rbp)
setne %al
testb %al, %r14b
jne 0x6322
leaq 0x4(%r12), %rax
cmpq -0x50(%rbp), %r12
movq %rax, %r12
jne 0x62c5
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x7436
leaq -0x40(%rbp), %rdi
callq 0x3122
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6351
jmp 0x6351
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3122
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::ham_path_bt(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_bt(int source,
                                                     int last,
                                                     bool count,
                                                     const std::vector< std::pair<int,int> >& map,
                                                     const std::vector< std::pair<int,int> >& diamonds)
{
    paths.clear();
    visited.assign(n_vertices, false);
    path.resize(n_vertices);

    backtracking(source, 0, last, count);
    
    std::vector< std::vector<int> > valid_paths;
    for(auto candidate : paths)
        if(valid(candidate, map, diamonds)) valid_paths.push_back(candidate);
    
    paths = valid_paths;

    return paths;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r14
movq %r8, %r15
movl %ecx, -0x2c(%rbp)
movl %edx, %r13d
movl %esi, %r12d
movq %rdi, %rbx
addq $0x78, %rdi
movq %rdi, -0x58(%rbp)
callq 0x75e2
leaq 0x50(%rbx), %rdi
movslq (%rbx), %rsi
xorl %edx, %edx
callq 0x84d6
leaq 0x90(%rbx), %rdi
movslq (%rbx), %rsi
callq 0x770a
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
movl %r13d, %ecx
movl -0x2c(%rbp), %r8d
callq 0x35d4
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq 0x78(%rbx), %r12
movq 0x80(%rbx), %rbx
cmpq %rbx, %r12
je 0x642a
leaq -0x70(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x335e
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x376e
testb %al, %al
je 0x6413
leaq -0x50(%rbp), %rdi
movq %r13, %rsi
callq 0x73fa
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x6421
callq 0x21d0
addq $0x18, %r12
cmpq %rbx, %r12
jne 0x63ea
leaq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rbx
movq %rbx, %rdi
callq 0x7436
leaq -0x50(%rbp), %rdi
callq 0x3122
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x646a
movq %rax, %rbx
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x646d
callq 0x21d0
jmp 0x646d
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3122
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::k_paths(int, 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&)
std::vector<int>&
Graph::k_paths(int k,
               int source,
               int last,
               const std::vector< std::pair<int, int> >& map,
               const std::vector< std::pair<int, int> >& diamonds)
{
    paths = ham_path_sat(source, last, false, map, diamonds);
    if(paths.size() > k){
        path.clear();
        return path;
    }

    return paths[0]; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl %edx, %esi
movl %ecx, %edx
xorl %ecx, %ecx
callq 0x50f2
leaq 0x78(%rbx), %rdi
movq %rax, %rsi
callq 0x7436
movq 0x78(%rbx), %rax
movq 0x80(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
movslq %r14d, %rcx
cmpq %rcx, %rdx
jbe 0x671c
leaq 0x90(%rbx), %rax
movq 0x90(%rbx), %rcx
cmpq %rcx, 0x98(%rbx)
je 0x671c
movq %rcx, 0x98(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::write_min_cons(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, int, std::basic_ofstream<char, std::char_traits<char>>&)
void Graph::write_min_cons(std::vector<int>& orig_path, std::vector<int>& cons, int num, std::ofstream &ofile){
    for(int v : orig_path){
        ofile << v << "\n";
    }
    
    ofile << "-1\n";

    for(int i = 0; i <= num; i++){
        int con = cons[i];

        if(con < 0){
            con = -con;
            ofile << orig_path[con] << " " << con + 1 << "\n";
        }
    }

    ofile << "-1\n";

    for(int i = 0; i <= num; i++){
        int con = cons[i];

        if(con >= 0){
            int u = orig_path[con];
            int v = orig_path[con+1];
            ofile << u << " " << v << "\n";
        }
    }

    ofile << "-1\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, -0x30(%rbp)
movq %rdx, %r13
movq (%rsi), %r14
movq %rsi, -0x40(%rbp)
movq 0x8(%rsi), %r15
cmpq %r15, %r14
je 0x6a2a
leaq 0x2777(%rip), %r12      # 0x917d
movl (%r14), %esi
movq %rbx, %rdi
callq 0x2370
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2250
addq $0x4, %r14
cmpq %r15, %r14
jne 0x6a06
leaq 0x27c2(%rip), %rsi      # 0x91f3
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2250
movq -0x30(%rbp), %rax
testl %eax, %eax
js 0x6b45
leal 0x1(%rax), %r15d
xorl %r12d, %r12d
movq %r13, -0x38(%rbp)
movq (%r13), %rax
movl (%rax,%r12,4), %r14d
testl %r14d, %r14d
jns 0x6ab8
movl %r14d, %eax
negl %eax
movq -0x40(%rbp), %rcx
movq (%rcx), %rcx
movl (%rcx,%rax,4), %esi
movq %rbx, %rdi
callq 0x2370
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
leaq 0x2754(%rip), %rsi      # 0x91df
callq 0x2250
movl $0x1, %esi
subl %r14d, %esi
movq %r13, %rdi
movq -0x38(%rbp), %r13
callq 0x2370
movl $0x1, %edx
movq %rax, %rdi
leaq 0x26ca(%rip), %rsi      # 0x917d
callq 0x2250
incq %r12
cmpq %r12, %r15
jne 0x6a55
leaq 0x272c(%rip), %rsi      # 0x91f3
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2250
cmpl $0x0, -0x30(%rbp)
js 0x6b59
xorl %r14d, %r14d
movq (%r13), %rax
movslq (%rax,%r14,4), %rax
testq %rax, %rax
js 0x6b3b
movq -0x40(%rbp), %rcx
movq (%rcx), %rcx
movl (%rcx,%rax,4), %esi
movl 0x4(%rcx,%rax,4), %r12d
movq %rbx, %rdi
callq 0x2370
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
leaq 0x26cc(%rip), %rsi      # 0x91df
callq 0x2250
movq %r13, %rdi
movq -0x38(%rbp), %r13
movl %r12d, %esi
callq 0x2370
movl $0x1, %edx
movq %rax, %rdi
leaq 0x2647(%rip), %rsi      # 0x917d
callq 0x2250
incq %r14
cmpq %r14, %r15
jne 0x6add
jmp 0x6b59
leaq 0x26a7(%rip), %rsi      # 0x91f3
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2250
leaq 0x2693(%rip), %rsi      # 0x91f3
movl $0x3, %edx
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2250
nop