LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms2/./assignment3.hpp
// Function: assignment3::read_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, int&)
void read_file(const std::string& fileName, std::vector<int>& values, std::vector<int>& weights, int& W)
    {
        PROFILE("Read file for " + fileName);
        std::ifstream file(fileName, std::ios::in);
        if (file.is_open())
        {
            int n;
            file >> W >> n; // knapsack size, number of items

            int v, w;
            while (file >> v >> w)
            {
                values.push_back(v);
                weights.push_back(w);
            }
            file.close();
        }
        PROFILE_STOP();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x88f8
movq %rax, %r13
leaq 0x9a7f(%rip), %rsi      # 0xe58d
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rdx
callq 0x8ccc
movq %r13, %rdi
movq %rbp, %rsi
callq 0x8942
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4b3c
callq 0x21f0
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movl $0x8, %edx
callq 0x22f0
leaq 0x88(%rsp), %rdi
callq 0x20b0
testb %al, %al
je 0x4c06
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x2160
leaq 0xc(%rsp), %rsi
movq %rax, %rdi
callq 0x2160
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x4(%rsp), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x2160
movq %rax, %rdi
movq %r13, %rsi
callq 0x2160
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4bfc
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x4bca
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x4bd5
movq %r14, %rdi
movq %r12, %rdx
callq 0xb90c
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4bef
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4b8c
movq %rbx, %rdi
movq %r13, %rdx
callq 0xb90c
jmp 0x4b8c
leaq 0x10(%rsp), %rdi
callq 0x2090
callq 0x88f8
movq %rax, %rdi
callq 0x898c
leaq 0x10(%rsp), %rdi
callq 0x20c0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c4d
jmp 0x4c4d
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c5a
callq 0x21f0
jmp 0x4c5a
jmp 0x4c4d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms2/./assignment3.hpp
// Function: assignment3::knapsack_1::testCase1()
bool testCase1()
        {
            std::vector<int> test_v = { 3,2,4,4 };
            std::vector<int> test_wt = { 4,3,2,3 };
            int test_W = 6;
            int optimal_value = knapsack(test_v, test_wt, test_W);

            assert(optimal_value == 8);
            return true;
        }

// Assembly:
pushq %rbx
subq $0x50, %rsp
movaps 0x9303(%rip), %xmm0     # 0xe0d0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rbx
movl $0x4, %edx
movq %rbx, %rcx
callq 0x87ac
movaps 0x92ed(%rip), %xmm0     # 0xe0e0
movaps %xmm0, (%rbx)
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x4, %edx
callq 0x87ac
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x6, %edx
callq 0x4c62
cmpl $0x8, %eax
jne 0x4e4e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4e37
callq 0x21f0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4e46
callq 0x21f0
movb $0x1, %al
addq $0x50, %rsp
popq %rbx
retq
leaq 0x97d8(%rip), %rdi      # 0xe62d
leaq 0x9760(%rip), %rsi      # 0xe5bc
leaq 0x97dd(%rip), %rcx      # 0xe640
movl $0x6d, %edx
callq 0x2170
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4e84
callq 0x21f0
jmp 0x4e84
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4e93
callq 0x21f0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms2/./assignment3.hpp
// Function: assignment3::knapsack_big::knapsack_rec_memoization(int, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, int)
int knapsack_rec_memoization(int n, std::vector<int>& values, std::vector<int>& weights, const int W)
        {
            if (saved.count(W) > 0)
            {
                for (auto el : saved[W])
                {
                    if (std::get<0>(el) == n)   // if we have item's value for the given W and item number, let's return it
                        return std::get<1>(el);
                }
            }
            int withLastItem = -1;
            int withoutLastItem = -1;
            if (n <= 0)
                return 0;
           
            if (W < weights[n-1]) // last item
                withLastItem = -1;
            else
            {
                withLastItem = values[n - 1] + knapsack_rec_memoization(n - 1, values, weights, W - weights[n - 1]);
            }
            withoutLastItem = knapsack_rec_memoization(n - 1, values, weights, W);
            saved[W].push_back(std::make_tuple(n, std::max(withLastItem, withoutLastItem)));
            return std::max(withLastItem, withoutLastItem);
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebx
leaq 0xc(%rsp), %rsi
movl %ecx, (%rsi)
leaq 0x101ed(%rip), %rdi     # 0x151f8
callq 0xc1b0
testq %rax, %rax
je 0x504a
leaq 0x101dc(%rip), %rdi     # 0x151f8
leaq 0xc(%rsp), %rsi
callq 0xc20c
movq (%rax), %rcx
movq 0x8(%rax), %rax
cmpq %rax, %rcx
je 0x504a
movq (%rcx), %r12
movq %r12, %rdx
shrq $0x20, %rdx
cmpl %ebx, %edx
je 0x50c7
addq $0x8, %rcx
jmp 0x502d
testl %ebx, %ebx
jle 0x50c4
movl 0xc(%rsp), %ecx
leal -0x1(%rbx), %r12d
movq (%r14), %rdx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ecx, %eax
subl (%rdx,%r12,4), %eax
jl 0x5086
movq (%r15), %rcx
movl (%rcx,%r12,4), %r13d
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movl %eax, %ecx
callq 0x4fe7
movl %eax, %ebp
addl %r13d, %ebp
movl 0xc(%rsp), %ecx
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4fe7
movl %eax, %r12d
leaq 0x1015a(%rip), %rdi     # 0x151f8
leaq 0xc(%rsp), %rsi
callq 0xc20c
cmpl %r12d, %ebp
cmovgl %ebp, %r12d
leaq 0x10(%rsp), %rsi
movl %r12d, (%rsi)
movl %ebx, 0x4(%rsi)
movq %rax, %rdi
callq 0xc4d8
jmp 0x50c7
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms2/./assignment3.hpp
// Function: assignment3::knapsack_big::testCase1()
bool testCase1()
        {
            std::vector<int> test_v = { 3,2,4,4 };
            std::vector<int> test_wt = { 4,3,2,3 };
            int test_W = 6;
            int optimal_value = knapsack_smallArray(test_v, test_wt, test_W); //knapsack_rec_memoization(4, test_v, test_wt, test_W);

            assert(optimal_value == 8);
            return true;
        }

// Assembly:
pushq %rbx
subq $0x50, %rsp
movaps 0x8ec8(%rip), %xmm0     # 0xe0d0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rbx
movl $0x4, %edx
movq %rbx, %rcx
callq 0x87ac
movaps 0x8eb2(%rip), %xmm0     # 0xe0e0
movaps %xmm0, (%rbx)
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x4, %edx
callq 0x87ac
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x6, %edx
callq 0x50d9
cmpl $0x8, %eax
jne 0x5289
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5272
callq 0x21f0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5281
callq 0x21f0
movb $0x1, %al
addq $0x50, %rsp
popq %rbx
retq
leaq 0x939d(%rip), %rdi      # 0xe62d
leaq 0x9325(%rip), %rsi      # 0xe5bc
leaq 0x93ff(%rip), %rcx      # 0xe69d
movl $0xe7, %edx
callq 0x2170
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x52bf
callq 0x21f0
jmp 0x52bf
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x52ce
callq 0x21f0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms2/./assignment4.hpp
// Function: assignment4::load_graph(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int load_graph(const std::string& fileName)
    {
        if (!g.empty())
            g.clear();

        std::fstream file(fileName, std::ios::in);
        int n, m;
        
        if (file.is_open())
        {
            file >> n >> m;
            int source, dest, cost;
            while (file >> source >> dest >> cost)
            {
                g[source].push_back(std::make_pair(dest, cost));
            }
            file.close();
        }
        return n;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
cmpq $0x0, 0xf9f0(%rip)      # 0x15248
je 0x5866
leaq 0xf9cf(%rip), %rdi      # 0x15230
callq 0xa6c8
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x2330
leaq 0xa8(%rsp), %rdi
callq 0x20b0
testb %al, %al
je 0x5946
leaq 0x28(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x2160
leaq 0x24(%rsp), %rsi
movq %rax, %rdi
callq 0x2160
leaq 0x28(%rsp), %rbx
leaq 0x20(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
leaq 0xf96c(%rip), %r13      # 0x15230
leaq 0x18(%rsp), %rbp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2160
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
movq %rax, %rdi
movq %r12, %rsi
callq 0x2160
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5938
movq %r13, %rdi
movq %r14, %rsi
callq 0xc7a2
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
shlq $0x20, %rcx
orq %rdx, %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x592b
movq %rcx, (%rsi)
addq $0x8, 0x8(%rax)
jmp 0x58c9
movq %rax, %rdi
movq %rbp, %rdx
callq 0xca6e
jmp 0x58c9
leaq 0x28(%rsp), %rdi
callq 0x2050
movl 0x14(%rsp), %ebx
leaq 0x28(%rsp), %rdi
callq 0x20a0
movl %ebx, %eax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x596a
jmp 0x596a
jmp 0x596a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms2/./assignment4.hpp
// Function: assignment4::ijConnected(int, int, std::unordered_map<int, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>> const&, int&)
bool ijConnected(int i, int j, const Graph& graph, int& cst)
    {
        std::vector<std::pair<int, int>> neighbors = graph.at(i);
        for (const auto& n : neighbors)
        {
            if (n.first == j)
            {
                cst = n.second;
                return true;
            }
        }
        cst = 0;   // assuming no loops are permitted, we return 0 if they are not connected!
        return false;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movl %esi, %ebp
leaq 0x4(%rsp), %rsi
movl %edi, (%rsi)
movq %rdx, %rdi
callq 0xcbac
testq %rax, %rax
je 0x59f3
addq $0x10, %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x8f8a
movq (%r14), %rdi
movq 0x8(%r14), %rax
cmpq %rax, %rdi
je 0x59d0
movq %rdi, %rcx
cmpl %ebp, (%rcx)
je 0x59d6
addq $0x8, %rcx
cmpq %rax, %rcx
jne 0x59c3
xorl %ebp, %ebp
xorl %eax, %eax
jmp 0x59dc
movl 0x4(%rcx), %eax
movb $0x1, %bpl
movl %eax, (%rbx)
testq %rdi, %rdi
je 0x59e8
callq 0x21f0
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x9528(%rip), %rdi      # 0xef22
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms2/./assignment4.hpp
// Function: assignment4::run_algorithm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void run_algorithm(const std::string& fileName)
    {
        int n = load_graph(fileName);
        int shortest_shortest_path = INT32_MAX;
        if (floyd_warshall(assignment4::g, n, shortest_shortest_path))
        {
            std::cout << "Shortest of all shortest paths is: " << shortest_shortest_path << std::endl;
            assert(shortest_shortest_path == -19);
        }
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x583c
leaq 0x4(%rsp), %rdx
movl $0x7fffffff, (%rdx)     # imm = 0x7FFFFFFF
leaq 0xf460(%rip), %rdi      # 0x15230
movl %eax, %esi
callq 0x59ff
testb %al, %al
je 0x5e33
movq 0xf1f6(%rip), %rbx      # 0x14fd8
leaq 0x8a88(%rip), %rsi      # 0xe871
movl $0x23, %edx
movq %rbx, %rdi
callq 0x2240
movl 0x4(%rsp), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2340
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2190
cmpl $-0x13, %ebp
jne 0x5e3a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8a54(%rip), %rdi      # 0xe895
leaq 0x8a6b(%rip), %rsi      # 0xe8b3
leaq 0x8a76(%rip), %rcx      # 0xe8c5
movl $0xa2, %edx
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms2/./assignment6.hpp
// Function: assignment6::DFSFillStack(std::unordered_map<int, std::vector<int, std::allocator<int>>, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, std::vector<int, std::allocator<int>>>>>&, int)
void DFSFillStack(Graph& g, int u)
    {
        _explored[u] = true;           // mark  as seen

        // for every edge (s, v)
        for (int v : g[u])
        {
            if (!_explored[v])   // if v is not yet explored
            {
                DFSFillStack(g, v);
            }
        }
        _S.push(u);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movl %esi, (%r14)
leaq 0xf11a(%rip), %rdi      # 0x152b8
movq %r14, %rsi
callq 0xbda0
movb $0x1, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd4fe
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x61f9
leaq 0xf0f1(%rip), %r14      # 0x152b8
leaq 0x8(%rsp), %r15
movl (%r12), %eax
movl %eax, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xbda0
cmpb $0x0, (%rax)
jne 0x61f0
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x617f
addq $0x4, %r12
cmpq %r13, %r12
jne 0x61cc
movq 0xf098(%rip), %rax      # 0x15298
movq 0xf0a1(%rip), %rcx      # 0x152a8
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x6223
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0xf077(%rip)      # 0x15298
jmp 0x6234
leaq 0xf03e(%rip), %rdi      # 0x15268
leaq 0xc(%rsp), %rsi
callq 0xd6a8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms2/./assignment6.hpp
// Function: assignment6::DFSSCC(std::unordered_map<int, std::vector<int, std::allocator<int>>, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, std::vector<int, std::allocator<int>>>>>&, int, std::vector<int, std::allocator<int>>&)
void DFSSCC(Graph& g, int u, std::vector<int>& scc)
    {
        _explored[u] = true;           // mark  as seen

        // for every edge (u, v)
        for (int v : g[u])
        {
            if (!_explored[v])   // if v is not yet explored
            {
                DFSSCC(g, v, scc);
            }
        }
        scc.push_back(u);   // add node to scc
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x4(%rsp), %r15
movl %esi, (%r15)
leaq 0xf056(%rip), %rdi      # 0x152b8
movq %r15, %rsi
callq 0xbda0
movb $0x1, (%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0xd4fe
movq (%rax), %r13
movq 0x8(%rax), %rbp
cmpq %rbp, %r13
je 0x62bc
leaq 0xf02d(%rip), %r15      # 0x152b8
movq %rsp, %r12
movl (%r13), %eax
movl %eax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xbda0
cmpb $0x0, (%rax)
jne 0x62b3
movl (%rsp), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6242
addq $0x4, %r13
cmpq %rbp, %r13
jne 0x628e
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x62d6
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x62e3
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0xb90c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms2/./lib/profile.hpp
// Function: tools::Profile::stop()
void stop()
        {
            _end = std::chrono::steady_clock::now();
            _duration = std::chrono::duration_cast<std::chrono::milliseconds>(_end - _startTimes.top()).count();
            _startTimes.pop();

            std::cout << "[PROFILE] " << _profileNames.top() << " took " << _duration << "ms" << " to run." << std::endl;
            _profileNames.pop();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2280
movq %rax, 0x8(%rbx)
leaq 0x68(%rbx), %rdi
movq 0x98(%rbx), %rcx
cmpq 0xa0(%rbx), %rcx
jne 0x89c1
movq 0xb0(%rbx), %rdx
movl $0x200, %ecx            # imm = 0x200
addq -0x8(%rdx), %rcx
movq -0x8(%rcx), %rcx
subq %rcx, %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
movq %rdx, 0x10(%rbx)
callq 0xa4f4
movq 0xc5e5(%rip), %rdi      # 0x14fd8
leaq 0x63b8(%rip), %rsi      # 0xedb2
movl $0xa, %edx
callq 0x2240
movq 0x48(%rbx), %rax
cmpq 0x50(%rbx), %rax
jne 0x8a1b
movq 0x60(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
leaq 0x18(%rbx), %r14
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
movq 0xc5aa(%rip), %rdi      # 0x14fd8
callq 0x2240
movq %rax, %r15
leaq 0x6380(%rip), %rsi      # 0xedbd
movl $0x6, %edx
movq %rax, %rdi
callq 0x2240
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x2100
movq %rax, %rbx
leaq 0x5d70(%rip), %rsi      # 0xe7d0
movl $0x2, %edx
movq %rax, %rdi
callq 0x2240
leaq 0x6350(%rip), %rsi      # 0xedc4
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2190
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xa53c
nop
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms2/./lib/UnionFind.hpp
// Function: DataStructures::UnionFind::UnionFind(int)
UnionFind(int n)
        {
           // _parent.resize(n);
           // _rank.resize(n);
            _parent = new int[n];
            _rank = new int[n];

            _count = n;

            for (int i = 0; i < n; i++)
            {
                _parent[i] = i;
                _rank[i] = 0;
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r15
movl %esi, %r13d
leaq (,%r13,4), %r14
testl %esi, %esi
movq $-0x1, %r12
cmovnsq %r14, %r12
movq %r12, %rdi
callq 0x2030
movq %rax, %rbx
movq %rax, (%r15)
movq %r12, %rdi
callq 0x2030
movq %rax, 0x8(%r15)
movl %ebp, 0x10(%r15)
testl %ebp, %ebp
jle 0x8ba1
xorl %r15d, %r15d
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2140
leal 0x1(%r13), %eax
andl $-0x2, %eax
decq %r13
movq %r13, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x5540(%rip), %xmm1     # 0xe070
movdqa 0x5548(%rip), %xmm2     # 0xe080
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x5548(%rip), %xmm4     # 0xe090
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %ecx
notl %ecx
testb $0x1, %cl
je 0x8b7d
movl %r15d, (%rbx,%r15,4)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %ecx
testb $0x1, %cl
je 0x8b94
leal 0x1(%r15), %ecx
movl %ecx, 0x4(%rbx,%r15,4)
addq $0x2, %r15
paddq %xmm4, %xmm1
cmpq %r15, %rax
jne 0x8b48
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms2/./lib/UnionFind.hpp
// Function: DataStructures::UnionFind::Union(int, int)
void Union(int x, int y)
        {
            int s1 = Find(x);
            int s2 = Find(y);

            // if both elements belong to the same component return
            if (s1 == s2)
                return;

            if (_rank[s1] > _rank[s2])
                _parent[s2] = s1;
            else if (_rank[s1] < _rank[s2])
                _parent[s1] = s2;
            else
            {
                _rank[s1]++;
                _parent[s2] = s1;
            }
            _count--;
        }

// Assembly:
movq (%rdi), %rax
movl %esi, %ecx
movslq %esi, %r8
movl (%rax,%r8,4), %esi
cmpl %r8d, %esi
jne 0x8bb3
movl %edx, %r9d
movslq %edx, %rsi
movl (%rax,%rsi,4), %edx
cmpl %esi, %edx
jne 0x8bc1
cmpl %r9d, %ecx
je 0x8bf6
movq 0x8(%rdi), %rdx
movl (%rdx,%r8,4), %r10d
cmpl (%rdx,%rsi,4), %r10d
jg 0x8bf0
jge 0x8be9
movl %r9d, (%rax,%r8,4)
jmp 0x8bf3
incl %r10d
movl %r10d, (%rdx,%r8,4)
movl %ecx, (%rax,%rsi,4)
decl 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms2/./assignment5.hpp
// Function: assignment5::TSP::TSP(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TSP(const std::string& fileName)
        {
            std::fstream file(fileName, std::ios::in);

            if (file.is_open())
            {
                file >> num_cities;
                float x, y;
                while (file >> x >> y)
                    city_coord.push_back(std::make_pair(x, y));
                file.close();
            }
            _distances.resize(num_cities);
            for (int i = 0; i < num_cities; i++)
                _distances[i].resize(num_cities);

            precalculate_distances();
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %r15
leaq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
leaq 0x18(%rsp), %rdi
movl $0x8, %edx
callq 0x2330
leaq 0x98(%rsp), %rdi
callq 0x20b0
testb %al, %al
je 0x92f9
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x2160
leaq 0x18(%rsp), %r12
leaq 0x4(%rsp), %r13
movq %rsp, %rbp
leaq 0x10(%rsp), %rbx
movq %r12, %rdi
movq %r13, %rsi
callq 0x2380
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2380
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x92ef
movss (%rsp), %xmm1
movss 0x4(%rsp), %xmm0
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movlps %xmm0, 0x10(%rsp)
movq 0x10(%r15), %rsi
cmpq 0x18(%r15), %rsi
je 0x92e0
movlps %xmm0, (%rsi)
addq $0x8, 0x10(%r15)
jmp 0x9295
movq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xa972
jmp 0x9295
leaq 0x18(%rsp), %rdi
callq 0x2050
movslq (%r15), %rsi
movq %r14, %rdi
callq 0xa818
movl (%r15), %eax
testl %eax, %eax
jle 0x932d
xorl %ebx, %ebx
xorl %r12d, %r12d
movq (%r14), %rdi
addq %rbx, %rdi
movslq %eax, %rsi
callq 0xa89a
incq %r12
movslq (%r15), %rax
addq $0x18, %rbx
cmpq %rax, %r12
jl 0x9310
movq %r15, %rdi
callq 0xa8cc
leaq 0x18(%rsp), %rdi
callq 0x20a0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x935e
movq %rax, %rbx
jmp 0x936b
jmp 0x935e
jmp 0x935e
jmp 0x935e
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x20a0
movq %r14, %rdi
callq 0xa92c
movq 0x8(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x9385
callq 0x21f0
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_loop_timeout_rtc.cpp
// Function: timeout_rtc_handler::check()
bool check() override
   {
      static constexpr std::size_t max_iters_per_check = 100000;

      if (++iterations_ >= max_iters_per_check)
      {
         if (std::chrono::steady_clock::now() >= timeout_tp_)
         {
            return false;
         }

         iterations_ = 0;
      }

      return true;
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rax
incq %rax
movq %rax, 0x18(%rdi)
movb $0x1, %bl
cmpq $0x186a0, %rax          # imm = 0x186A0
jb 0x118e4d
movq %rdi, %r14
callq 0x1144b0
cmpq 0x20(%r14), %rax
jge 0x118e4b
movq $0x0, 0x18(%r14)
jmp 0x118e4d
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/enum_helper.h
// Function: Boss::EnumHelper<MyNs::IFaces::IFixPrice>::Next()
RefObjPtr<T> Next()
    {
      RefObjQIPtr<T> Ret;
      for (IBasePtr i ; (i = NextInternal()).Get() ; )
      {
        if ((Ret = std::move(i)).Get())
          break;
      }
      return std::move(Ret);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x1a1ae
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1877c
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x187ac
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a24e
cmpq $0x0, (%rax)
je 0x18761
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x187ac
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x187d4
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq 0x10(%rsp), %rdi
movq %r14, (%rbx)
testq %rdi, %rdi
je 0x187db
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x187db
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1883b
jmp 0x1883b
movq %rax, %rbx
jmp 0x18821
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x18811
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x18811
jmp 0x1883b
jmp 0x1880e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x18821
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x18831
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xbb300
jmp 0x1883b
movq %rax, %rdi
callq 0x18c71
nop
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/enum.h
// Function: Boss::Enum::Next(Boss::IBase**)
virtual RetCode Next(IBase **item)
    {
      if (!item || *item)
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        if (CurPos == std::end(Items))
          return Status::False;
        return (CurPos++)->QueryInterface(item);
      }
      catch (std::exception const &)
      {
        return Status::Fail;
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x5, %ebp
testq %rsi, %rsi
je 0x18f08
movq %rsi, %r14
cmpq $0x0, (%rsi)
jne 0x18f08
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x145c0
testl %eax, %eax
jne 0x18f15
leaq 0x40(%r15), %rcx
movq 0x58(%r15), %rax
cmpq %rcx, %rax
je 0x18ef4
movq (%rax), %rcx
movq %rcx, 0x58(%r15)
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x18efb
movq (%rdi), %rax
movl $0x2cc77d66, %esi       # imm = 0x2CC77D66
movq %r14, %rdx
callq *0x20(%rax)
movl %eax, %ebp
jmp 0x18f00
movl $0x1, %ebp
jmp 0x18f00
movl $0x2, %ebp
movq %rbx, %rdi
callq 0x14620
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x16173
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x14620
jmp 0x18f32
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x18f4c
callq 0x1ad30
callq 0x1ada0
movl $0x2, %ebp
jmp 0x18f08
callq 0xbb300
nop
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/enum.h
// Function: Boss::Enum::Reset()
virtual RetCode Reset()
    {
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        CurPos = Items.begin();
      }
      catch (std::exception const &)
      {
        return Status::Fail;
      }
      return Status::Ok;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x145c0
testl %eax, %eax
jne 0x18f83
movq 0x40(%r14), %rax
movq %rax, 0x58(%r14)
movq %rbx, %rdi
callq 0x14620
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %eax, %edi
callq 0x16173
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x18fa3
callq 0x1ad30
callq 0x1ada0
movl $0x2, %eax
jmp 0x18f7b
callq 0xbb300
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/core/base.h
// Function: Boss::Base<MyNs::Impl::BestOffer>::QueryInterface(unsigned int, void**)
virtual RetCode BOSS_CALL QueryInterface(InterfaceId ifaceId, Ptr *iface)
    {
      RetCode Ret = Private::QueryInterface<T>::Query(static_cast<T *>(this), ifaceId, iface);
      if (Ret == Status::Ok)
        AddRef();
      return Ret;
    }

// Assembly:
movl $0x28, %eax
cmpl $0x6f972b9, %esi        # imm = 0x6F972B9
je 0x1954f
cmpl $0x2cc77d66, %esi       # imm = 0x2CC77D66
je 0x1954f
movl $0x3, %eax
cmpl $0x29ab589c, %esi       # imm = 0x29AB589C
jne 0x1955b
movl $0x10, %eax
addq %rdi, %rax
movq %rax, (%rdx)
lock
incl 0x58(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/examples/simple_enum/main.cpp
// Function: MyNs::Impl::BestOffer::MyOffer(double)
virtual Boss::RetCode BOSS_CALL MyOffer(double price)
      {
        if (price < 0)
          return Boss::Status::InvalidArgument;
        try
        {
          Prices.push_back(price);
        }
        catch (std::exception const &)
        {
          return Boss::Status::Fail;
        }
        return Boss::Status::Ok;
      }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movl $0x5, %ebx
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x195a0
movq 0x40(%rdi), %rsi
cmpq 0x48(%rdi), %rsi
je 0x19590
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x40(%rdi)
xorl %ebx, %ebx
jmp 0x195a0
addq $0x38, %rdi
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdx
callq 0x18c7c
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x1ad30
callq 0x1ada0
movl $0x2, %ebx
jmp 0x195a0
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/examples/simple_enum/main.cpp
// Function: MyNs::Impl::BestOffer::GetAllOffers(Boss::IEnum**) const
virtual Boss::RetCode BOSS_CALL GetAllOffers(Boss::IEnum **offers) const
      {
        try
        {
          auto Offers = Boss::Base<Boss::Enum>::Create();
          for (auto i : Prices)
          {
            Offers->AddItem(Boss::Base<FixPrice>::Create(i));
          }
          return Offers.QueryInterface(offers);
        }
        catch (std::exception const &)
        {
        }
        return Boss::Status::Fail;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
callq 0x181f2
movq 0x38(%r14), %r13
movq 0x40(%r14), %rbp
cmpq %rbp, %r13
je 0x19636
movq %rsp, %r14
leaq 0x10(%rsp), %r15
movsd (%r13), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x19aaa
movq %r12, %rdi
movq %r14, %rsi
callq 0x1828c
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x19625
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, (%rsp)
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x195ef
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x196be
movq (%rdi), %rax
movl $0xe2cd2d56, %esi       # imm = 0xE2CD2D56
movq %rbx, %rdx
callq *0x28(%rax)
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x196c3
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x196c3
jmp 0x1966e
jmp 0x19676
movq %rdx, %r14
movq %rax, %rbx
jmp 0x196ab
movq %rax, %rdi
callq 0x18c71
movq %rdx, %r14
movq %rax, %rbx
jmp 0x1969b
movq %rdx, %r14
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x19693
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, (%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x196ab
movq (%rdi), %rax
callq *0x20(%rax)
movq %rbx, %rdi
cmpl $0x1, %r14d
jne 0x196d4
callq 0x1ad30
callq 0x1ada0
movl $0x2, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xbb300
jmp 0x1966e
jmp 0x1966e
nop
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/enum_helper.h
// Function: Boss::EnumHelper<Boss::IBase>::NextInternal()
IBasePtr NextInternal()
    {
      IBasePtr Ret;
      RetCode Code = Enumerator->Next(Ret.GetPPtr());
      if (Code != Status::Ok && Code != Status::False)
        throw EnumHelperException("Failed to get next item.");
      return std::move(Ret);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rax
movq $0x0, (%rax)
movq (%rsi), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x28(%rcx)
cmpl $0x2, %eax
jae 0x19fb2
movq (%rsp), %rax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x1abd0
movq %rax, %r14
leaq 0xa427d(%rip), %rsi     # 0xbe243
movq %rax, %rdi
callq 0x2e110
leaq 0xdb0e3(%rip), %rax     # 0xf50b8
movq %rax, (%r14)
leaq 0xdb0b1(%rip), %rsi     # 0xf5090
leaq 0xa7aa(%rip), %rdx      # 0x24790
movq %r14, %rdi
callq 0x1bc20
movq %rax, %rbx
movq %r14, %rdi
callq 0x1ac30
jmp 0x19ffe
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a00d
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xbb300
movq %rax, %rdi
callq 0x18c71
nop
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/../core/ref_obj_qi_ptr.h
// Function: Boss::RefObjQIPtr<Boss::IBase>& Boss::RefObjQIPtr<Boss::IBase>::operator=<Boss::IBase>(Boss::RefObjPtr<Boss::IBase>&&)
RefObjQIPtr& operator = (RefObjPtr<Other> &&ptr)
    {
      RefObjQIPtr<T> Tmp;
      if (ptr.Ptr)
        ptr.QueryInterface(Tmp.GetPPtr());
      Swap(Tmp);
      ptr.Release();
      return *this;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, (%rsp)
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1a06b
movq (%rdi), %rax
movq %rsp, %rdx
movl $0x2cc77d66, %esi       # imm = 0x2CC77D66
callq *0x20(%rax)
movq (%r14), %rax
movq (%rsp), %rcx
movq (%rbx), %rdi
movq %rdi, (%rsp)
movq %rcx, (%rbx)
testq %rax, %rax
je 0x1a079
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq (%rsp), %rdi
jmp 0x1a079
movq (%rbx), %rdi
movq %rdi, (%rsp)
movq $0x0, (%rbx)
movq $0x0, (%r14)
testq %rdi, %rdi
je 0x1a08b
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x1a0b2
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a0aa
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xbb300
movq %rax, %rdi
callq 0x18c71
// File: /workspace/github_cpp_makefile_star2_O3/f18m[P]boost-intrusive-pool/tests/tutorial.cpp
// Function: showcase_std_shared_pointers()
void showcase_std_shared_pointers()
{
    print_header();
    std::cout << "Running some examples for std::shared_ptr<>:" << std::endl;

    // the test below shows that the overhead of a std::shared_ptr is about 8B/pointer
    // (tested with GCC 7.3.0) and the control block adds an overhead of about 16B

    {
        std::shared_ptr<DummyClass> hdummy;
        std::cout << "  Size of a simple std::shared_ptr<>: " << sizeof(hdummy) << std::endl;

        {
            // now allocate an instance of the class:
            std::cout << "  Now allocating dummy class of size: " << sizeof(DummyClass) << std::endl;
            hdummy = std::make_shared<DummyClass>(); // you will see a memory malloc traced when running this line

            // of course copying pointers around does not trigger any memory allocation:
            std::shared_ptr<DummyClass> hdummy2 = hdummy;

        } // the DummyClass instance survives this block since its reference is stored in hdummy

        std::cout << "  Going to release all references to the std::shared_ptr<> created so far" << std::endl;
    } // you will see a memory free traced when running this line
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
callq 0x2595
movq 0x89d6(%rip), %rbx      # 0xafd0
leaq 0x3a79(%rip), %rsi      # 0x607a
movl $0x2c, %edx
movq %rbx, %rdi
callq 0x2100
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x3a6b(%rip), %rsi      # 0x60a7
movl $0x26, %edx
movq %rbx, %rdi
callq 0x2100
movl $0x10, %esi
movq %rbx, %rdi
callq 0x2090
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x3a47(%rip), %rsi      # 0x60ce
movl $0x26, %edx
movq %rbx, %rdi
callq 0x2100
movl $0x420, %esi            # imm = 0x420
movq %rbx, %rdi
callq 0x2090
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq -0x20(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x28(%rbp), %rbx
leaq -0x11(%rbp), %rdx
movq %rbx, %rsi
callq 0x3b24
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x270d
movq 0x88d1(%rip), %rax      # 0xafc8
cmpb $0x0, (%rax)
je 0x2701
incl 0x8(%rbx)
jmp 0x2705
lock
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0x3960
movq 0x88bc(%rip), %r14      # 0xafd0
leaq 0x39da(%rip), %rsi      # 0x60f5
movl $0x49, %edx
movq %r14, %rdi
callq 0x2100
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq 0x888a(%rip), %rdi      # 0xafd0
callq 0x2040
movq %rax, %rdi
callq 0x20a0
testq %rbx, %rbx
je 0x2760
movq %rbx, %rdi
callq 0x3960
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
testq %rbx, %rbx
je 0x2779
movq %rbx, %rdi
callq 0x3960
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/f18m[P]boost-intrusive-pool/tests/tutorial.cpp
// Function: main
int main()
{
    showcase_std_shared_pointers();
    showcase_boost_intrusive_pointers();
    showcase_boost_intrusive_pool();

    print_header();
    std::cout << "Exiting" << std::endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x25e3
callq 0x2781
callq 0x2b49
callq 0x2595
movq 0x7de3(%rip), %rbx      # 0xafd0
leaq 0x33f5(%rip), %rsi      # 0x65e9
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2100
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyClass>::allocate()
item_ptr allocate()
    {
        assert(m_pool); // pool must be initialized
        Item* recycled_item = m_pool->allocate_safe_get_recycled_item();
        if (!recycled_item)
            return nullptr;

        // in this case we don't need to call ANY function

        item_ptr ret_ptr(recycled_item);
#if BOOST_INTRUSIVE_POOL_DEBUG_CHECKS
        ret_ptr->check();
#endif
        return ret_ptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x34a3
callq 0x4738
testq %rax, %rax
je 0x3494
movq %rax, (%rbx)
movq 0x8(%rax), %rcx
cmpq $0x3ff, %rcx            # imm = 0x3FF
jae 0x34c2
incq %rcx
movq %rcx, 0x8(%rax)
movq %rax, %rdi
callq 0x3c00
jmp 0x349b
movq $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x39dc(%rip), %rdi      # 0x6e86
leaq 0x31f2(%rip), %rsi      # 0x66a3
leaq 0x39d5(%rip), %rcx      # 0x6e8d
movl $0x18d, %edx            # imm = 0x18D
callq 0x2080
leaq 0x3189(%rip), %rdi      # 0x6652
leaq 0x31d3(%rip), %rsi      # 0x66a3
leaq 0x31ed(%rip), %rcx      # 0x66c4
movl $0xdc, %edx
callq 0x2080
movq %rax, %r14
movq %rbx, %rdi
callq 0x3344
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: boost::intrusive_ptr<DummyDerivedClass> memorypool::boost_intrusive_pool<DummyDerivedClass>::allocate_through_function<>(std::function<void (DummyDerivedClass&)>)
item_ptr allocate_through_function(allocate_function fn)
    {
        assert(m_pool); // pool must be initialized
        Item* recycled_item = m_pool->allocate_safe_get_recycled_item();
        if (!recycled_item)
            return nullptr;

        // Construct the object in the obtained storage
        // uses perfect forwarding to the class ctor:
        /// new (recycled_item) Item(std::forward<Args>(args)...);
        fn(*recycled_item);

        // relinking the item to the pool is instead a critical step: we just executed
        // the ctor of the recycled item; that resulted in a call to
        // boost_intrusive_pool_item::boost_intrusive_pool_item()!
        recycled_item->_refcounted_item_set_pool(m_pool);

        // AFTER the ctor call, run the check() function
        item_ptr ret_ptr(recycled_item);
#if BOOST_INTRUSIVE_POOL_DEBUG_CHECKS
        ret_ptr->check();
#endif
        return ret_ptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x378a
movq %rdx, %r12
movq %rsi, %r15
callq 0x54ee
testq %rax, %rax
je 0x3773
cmpq $0x0, 0x10(%r12)
je 0x37a9
movq %rax, %r14
movq %r12, %rdi
movq %rax, %rsi
callq *0x18(%r12)
movq 0x8(%r15), %rax
movq %rax, -0x28(%rbp)
testq %rax, %rax
je 0x372f
incl 0x8(%rax)
movq %r14, %rdi
addq $0x18, %rdi
leaq -0x28(%rbp), %rsi
callq 0x4466
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x3753
decl 0x8(%rdi)
jne 0x3753
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, (%rbx)
movq 0x8(%r14), %rax
cmpq $0x3ff, %rax            # imm = 0x3FF
jae 0x37ae
incq %rax
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x3c00
jmp 0x377a
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x36f5(%rip), %rdi      # 0x6e86
leaq 0x2f0b(%rip), %rsi      # 0x66a3
leaq 0x3cb9(%rip), %rcx      # 0x7458
movl $0x1b5, %edx            # imm = 0x1B5
callq 0x2080
callq 0x2060
leaq 0x2e9d(%rip), %rdi      # 0x6652
leaq 0x2ee7(%rip), %rsi      # 0x66a3
leaq 0x2f01(%rip), %rcx      # 0x66c4
movl $0xdc, %edx
callq 0x2080
movq %rax, %r14
movq %rbx, %rdi
callq 0x38c6
jmp 0x37f1
movq %rax, %r14
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x37f1
decl 0x8(%rdi)
jne 0x37f1
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool_item::check() const
void check() const
    {
        if (is_in_memory_pool()) {
            assert(m_boost_intrusive_pool_refcount < BOOST_INTRUSIVE_POOL_DEBUG_MAX_REFCOUNT);

            if (m_boost_intrusive_pool_refcount == 0) {
                // this item is apparently inside the free list of the memory pool:
                // in such case it should be always linked to the list; the only case where
                // the "next" pointer can be NULL is in the case the memory pool is memory-bounded
                // and the free items are exhausted or the memory pool is infinite but the memory is over
                assert(m_boost_intrusive_pool_next != nullptr || m_boost_intrusive_pool_owner->is_bounded()
                    || m_boost_intrusive_pool_owner->is_memory_exhausted());
            } else {
                // this item is in use and thus must be UNLINKED from the free list of the memory pool:
                assert(m_boost_intrusive_pool_next == nullptr);
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x3c6d
movq 0x8(%rbx), %rax
cmpq $0x400, %rax            # imm = 0x400
jae 0x3c74
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x3c4b
testq %rcx, %rcx
je 0x3c6d
leaq 0x2be5(%rip), %rdi      # 0x6818
leaq 0x2a69(%rip), %rsi      # 0x66a3
leaq 0x2b11(%rip), %rcx      # 0x6752
movl $0xcd, %edx
callq 0x2080
testq %rcx, %rcx
jne 0x3c6d
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0x3c6d
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3c93
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x3cb2
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2a8d(%rip), %rdi      # 0x6708
leaq 0x2a21(%rip), %rsi      # 0x66a3
leaq 0x2ac9(%rip), %rcx      # 0x6752
movl $0xc2, %edx
callq 0x2080
leaq 0x2ba5(%rip), %rdi      # 0x683f
leaq 0x2ba6(%rip), %rsi      # 0x6847
leaq 0x2bce(%rip), %rcx      # 0x6876
movl $0xc7, %edx
callq 0x2080
leaq 0x2ad3(%rip), %rdi      # 0x678c
leaq 0x29e3(%rip), %rsi      # 0x66a3
leaq 0x2a8b(%rip), %rcx      # 0x6752
movl $0xca, %edx
callq 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O3/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyClass>::init(unsigned long, unsigned long, unsigned long, memorypool::recycle_method_e, std::function<void (DummyClass&)>)
bool init(size_t init_size = BOOST_INTRUSIVE_POOL_DEFAULT_POOL_SIZE,
        size_t enlarge_size = BOOST_INTRUSIVE_POOL_INCREASE_STEP, size_t max_size = BOOST_INTRUSIVE_POOL_NO_MAX_SIZE,
        recycle_method_e recycle_method = RECYCLE_METHOD_NONE, recycle_function recycle_fn = nullptr)
    {
        assert(m_pool == nullptr); // cannot initialize twice the memory pool
        assert(init_size > 0);
        assert((max_size == BOOST_INTRUSIVE_POOL_NO_MAX_SIZE) || (max_size >= init_size && enlarge_size > 0));

        m_pool = boost::intrusive_ptr<impl>(new impl(enlarge_size, max_size, recycle_method, recycle_fn));

        // do initial malloc
        return m_pool->enlarge(init_size);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpq $0x0, 0x8(%rdi)
jne 0x3da7
testq %rsi, %rsi
je 0x3dc6
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %r14
movq %r9, %rbx
movl %r8d, -0x2c(%rbp)
testq %rcx, %rcx
je 0x3d1e
testq %r12, %r12
je 0x3e04
cmpq %rsi, %r13
jb 0x3e04
movq %rsi, -0x38(%rbp)
movl $0x88, %edi
callq 0x235c
movq %rax, %r15
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x3e5c
leaq -0x58(%rbp), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl -0x2c(%rbp), %ecx
callq 0x3ede
incl 0x8(%r15)
movq 0x8(%r14), %rdi
movq %r15, 0x8(%r14)
testq %rdi, %rdi
je 0x3d6c
decl 0x8(%rdi)
jne 0x3d6c
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x48(%rbp), %rax
testq %rax, %rax
movq -0x38(%rbp), %rbx
je 0x3d87
leaq -0x58(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x3de5
movq %rbx, %rsi
callq 0x3f7c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b92(%rip), %rdi      # 0x6940
leaq 0x28ee(%rip), %rsi      # 0x66a3
leaq 0x2b96(%rip), %rcx      # 0x6952
movl $0x176, %edx            # imm = 0x176
callq 0x2080
leaq 0x2c0d(%rip), %rdi      # 0x69da
leaq 0x28cf(%rip), %rsi      # 0x66a3
leaq 0x2b77(%rip), %rcx      # 0x6952
movl $0x177, %edx            # imm = 0x177
callq 0x2080
leaq 0x2a53(%rip), %rdi      # 0x683f
leaq 0x2a54(%rip), %rsi      # 0x6847
leaq 0x2e16(%rip), %rcx      # 0x6c10
movl $0xc7, %edx
callq 0x2080
leaq 0x2bdd(%rip), %rdi      # 0x69e8
leaq 0x2891(%rip), %rsi      # 0x66a3
leaq 0x2b39(%rip), %rcx      # 0x6952
movl $0x178, %edx            # imm = 0x178
callq 0x2080
jmp 0x3e41
movq %rax, %rbx
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0x3e4c
leaq -0x58(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3e4c
movq %rax, %rdi
callq 0x39cc
movq %rax, %rbx
movq %r15, %rdi
callq 0x242d
movq %rbx, %rdi
callq 0x21a0