LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x70(%rbp)
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movq %rdi, -0x68(%rbp)
movl (%rdi), %eax
xorl %edx, %edx
pushq $-0x1
popq %rcx
movl %ecx, -0x2c(%rbp)
leal -0x1(%rax), %ecx
cmpl %ecx, %edx
jge 0x3f69
movl %edx, -0x30(%rbp)
xorl %ebx, %ebx
cmpl %eax, %ebx
jge 0x3f5c
movl %ebx, %r14d
notl %r14d
pushq $0x1
popq %rcx
movl %ecx, %r13d
pushq $-0x1
popq %r12
leal -0x1(%r13), %ecx
cmpl %eax, %ecx
jge 0x3f55
movl %eax, %ecx
imull -0x30(%rbp), %ecx
movl %r14d, %edx
subl %ecx, %edx
movl %edx, -0x3c(%rbp)
movl -0x2c(%rbp), %ecx
imull %eax, %ecx
addl %r12d, %ecx
movl %ecx, -0x38(%rbp)
leal (%rbx,%rax), %ecx
imull %eax, %ecx
addl %r13d, %ecx
movl %ecx, -0x34(%rbp)
movq -0x60(%rbp), %rax
cmpq %rax, -0x58(%rbp)
je 0x3f17
movq %rax, -0x58(%rbp)
movq %r15, %rdi
leaq -0x3c(%rbp), %rsi
callq 0x5e82
movq %r15, %rdi
leaq -0x38(%rbp), %rsi
callq 0x5e82
movq %r15, %rdi
leaq -0x34(%rbp), %rsi
callq 0x5e82
movq -0x70(%rbp), %rdi
movq %r15, %rsi
callq 0x5e46
movq -0x68(%rbp), %rax
movl (%rax), %eax
decl %r12d
incl %r13d
jmp 0x3edb
incl %ebx
jmp 0x3ec3
movl -0x30(%rbp), %edx
incl %edx
decl -0x2c(%rbp)
jmp 0x3eb3
leaq -0x60(%rbp), %rdi
callq 0x2e04
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2e04
movq %rbx, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x50(%rbp), %r12
andq $0x0, 0x10(%r12)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
xorl %r13d, %r13d
movl (%r15), %eax
cmpl %eax, %r13d
jge 0x400a
cmpl %ebx, %r13d
je 0x4005
leal (%rax,%rbx), %ecx
imull %eax, %ecx
leal (%rcx,%r13), %eax
incl %eax
movl %eax, -0x2c(%rbp)
movq -0x50(%rbp), %rax
cmpq %rax, -0x48(%rbp)
je 0x3fee
movq %rax, -0x48(%rbp)
movq %r12, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x5e82
movq %r14, %rdi
movq %r12, %rsi
callq 0x5e46
incl %r13d
jmp 0x3fc4
leaq -0x50(%rbp), %rdi
callq 0x2e04
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2e04
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movl %edx, %ebx
movq %rsi, -0x58(%rbp)
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r12
andq $0x0, 0x10(%r12)
movaps %xmm0, (%r12)
leal 0x1(%rbx), %r13d
xorl %r14d, %r14d
movl (%r15), %eax
cmpl %eax, %r14d
jge 0x40ae
cmpl %r14d, %ebx
je 0x40a9
leal (%r14,%rax), %ecx
imull %eax, %ecx
addl %r13d, %ecx
movl %ecx, -0x2c(%rbp)
movq -0x50(%rbp), %rax
cmpq %rax, -0x48(%rbp)
je 0x4091
movq %rax, -0x48(%rbp)
movq %r12, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x5e82
movq -0x58(%rbp), %rdi
movq %r12, %rsi
callq 0x5e46
incl %r14d
jmp 0x4069
leaq -0x50(%rbp), %rdi
callq 0x2e04
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2e04
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x10(%rdi)
movaps %xmm0, (%rdi)
incl %edx
leaq -0xc(%rbp), %rsi
movl %edx, (%rsi)
callq 0x5e82
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x5e46
leaq -0x30(%rbp), %rdi
callq 0x2e04
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2e04
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x30(%rbp), %rax
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movl (%rdi), %ecx
leal -0x1(%rcx), %esi
imull %ecx, %esi
leal (%rdx,%rsi), %ecx
incl %ecx
leaq -0xc(%rbp), %rsi
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0x5e82
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x5e46
leaq -0x30(%rbp), %rdi
callq 0x2e04
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2e04
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %r8, %r12
movq %rcx, %r13
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
andq $0x0, -0x50(%rbp)
leaq -0x40(%rbp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
callq 0x3642
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x36e8
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x37ca
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3876
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3970
leaq -0x40(%rbp), %rsi
movq %r13, %rdx
callq 0x3a7a
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3af2
leaq -0x40(%rbp), %rsi
movl %r15d, %edx
callq 0x40da
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x4132
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3c06
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3d4a
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3e80
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
movl %r15d, %edx
callq 0x3f96
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x4036
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x42c8
leaq -0x40(%rbp), %rdi
callq 0x2d36
leaq -0x60(%rbp), %rdi
callq 0x2e04
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2d36
leaq -0x60(%rbp), %rdi
callq 0x2e04
movq %rbx, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O2/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::write_sat(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
void Graph::write_sat(std::vector<std::vector<int> > &clauses){
    std::ofstream ofs(get_path(sat_input));

    ofs << "p cnf " << n_vertices*n_vertices*2 << " " << (int) clauses.size() << "\n";
    for(auto c : clauses){
        bool first = true;
        for(auto v : c){
            if(!first)  ofs << " ";
            ofs << v;
            first = false;
        }
        ofs << " 0\n";
    }

    ofs.close();

    std::cout << "sat formula written\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3e3b(%rip), %rsi      # 0x8124
leaq -0x80(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x20b0
leaq -0x50(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x4491
leaq -0x280(%rbp), %rdi
leaq -0x50(%rbp), %rsi
pushq $0x10
popq %rdx
callq 0x2390
leaq -0x50(%rbp), %rdi
callq 0x20e0
leaq -0x80(%rbp), %rdi
callq 0x20e0
leaq 0x3e03(%rip), %rsi      # 0x8132
leaq -0x280(%rbp), %rdi
callq 0x21d0
movl (%r14), %esi
imull %esi, %esi
addl %esi, %esi
movq %rax, %rdi
callq 0x2350
leaq 0x3e4b(%rip), %rsi      # 0x819d
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
movq 0x8(%rbx), %rax
subq (%rbx), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movl %eax, %esi
callq 0x2350
leaq 0x3dc1(%rip), %rsi      # 0x813b
movq %rax, %rdi
callq 0x21d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rbx
leaq -0x280(%rbp), %r12
leaq 0x3dfe(%rip), %r13      # 0x819d
cmpq -0x58(%rbp), %rsi
je 0x440a
movq %rbx, %rdi
movq %rsi, -0x60(%rbp)
callq 0x2f56
movq -0x50(%rbp), %rbx
movq -0x48(%rbp), %r14
movb $0x1, %al
cmpq %r14, %rbx
je 0x43e5
movl (%rbx), %r15d
testb $0x1, %al
jne 0x43d2
movq %r12, %rdi
movq %r13, %rsi
callq 0x21d0
movq %r12, %rdi
movl %r15d, %esi
callq 0x2350
addq $0x4, %rbx
xorl %eax, %eax
jmp 0x43bb
movq %r12, %rdi
leaq 0x3d4a(%rip), %rsi      # 0x8139
callq 0x21d0
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x2e04
movq -0x60(%rbp), %rsi
addq $0x18, %rsi
jmp 0x439f
leaq -0x280(%rbp), %rdi
callq 0x2290
movq 0x7bb3(%rip), %rdi      # 0xbfd0
leaq 0x3d19(%rip), %rsi      # 0x813d
callq 0x21d0
leaq -0x280(%rbp), %rdi
callq 0x22b0
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20e0
jmp 0x4458
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x20e0
jmp 0x4489
movq %rax, %rbx
jmp 0x4489
jmp 0x446c
jmp 0x4471
movq %rax, %rbx
jmp 0x447d
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2e04
leaq -0x280(%rbp), %rdi
callq 0x22b0
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x448, %rsp            # imm = 0x448
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3cc4(%rip), %rdi      # 0x8172
leaq -0x460(%rbp), %r15
movl $0x400, %edx            # imm = 0x400
movq %r15, %rsi
callq 0x21f0
movq %r15, %rdi
callq 0x20d0
leaq -0x58(%rbp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x20b0
leaq 0x3ca5(%rip), %rdx      # 0x8185
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x60fd
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movq %r14, %rdx
callq 0x6135
leaq -0x58(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2240
movq %r14, %rdi
callq 0x20e0
leaq -0x38(%rbp), %rdi
callq 0x20e0
movq %rbx, %rax
addq $0x448, %rsp            # imm = 0x448
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x20e0
jmp 0x453e
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x40(%rbp)
movq %r8, %r12
movl %ecx, -0x2c(%rbp)
movl %edx, %r13d
movl %esi, %ebx
movq %rdi, %r14
leaq 0x78(%rdi), %r15
movq %r15, %rdi
callq 0x5f8a
movq %r14, %rdi
movl %ebx, %esi
movl %r13d, %edx
movq %r12, %rcx
movq -0x40(%rbp), %r8
callq 0x4198
callq 0x48aa
movq %r14, %rdi
callq 0x454e
leaq 0x90(%r14), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x5f98
leaq -0x80(%rbp), %r13
leaq -0x60(%rbp), %rbx
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
je 0x4875
movq %r15, %rdi
movq %r12, %rsi
callq 0x5e46
cmpb $0x0, -0x2c(%rbp)
je 0x4875
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4bc6
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2270
movq %rbx, %rsi
leaq -0x34(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x4cc6
movq %rbx, %rdi
callq 0x20e0
movl -0x34(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0x4f70
callq 0x48aa
movq %r14, %rdi
callq 0x454e
movq %r12, %rdi
movq %rax, %rsi
callq 0x5f98
movq %r13, %rdi
callq 0x20e0
jmp 0x47f6
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20e0
jmp 0x4898
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O2/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::create_ban[abi:cxx11](std::vector<int, std::allocator<int>>&)
std::string Graph::create_ban(std::vector<int> &orig_path){
    int n_vertices = orig_path.size();
    std::string ban = "";
    for(int i = 1; i < n_vertices - 1; i++){
        int var = -encode(i, orig_path[i]);
        ban += std::to_string(var) + " ";
    }
    ban += "0\n";

    return ban;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, -0x38(%rbp)
movq 0x8(%rdx), %r15
subq (%rdx), %r15
leaq 0x3550(%rip), %rsi      # 0x813c
leaq -0x78(%rbp), %r12
movq %rdi, -0x30(%rbp)
movq %r12, %rdx
callq 0x20b0
shlq $0x1e, %r15
movabsq $-0x100000000, %rbx     # imm = 0xFFFFFFFF00000000
addq %r15, %rbx
sarq $0x20, %rbx
pushq $0x1
popq %r15
leaq -0x58(%rbp), %r13
cmpq %rbx, %r15
jge 0x4c6e
movq (%r14), %rax
movl (%rax,%r15,4), %esi
movq -0x38(%rbp), %rax
movl (%rax), %eax
imull %r15d, %eax
notl %esi
subl %eax, %esi
movq %r13, %rdi
callq 0x61b5
movq %r12, %rdi
movq %r13, %rsi
leaq 0x3555(%rip), %rdx      # 0x819d
callq 0x6063
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x23a0
movq %r12, %rdi
callq 0x20e0
movq %r13, %rdi
callq 0x20e0
incq %r15
jmp 0x4c19
leaq 0x34c5(%rip), %rsi      # 0x813a
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2380
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4cb1
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x20e0
jmp 0x4ca6
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x20e0
jmp 0x4cb4
movq %rax, %r14
movq -0x30(%rbp), %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O2/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::recopy(int, int)
void Graph::recopy(int n_vars, int n_clauses){
    std::ifstream ifile(get_path(sat_aux_input));
    std::ofstream ofile(get_path(sat_input));
    
    ofile << "p cnf " << n_vars << " " << n_clauses << "\n";

    std::string line;
    while(getline(ifile, line)){
        ofile << line << "\n";
    }

    ofile.close();
    ifile.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x470, %rsp            # imm = 0x470
movl %edx, %ebx
movl %esi, %r14d
leaq 0x3211(%rip), %rsi      # 0x819f
leaq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x20b0
leaq -0x288(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x4491
leaq -0x490(%rbp), %rdi
leaq -0x288(%rbp), %rsi
pushq $0x8
popq %rdx
callq 0x22e0
leaq -0x288(%rbp), %rdi
callq 0x20e0
leaq -0x88(%rbp), %rdi
callq 0x20e0
leaq 0x313e(%rip), %rsi      # 0x8124
leaq -0x68(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x20b0
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4491
leaq -0x288(%rbp), %rdi
leaq -0x48(%rbp), %rsi
pushq $0x10
popq %rdx
callq 0x2390
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x68(%rbp), %rdi
callq 0x20e0
leaq 0x3106(%rip), %rsi      # 0x8132
leaq -0x288(%rbp), %rdi
callq 0x21d0
movq %rax, %rdi
movl %r14d, %esi
callq 0x2350
leaq 0x3153(%rip), %rsi      # 0x819d
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2350
leaq 0x30d8(%rip), %rsi      # 0x813b
movq %rax, %rdi
callq 0x21d0
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x490(%rbp), %rbx
leaq -0x48(%rbp), %r14
leaq -0x288(%rbp), %r15
leaq 0x30a7(%rip), %r12      # 0x813b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x50c5
movq %r15, %rdi
movq %r14, %rsi
callq 0x21a0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21d0
jmp 0x5094
leaq -0x288(%rbp), %rdi
callq 0x2290
leaq -0x490(%rbp), %rdi
callq 0x2050
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x288(%rbp), %rdi
callq 0x22b0
leaq -0x490(%rbp), %rdi
callq 0x2070
addq $0x470, %rsp            # imm = 0x470
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20e0
jmp 0x511f
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x20e0
jmp 0x5175
movq %rax, %rbx
jmp 0x5175
movq %rax, %rbx
leaq -0x288(%rbp), %rdi
callq 0x20e0
jmp 0x5143
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x20e0
jmp 0x5181
movq %rax, %rbx
jmp 0x5181
jmp 0x515d
movq %rax, %rbx
jmp 0x5169
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x288(%rbp), %rdi
callq 0x22b0
leaq -0x490(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
movl %esi, -0x2c(%rbp)
movq %rdi, %r12
movq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rax
subq %rcx, %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
leaq 0x8(%rcx), %rdx
movl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
pushq $-0x1
popq %rsi
xorl %edi, %edi
cmpq %rdi, %rax
je 0x51f2
movq (%rdx), %r8
subq -0x8(%rdx), %r8
sarq $0x2, %r8
movslq %esi, %rsi
cmpq %rsi, %r8
cmovbl %r8d, %esi
cmovbl %edi, %r13d
incq %rdi
addq $0x18, %rdx
jmp 0x51cb
leaq -0x50(%rbp), %rax
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movslq %r13d, %rax
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %r15
movq 0x8(%rcx,%rax), %rbx
leaq 0x78(%r12), %rax
movq %rax, -0x38(%rbp)
movzbl -0x2c(%rbp), %r14d
cmpq %rbx, %r15
je 0x5279
movl (%r15), %esi
movq %r12, %rdi
movl %r13d, %edx
movl %r14d, %ecx
movq -0x58(%rbp), %r8
movq -0x60(%rbp), %r9
callq 0x478c
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5ea8
movq -0x50(%rbp), %rsi
movq 0x78(%r12), %rdx
movq 0x80(%r12), %rcx
leaq -0x50(%rbp), %rdi
callq 0x615e
cmpb $0x0, -0x2c(%rbp)
jne 0x5273
movq -0x50(%rbp), %rax
cmpq -0x48(%rbp), %rax
jne 0x5279
addq $0x4, %r15
jmp 0x521f
leaq -0x50(%rbp), %rsi
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x5ea8
leaq -0x50(%rbp), %rdi
callq 0x2d36
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x52a8
jmp 0x52a8
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2d36
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x38(%rbp)
callq 0x5f8a
leaq 0x50(%rbx), %rdi
movslq (%rbx), %rsi
xorl %edx, %edx
callq 0x6f90
leaq 0x90(%rbx), %rdi
movslq (%rbx), %rsi
callq 0x617e
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
movl %r13d, %ecx
movl -0x2c(%rbp), %r8d
callq 0x3228
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rax
andq $0x0, 0x10(%rax)
movaps %xmm0, (%rax)
movq 0x78(%rbx), %r13
movq 0x80(%rbx), %r12
leaq -0x68(%rbp), %rbx
cmpq %r12, %r13
je 0x5377
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2f56
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3330
testb %al, %al
je 0x5369
leaq -0x50(%rbp), %rdi
movq %rbx, %rsi
callq 0x5e46
movq %rbx, %rdi
callq 0x2e04
addq $0x18, %r13
jmp 0x533b
leaq -0x50(%rbp), %rsi
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x5ea8
leaq -0x50(%rbp), %rdi
callq 0x2d36
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x53b2
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x2e04
jmp 0x53b5
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2d36
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/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 0x478c
leaq 0x78(%rbx), %rdi
movq %rax, %rsi
callq 0x5ea8
movq 0x78(%rbx), %rcx
movq 0x80(%rbx), %rax
subq %rcx, %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
movslq %r14d, %rdx
cmpq %rdx, %rax
jbe 0x5620
leaq 0x90(%rbx), %rcx
movq 0x90(%rbx), %rax
cmpq %rax, 0x98(%rbx)
je 0x5620
movq %rax, 0x98(%rbx)
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %ecx, -0x2c(%rbp)
movq %rdx, %r14
movq (%rsi), %r15
movq %rsi, -0x38(%rbp)
movq 0x8(%rsi), %r12
leaq 0x284b(%rip), %r13      # 0x813b
cmpq %r12, %r15
je 0x5911
movl (%r15), %esi
movq %rbx, %rdi
callq 0x2350
movq %rax, %rdi
movq %r13, %rsi
callq 0x21d0
addq $0x4, %r15
jmp 0x58f0
leaq 0x2899(%rip), %rsi      # 0x81b1
movq %rbx, %rdi
callq 0x21d0
movslq -0x2c(%rbp), %r13
xorl %r12d, %r12d
cmpq %r13, %r12
jg 0x5980
movq (%r14), %rax
movl (%rax,%r12,4), %r15d
testl %r15d, %r15d
jns 0x597b
movl %r15d, %eax
negl %eax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movl (%rcx,%rax,4), %esi
movq %rbx, %rdi
callq 0x2350
movq %rax, %rdi
leaq 0x2844(%rip), %rsi      # 0x819d
callq 0x21d0
pushq $0x1
popq %rsi
subl %r15d, %esi
movq %rax, %rdi
callq 0x2350
movq %rax, %rdi
leaq 0x27c5(%rip), %rsi      # 0x813b
callq 0x21d0
incq %r12
jmp 0x5927
leaq 0x282a(%rip), %rsi      # 0x81b1
movq %rbx, %rdi
callq 0x21d0
xorl %r15d, %r15d
cmpq %r13, %r15
jg 0x59e8
movq (%r14), %rax
movslq (%rax,%r15,4), %rax
testq %rax, %rax
js 0x59e3
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movl (%rcx,%rax,4), %esi
movl 0x4(%rcx,%rax,4), %r12d
movq %rbx, %rdi
callq 0x2350
movq %rax, %rdi
leaq 0x27d9(%rip), %rsi      # 0x819d
callq 0x21d0
movq %rax, %rdi
movl %r12d, %esi
callq 0x2350
movq %rax, %rdi
leaq 0x275d(%rip), %rsi      # 0x813b
callq 0x21d0
incq %r15
jmp 0x5992
leaq 0x27c2(%rip), %rsi      # 0x81b1
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::create_cons(int)
std::vector<int> Graph::create_cons(int n_vertices){
    std::vector<int> cons;
    // add diamonds 
    for(int i = 0; i < n_vertices - 1; i++)
        cons.push_back(i);

    // add map
    for(int i = 1; i < n_vertices - 1; i++)
        cons.push_back(-i);
    
    std::random_device rd;
    std::mt19937 g(rd());
 
    std::shuffle(cons.begin(), cons.end(), g);

    return cons;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2718, %rsp           # imm = 0x2718
movl %edx, %r14d
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
decl %r14d
xorl %eax, %eax
leaq -0x13b0(%rbp), %r15
movl %eax, -0x13b0(%rbp)
cmpl %r14d, %eax
jge 0x5a57
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5e82
movl -0x13b0(%rbp), %eax
incl %eax
jmp 0x5a37
pushq $0x1
popq %r12
pushq $-0x1
popq %r13
leaq -0x13b0(%rbp), %r15
cmpl %r14d, %r12d
jge 0x5a85
movl %r13d, -0x13b0(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3044
incl %r12d
decl %r13d
jmp 0x5a66
leaq -0x13b0(%rbp), %rdi
callq 0x6216
leaq -0x13b0(%rbp), %rdi
callq 0x2280
movl %eax, %esi
leaq -0x2738(%rbp), %rdi
callq 0x772c
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq -0x2738(%rbp), %rdx
callq 0x626c
leaq -0x13b0(%rbp), %rdi
callq 0x6396
movq %rbx, %rax
addq $0x2718, %rsp           # imm = 0x2718
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5af4
movq %rax, %r14
leaq -0x13b0(%rbp), %rdi
callq 0x6396
jmp 0x5af7
jmp 0x5af4
movq %rax, %r14
movq %rbx, %rdi
callq 0x2e04
movq %r14, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O2/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::add_cons(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, int)
void Graph::add_cons(std::vector<int>& orig_path, std::vector<int>& cons, int pos){
    std::ofstream ofile;
    ofile.open(get_path(sat_input), std::ofstream::app);

    int n_vertices = orig_path.size();
    for(int i = 0; i <= pos; i++){
        int con = cons[i];
        if(con >= 0){
            int u = orig_path[con];
            int v = orig_path[con+1];
            std::string diam = diam_s(u, v, n_vertices);
            ofile << diam;
        }
        else{
            con = -con;
            int var = encode(con, orig_path[con]);
            ofile << std::to_string(var) << " 0\n";
        }
    }

    ofile.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movl %ecx, %ebx
movq %rdx, -0x40(%rbp)
movq %rsi, %r14
movq %rdi, -0x38(%rbp)
leaq -0x280(%rbp), %rdi
callq 0x2330
leaq 0x25e8(%rip), %rsi      # 0x8124
leaq -0x80(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x20b0
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x4491
leaq -0x280(%rbp), %rdi
leaq -0x60(%rbp), %rsi
pushq $0x1
popq %rdx
callq 0x2100
leaq -0x60(%rbp), %r12
movq %r12, %rdi
callq 0x20e0
leaq -0x80(%rbp), %rdi
callq 0x20e0
movq 0x8(%r14), %r13
subq (%r14), %r13
shrq $0x2, %r13
movslq %ebx, %rbx
xorl %r15d, %r15d
cmpq %rbx, %r15
jg 0x5c1c
movq -0x40(%rbp), %rax
movq (%rax), %rax
movslq (%rax,%r15,4), %rax
testq %rax, %rax
js 0x5bd2
movq (%r14), %rcx
movl (%rcx,%rax,4), %edx
movl 0x4(%rcx,%rax,4), %ecx
movq %r12, %rdi
movq -0x38(%rbp), %rsi
movl %r13d, %r8d
callq 0x5c8a
leaq -0x280(%rbp), %rdi
movq %r12, %rsi
callq 0x21a0
jmp 0x5c0c
negl %eax
movq (%r14), %rcx
movl (%rcx,%rax,4), %ecx
movq -0x38(%rbp), %rdx
imull (%rdx), %eax
leal (%rcx,%rax), %esi
incl %esi
movq %r12, %rdi
callq 0x61b5
leaq -0x280(%rbp), %rdi
movq %r12, %rsi
callq 0x21a0
movq %rax, %rdi
leaq 0x2532(%rip), %rsi      # 0x8139
callq 0x21d0
movq %r12, %rdi
callq 0x20e0
incq %r15
jmp 0x5b8f
leaq -0x280(%rbp), %rdi
callq 0x2290
leaq -0x280(%rbp), %rdi
callq 0x22b0
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5c65
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20e0
jmp 0x5c59
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
jmp 0x5c71
jmp 0x5c65
jmp 0x5c65
jmp 0x5c6a
movq %rax, %rbx
jmp 0x5c76
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20e0
leaq -0x280(%rbp), %rdi
callq 0x22b0
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::diam_s[abi:cxx11](int, int, int)
std::string Graph::diam_s(int u, int v, int n_vertices){
    std::string s;
    for(int i = 0; i < n_vertices; i++){

        int u_id = -encode(i, u);
        s += std::to_string(u_id);
        if(i > 0){
            int v1_id = encode(i-1, v);
            s += " " + std::to_string(v1_id);
        }
        if(i < n_vertices-1){
            int v2_id = encode(i+1, v);
            s += " " + std::to_string(v2_id);                
        }
        s += " 0\n";
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
notl %edx
movl %edx, -0x34(%rbp)
incl %ecx
movl %ecx, -0x2c(%rbp)
leal -0x1(%r8), %eax
movl %eax, -0x30(%rbp)
xorl %r15d, %r15d
testl %r8d, %r8d
cmovlel %r15d, %r8d
movq %r8, -0x40(%rbp)
leaq -0x60(%rbp), %r12
leaq -0x80(%rbp), %r14
cmpl %r15d, -0x40(%rbp)
je 0x5dae
movl (%r13), %eax
imull %r15d, %eax
movl -0x34(%rbp), %esi
subl %eax, %esi
movq %r12, %rdi
callq 0x61b5
movq %rbx, %rdi
movq %r12, %rsi
callq 0x23a0
movq %r12, %rdi
callq 0x20e0
testl %r15d, %r15d
je 0x5d50
leal -0x1(%r15), %esi
imull (%r13), %esi
addl -0x2c(%rbp), %esi
movq %r14, %rdi
callq 0x61b5
movq %r12, %rdi
leaq 0x2470(%rip), %rsi      # 0x819d
movq %r14, %rdx
callq 0x63a9
movq %rbx, %rdi
movq %r12, %rsi
callq 0x23a0
movq %r12, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x20e0
cmpl -0x30(%rbp), %r15d
jge 0x5d97
leal 0x1(%r15), %esi
imull (%r13), %esi
addl -0x2c(%rbp), %esi
movq %r14, %rdi
callq 0x61b5
movq %r12, %rdi
leaq 0x2429(%rip), %rsi      # 0x819d
movq %r14, %rdx
callq 0x63a9
movq %rbx, %rdi
movq %r12, %rsi
callq 0x23a0
movq %r12, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x20e0
movq %rbx, %rdi
leaq 0x2398(%rip), %rsi      # 0x8139
callq 0x2380
incl %r15d
jmp 0x5cd8
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5dd6
jmp 0x5de1
jmp 0x5dc6
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x20e0
jmp 0x5dd9
jmp 0x5de1
movq %rax, %r14
leaq -0x80(%rbp), %rdi
jmp 0x5ded
jmp 0x5de1
movq %rax, %r14
jmp 0x5df2
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/./c_loops.hh
// Function: voro::c_loop_order::start()
inline bool start() {
			cp=vo.o;op=vo.op;
			if(cp!=op) {
				ijk=*(cp++);decode();
				q=*(cp++);
				return true;
			} else return false;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x48(%rdi), %rax
movq (%rax), %r14
movq %r14, 0x50(%rdi)
movq 0x8(%rax), %r15
movq %r15, 0x58(%rdi)
cmpq %r15, %r14
je 0x501a
movq %rdi, %rbx
leaq 0x4(%r14), %rax
movq %rax, 0x50(%rdi)
movl (%r14), %eax
movl %eax, 0x3c(%rdi)
callq 0x515e
movq 0x50(%rbx), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x50(%rbx)
movl (%rax), %eax
movl %eax, 0x40(%rbx)
cmpq %r15, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/./c_loops.hh
// Function: voro::c_loop_base::pos(int&, double&, double&, double&, double&)
inline void pos(int &pid,double &x,double &y,double &z,double &r) {
			pid=id[ijk][q];
			double *pp=p[ijk]+ps*q;
			x=*(pp++);y=*(pp++);z=*pp;
			r=ps==3?default_radius:*(++pp);
		}

// Assembly:
movq 0x20(%rdi), %rax
movslq 0x3c(%rdi), %r10
movq (%rax,%r10,8), %rax
movslq 0x40(%rdi), %r10
movl (%rax,%r10,4), %eax
movl %eax, (%rsi)
movq 0x18(%rdi), %rax
movslq 0x3c(%rdi), %rsi
movq (%rax,%rsi,8), %rax
movslq 0x14(%rdi), %r10
movslq 0x40(%rdi), %rsi
imulq %r10, %rsi
movsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rdx)
movsd 0x8(%rax,%rsi,8), %xmm0
movsd %xmm0, (%rcx)
movsd 0x10(%rax,%rsi,8), %xmm0
movsd %xmm0, (%r8)
cmpq $0x3, %r10
jne 0x50a8
movsd 0x29f8a(%rip), %xmm0    # 0x2f030
jmp 0x50ae
movsd 0x18(%rax,%rsi,8), %xmm0
movsd %xmm0, (%r9)
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/./c_loops.hh
// Function: voro::c_loop_order::inc()
inline bool inc() {
			if(cp==op) return false;
			ijk=*(cp++);decode();
			q=*(cp++);
			return true;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x50(%rdi), %r14
movq 0x58(%rdi), %r15
cmpq %r15, %r14
je 0x50ed
movq %rdi, %rbx
leaq 0x4(%r14), %rax
movq %rax, 0x50(%rdi)
movl (%r14), %eax
movl %eax, 0x3c(%rdi)
callq 0x515e
movq 0x50(%rbx), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x50(%rbx)
movl (%rax), %eax
movl %eax, 0x40(%rbx)
cmpq %r15, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/./c_loops.hh
// Function: voro::c_loop_order::decode()
inline void decode() {
			k=ijk/nxy;
			int ijkt=ijk-nxy*k;
			j=ijkt/nx;
			i=ijkt-j*nx;
		}

// Assembly:
movl 0x3c(%rdi), %eax
cltd
idivl 0x64(%rdi)
movl %eax, 0x38(%rdi)
movl %edx, %eax
cltd
idivl 0x60(%rdi)
movl %eax, 0x34(%rdi)
movl %edx, 0x30(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/./c_loops.hh
// Function: voro::c_loop_all::inc()
inline bool inc() {
			q++;
			if(q>=co[ijk]) {
				q=0;
				do {
					if(!next_block()) return false;
				} while(co[ijk]==0);
			}
			return true;
		}

// Assembly:
pushq %rbx
movl 0x40(%rdi), %ecx
incl %ecx
movl %ecx, 0x40(%rdi)
movq 0x28(%rdi), %rdx
movslq 0x3c(%rdi), %rsi
movb $0x1, %al
cmpl (%rdx,%rsi,4), %ecx
jl 0x521f
movq %rdi, %rbx
andl $0x0, 0x40(%rdi)
movq %rbx, %rdi
callq 0x5248
testb %al, %al
je 0x521f
movq 0x28(%rbx), %rcx
movslq 0x3c(%rbx), %rdx
cmpl $0x0, (%rcx,%rdx,4)
je 0x5205
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/./c_loops.hh
// Function: voro::c_loop_all::next_block()
inline bool next_block() {
			ijk++;
			i++;
			if(i==nx) {
				i=0;j++;
				if(j==ny) {
					j=0;k++;
					if(ijk==nxyz) return false;
				}
			}
			return true;
		}

// Assembly:
movl 0x30(%rdi), %ecx
movl 0x3c(%rdi), %eax
incl %eax
movl %eax, 0x3c(%rdi)
incl %ecx
movl %ecx, 0x30(%rdi)
cmpl (%rdi), %ecx
jne 0x527c
andl $0x0, 0x30(%rdi)
movl 0x34(%rdi), %ecx
incl %ecx
movl %ecx, 0x34(%rdi)
cmpl 0x4(%rdi), %ecx
jne 0x527c
andl $0x0, 0x34(%rdi)
incl 0x38(%rdi)
cmpl 0x10(%rdi), %eax
jne 0x527c
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::add_memory_xse()
void voronoicell_base::add_memory_xse() {
	current_xsearch_size<<=1;
	if(current_xsearch_size>max_xsearch_size) voro_fatal_error("Extra search stack memory allocation exceeded absolute maximum",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=2
	fprintf(stderr,"Extra search stack memory scaled up to %d\n",current_xsearch_size);
#endif
	int *dsn=new int[current_xsearch_size],*dsnp=dsn,*dsp=xse;
	while(dsp<stackp3) *(dsnp++)=*(dsp++);
	delete [] xse;xse=dsn;stackp3=dsnp;
	stacke3=xse+current_xsearch_size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %edx
addl %edx, %edx
movl %edx, 0x18(%rdi)
cmpl $0x1000001, %edx        # imm = 0x1000001
jl 0x53a9
leaq 0x2b8bd(%rip), %rdi     # 0x30c5b
pushq $0x2
popq %rsi
callq 0xfdaf
movl 0x18(%rbx), %edx
movq 0x39c30(%rip), %rax     # 0x3efe0
movq (%rax), %rdi
leaq 0x2b8e0(%rip), %rsi     # 0x30c9a
xorl %eax, %eax
callq 0x21a0
movslq 0x18(%rbx), %r15
leaq (,%r15,4), %rax
testq %r15, %r15
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %r14
movq 0xa8(%rbx), %rdi
movq 0xb0(%rbx), %rax
movq %r14, %r12
movq %rdi, %rcx
cmpq %rax, %rcx
jae 0x5408
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, (%r12)
addq $0x4, %r12
jmp 0x53f3
testq %rdi, %rdi
je 0x5416
callq 0x2170
movslq 0x18(%rbx), %r15
movq %r14, 0xa8(%rbx)
movq %r12, 0xb0(%rbx)
leaq (%r14,%r15,4), %rax
movq %rax, 0xb8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::add_memory_ds()
void voronoicell_base::add_memory_ds() {
	current_delete_size<<=1;
	if(current_delete_size>max_delete_size) voro_fatal_error("Delete stack 1 memory allocation exceeded absolute maximum",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=2
	fprintf(stderr,"Delete stack 1 memory scaled up to %d\n",current_delete_size);
#endif
	int *dsn=new int[current_delete_size],*dsnp=dsn,*dsp=ds;
	while(dsp<stackp) *(dsnp++)=*(dsp++);
	delete [] ds;ds=dsn;stackp=dsnp;
	stacke=ds+current_delete_size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %edx
addl %edx, %edx
movl %edx, 0x10(%rdi)
cmpl $0x1000001, %edx        # imm = 0x1000001
jl 0x5469
leaq 0x2b739(%rip), %rdi     # 0x30b97
pushq $0x2
popq %rsi
callq 0xfdaf
movl 0x10(%rbx), %edx
movq 0x39b70(%rip), %rax     # 0x3efe0
movq (%rax), %rdi
leaq 0x2b758(%rip), %rsi     # 0x30bd2
xorl %eax, %eax
callq 0x21a0
movslq 0x10(%rbx), %r15
leaq (,%r15,4), %rax
testq %r15, %r15
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %r14
movq 0x78(%rbx), %rdi
movq 0x80(%rbx), %rax
movq %r14, %r12
movq %rdi, %rcx
cmpq %rax, %rcx
jae 0x54c5
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, (%r12)
addq $0x4, %r12
jmp 0x54b0
testq %rdi, %rdi
je 0x54d3
callq 0x2170
movslq 0x10(%rbx), %r15
movq %r14, 0x78(%rbx)
movq %r12, 0x80(%rbx)
leaq (%r14,%r15,4), %rax
movq %rax, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::~voronoicell_base()
voronoicell_base::~voronoicell_base() {
	for(int i=current_vertex_order-1;i>=0;i--) if(mem[i]>0) delete [] mep[i];
	delete [] xse;
	delete [] ds2;delete [] ds;
	delete [] mep;delete [] mec;
	delete [] mem;delete [] pts;
	delete [] mask;
	delete [] nu;delete [] ed;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x394c6(%rip), %rax     # 0x3ec18
movq %rax, (%rdi)
movl 0xc(%rdi), %r14d
testl %r14d, %r14d
jle 0x5782
movq 0x60(%rbx), %rax
cmpl $0x0, -0x4(%rax,%r14,4)
jle 0x577d
movq 0x70(%rbx), %rax
movq -0x8(%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x577d
callq 0x2170
decq %r14
jmp 0x5759
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x5793
callq 0x2170
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x57a4
callq 0x2170
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x57b2
callq 0x2170
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x57c0
callq 0x2170
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x57ce
callq 0x2170
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x57dc
callq 0x2170
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x57ea
callq 0x2170
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x57f8
callq 0x2170
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x5806
callq 0x2170
movq 0x28(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x581b
popq %rbx
popq %r14
jmp 0x2170
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::copy(voro::voronoicell_base*)
void voronoicell_base::copy(voronoicell_base* vb) {
	int i,j;
	p=vb->p;up=0;
	for(i=0;i<current_vertex_order;i++) {
		mec[i]=vb->mec[i];
		for(j=0;j<mec[i]*(2*i+1);j++) mep[i][j]=vb->mep[i][j];
		for(j=0;j<mec[i]*(2*i+1);j+=2*i+1) ed[mep[i][j+2*i]]=mep[i]+j;
	}
	for(i=0;i<p;i++) nu[i]=vb->nu[i];
	for(i=0;i<(p<<2);i++) pts[i]=vb->pts[i];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl 0x1c(%rsi), %eax
movl %eax, 0x1c(%rdi)
andl $0x0, 0x20(%rdi)
movabsq $0x4, %rax
movl $0x1, %ecx
xorl %edx, %edx
xorl %r8d, %r8d
movslq 0xc(%rdi), %r9
cmpq %r9, %r8
jge 0x58e4
movq 0x68(%rsi), %r9
movl (%r9,%r8,4), %r10d
movq 0x68(%rdi), %r11
movl %r10d, (%r11,%r8,4)
movq 0x70(%rdi), %rbx
leal 0x1(,%r8,2), %r9d
xorl %r14d, %r14d
movl %r10d, %ebp
imull %r9d, %ebp
movslq %ebp, %r15
cmpq %r15, %r14
jge 0x589c
movq 0x70(%rsi), %r10
movq (%r10,%r8,8), %r10
movl (%r10,%r14,4), %r10d
movq (%rbx,%r8,8), %r15
movl %r10d, (%r15,%r14,4)
incq %r14
movl (%r11,%r8,4), %r10d
jmp 0x5870
xorl %r11d, %r11d
xorl %ebx, %ebx
imull %r9d, %r10d
cmpl %r11d, %r10d
jle 0x58d1
movq 0x28(%rdi), %r10
movq 0x70(%rdi), %r14
movq (%r14,%r8,8), %r14
addq %rbx, %r14
movslq (%rdx,%r14), %r15
movq %r14, (%r10,%r15,8)
movq 0x68(%rdi), %r10
movl (%r10,%r8,4), %r10d
addq %rax, %rbx
addl %ecx, %r11d
jmp 0x58a1
incq %r8
addq $0x8, %rdx
addq $0x8, %rax
addl $0x2, %ecx
jmp 0x5844
movq 0x30(%rdi), %rcx
xorl %edx, %edx
movslq 0x1c(%rdi), %rax
cmpq %rax, %rdx
jge 0x5902
movq 0x30(%rsi), %rax
movl (%rax,%rdx,4), %eax
movl %eax, (%rcx,%rdx,4)
incq %rdx
jmp 0x58ea
shll $0x2, %eax
movq 0x40(%rdi), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x5928
movq 0x40(%rsi), %rdi
movsd (%rdi,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
jmp 0x5910
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_neighbor::operator=(voro::voronoicell&)
void voronoicell_neighbor::operator=(voronoicell &c) {
	voronoicell_base *vb=((voronoicell_base*) &c);
	check_memory_for_copy(*this,vb);copy(vb);
	int i,j;
	for(i=0;i<c.current_vertex_order;i++) {
		for(j=0;j<c.mec[i]*i;j++) mne[i][j]=0;
		for(j=0;j<c.mec[i];j++) ne[c.mep[i][(2*i+1)*j+2*i]]=mne[i]+(j*i);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %rsi
movq %rbx, %rdx
callq 0xd93a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5820
pushq $0x4
popq %rax
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movslq 0xc(%rbx), %rdi
cmpq %rdi, %rsi
jge 0x59f3
movq 0x68(%rbx), %rdi
movq 0xe8(%r14), %r8
xorl %r9d, %r9d
movl (%rdi,%rsi,4), %r10d
movl %r10d, %r11d
imull %esi, %r11d
movslq %r11d, %r11
cmpq %r11, %r9
jge 0x5996
movq (%r8,%rsi,8), %r10
andl $0x0, (%r10,%r9,4)
incq %r9
jmp 0x5975
movq %rcx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
movslq %r10d, %r10
cmpq %r10, %r9
jge 0x59df
movq 0xe8(%r14), %r10
movq 0xf0(%r14), %r11
movq (%r10,%rsi,8), %r10
addq %r8, %r10
movq 0x70(%rbx), %r15
movq (%r15,%rsi,8), %r15
movslq (%r15,%rdi), %r15
movq %r10, (%r11,%r15,8)
incq %r9
movq 0x68(%rbx), %r10
movl (%r10,%rsi,4), %r10d
addq %rdx, %r8
addq %rax, %rdi
jmp 0x599f
incq %rsi
addq $0x4, %rdx
addq $0x8, %rcx
addq $0x8, %rax
jmp 0x595a
popq %rbx
popq %r14
popq %r15
retq
nop