LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x68, %rsp
movl %edi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x11da0
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0x11dd0
leaq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11ed0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11f00
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x11f30
testb $0x1, %al
jne 0x8e5f
jmp 0x8ea7
leaq 0x20(%rsp), %rdi
callq 0x11f70
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
cmpl 0x5c(%rsp), %eax
jne 0x8e99
movq 0x10(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x48(%rsp), %rax
movl %ecx, (%rax)
movb $0x1, 0x67(%rsp)
movl $0x1, 0xc(%rsp)
jmp 0x8ebf
jmp 0x8e9b
leaq 0x20(%rsp), %rdi
callq 0x11f80
jmp 0x8e4a
movq 0x48(%rsp), %rax
movl $0x0, (%rax)
movb $0x0, 0x67(%rsp)
movl $0x1, 0xc(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11fa0
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x8c40
movl %eax, 0xc(%rsp)
movl $0x7fffffff, 0x8(%rsp)  # imm = 0x7FFFFFFF
movl 0xc(%rsp), %esi
leaq 0x3aaee(%rip), %rdi     # 0x442c8
leaq 0x8(%rsp), %rdx
callq 0x8ee0
testb $0x1, %al
jne 0x97ea
jmp 0x9842
movq 0x3a7e7(%rip), %rdi     # 0x43fd8
leaq 0x26fd6(%rip), %rsi     # 0x307ce
callq 0x32c0
movq %rax, %rdi
movl 0x8(%rsp), %esi
callq 0x3440
movq %rax, %rdi
movq 0x3a7b5(%rip), %rsi     # 0x43fc8
callq 0x32f0
cmpl $-0x13, 0x8(%rsp)
jne 0x9821
jmp 0x9840
leaq 0x26fca(%rip), %rdi     # 0x307f2
leaq 0x26fe1(%rip), %rsi     # 0x30810
movl $0xa2, %edx
leaq 0x26fe7(%rip), %rcx     # 0x30822
callq 0x3200
jmp 0x9842
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
leaq 0x3a51c(%rip), %rdi     # 0x44350
leaq 0x2c(%rsp), %rsi
callq 0x11100
movb $0x1, (%rax)
movq 0x30(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x12350
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x102f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10320
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10350
testb $0x1, %al
jne 0x9e88
jmp 0x9eca
leaq 0x18(%rsp), %rdi
callq 0x10390
movl (%rax), %eax
movl %eax, 0xc(%rsp)
leaq 0x3a4b1(%rip), %rdi     # 0x44350
leaq 0xc(%rsp), %rsi
callq 0x11100
testb $0x1, (%rax)
jne 0x9ebc
movq 0x30(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x9e20
jmp 0x9ebe
leaq 0x18(%rsp), %rdi
callq 0x10660
jmp 0x9e73
leaq 0x3a42f(%rip), %rdi     # 0x44300
leaq 0x2c(%rsp), %rsi
callq 0x123f0
addq $0x38, %rsp
retq
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x3a457(%rip), %rdi     # 0x44350
leaq 0x2c(%rsp), %rsi
callq 0x11100
movb $0x1, (%rax)
movq 0x30(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x12350
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x102f0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x10320
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x10350
testb $0x1, %al
jne 0x9f4d
jmp 0x9f94
leaq 0x10(%rsp), %rdi
callq 0x10390
movl (%rax), %eax
movl %eax, 0x4(%rsp)
leaq 0x3a3ec(%rip), %rdi     # 0x44350
leaq 0x4(%rsp), %rsi
callq 0x11100
testb $0x1, (%rax)
jne 0x9f86
movq 0x30(%rsp), %rdi
movl 0x4(%rsp), %esi
movq 0x20(%rsp), %rdx
callq 0x9ee0
jmp 0x9f88
leaq 0x10(%rsp), %rdi
callq 0x10660
jmp 0x9f38
movq 0x20(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x106f0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: Manca[P]algorithms2/./assignment6.hpp
// Function: assignment6::run_algorithm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool run_algorithm(const std::string& fileName)
    {
        // load from file
        Graph G, GRev;
        readFile(fileName, G, GRev);
        
        _explored.clear();
        PROFILE("Modified Kosaraju for 2SAT");
        // run algorithm with original and reverse graphs
        bool res = Check2SAT(G, GRev);
        PROFILE_STOP();
        return res;
    }

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x12810
leaq 0x70(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x12810
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0xe0(%rsp), %rdi
callq 0x9850
jmp 0xa409
leaq 0x39f40(%rip), %rdi     # 0x44350
callq 0x12570
callq 0x10a60
movq %rax, 0x20(%rsp)
jmp 0xa421
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3470
movq 0x18(%rsp), %rdx
leaq 0x2642a(%rip), %rsi     # 0x30866
leaq 0x40(%rsp), %rdi
callq 0x3360
jmp 0xa448
movq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x10ad0
jmp 0xa459
leaq 0x40(%rsp), %rdi
callq 0x31f0
leaq 0x3f(%rsp), %rdi
callq 0x3300
leaq 0xa8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x9fb0
movb %al, 0x17(%rsp)
jmp 0xa485
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x3e(%rsp)
callq 0x10a60
movq %rax, 0x8(%rsp)
jmp 0xa49b
movq 0x8(%rsp), %rdi
callq 0x10b90
jmp 0xa4a7
movb 0x3e(%rsp), %al
movb %al, 0x7(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x12820
leaq 0xa8(%rsp), %rdi
callq 0x12820
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0xa516
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0xa50c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x31f0
leaq 0x3f(%rsp), %rdi
callq 0x3300
leaq 0x70(%rsp), %rdi
callq 0x12820
leaq 0xa8(%rsp), %rdi
callq 0x12820
movq 0x68(%rsp), %rdi
callq 0x3460
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x3350
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rdi)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, (%rsp)
addq $0x68, %rdi
callq 0x16d40
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x16cf0
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x16cc0
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x16d50
movq 0x10(%rsp), %rdi
movq %rax, 0x10(%rdi)
addq $0x68, %rdi
callq 0x16d60
movq 0x333c6(%rip), %rdi     # 0x43fd8
leaq 0x200cc(%rip), %rsi     # 0x30ce5
callq 0x32c0
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
callq 0x16d70
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x32a0
movq %rax, %rdi
leaq 0x200a8(%rip), %rsi     # 0x30cf0
callq 0x32c0
movq %rax, %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x3180
movq %rax, %rdi
leaq 0x1fac5(%rip), %rsi     # 0x3072d
callq 0x32c0
movq %rax, %rdi
leaq 0x20080(%rip), %rsi     # 0x30cf7
callq 0x32c0
movq %rax, %rdi
movq 0x33342(%rip), %rsi     # 0x43fc8
callq 0x32f0
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x16d80
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movslq 0xc(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movslq 0xc(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0xc(%rsp), %ecx
movl %ecx, 0x10(%rax)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x10d60
movq (%rsp), %rax
movl 0x8(%rsp), %esi
movq (%rax), %rcx
movslq 0x8(%rsp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x8(%rax), %rax
movslq 0x8(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10d26
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x1c(%rsp), %esi
callq 0x10d70
movq 0x8(%rsp), %rdi
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %esi
callq 0x10d70
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jne 0x10e09
jmp 0x10ea9
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
movslq 0x14(%rsp), %rdx
movl (%rax,%rdx,4), %eax
movq 0x8(%rcx), %rcx
movslq 0x10(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x10e3e
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %edx
movq (%rax), %rax
movslq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x10e9b
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
movslq 0x14(%rsp), %rdx
movl (%rax,%rdx,4), %eax
movq 0x8(%rcx), %rcx
movslq 0x10(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x10e73
movq 0x8(%rsp), %rax
movl 0x10(%rsp), %edx
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x10e99
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movslq 0x14(%rsp), %rdx
movl (%rcx,%rdx,4), %esi
addl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
movl 0x14(%rsp), %edx
movq (%rax), %rax
movslq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x10e9b
movq 0x8(%rsp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x298, %rsp            # imm = 0x298
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
movq 0x290(%rsp), %rdi
movq %rdi, 0x48(%rsp)
addq $0x8, %rdi
movq %rdi, 0x40(%rsp)
callq 0x19050
movq 0x48(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x50(%rsp)
callq 0x19060
movq 0x288(%rsp), %rsi
leaq 0x78(%rsp), %rdi
movl $0x8, %edx
callq 0x3410
jmp 0x128ee
leaq 0x78(%rsp), %rdi
callq 0x3430
movb %al, 0x3f(%rsp)
jmp 0x128fe
movb 0x3f(%rsp), %al
testb $0x1, %al
jne 0x1290b
jmp 0x129f1
movq 0x48(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x31e0
jmp 0x1291c
jmp 0x1291e
leaq 0x78(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x3090
movq %rax, 0x30(%rsp)
jmp 0x12934
movq 0x30(%rsp), %rdi
leaq 0x64(%rsp), %rsi
callq 0x3090
movq %rax, 0x28(%rsp)
jmp 0x1294a
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3310
movb %al, 0x27(%rsp)
jmp 0x12964
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x1296e
jmp 0x129e3
movq 0x48(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x64(%rsp), %rsi
callq 0x190a0
movaps %xmm0, 0x10(%rsp)
jmp 0x12992
movq 0x8(%rsp), %rdi
movaps 0x10(%rsp), %xmm0
movlpd %xmm0, 0x5c(%rsp)
leaq 0x5c(%rsp), %rsi
callq 0x19070
jmp 0x129ae
jmp 0x1291e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x12a6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x30c0
jmp 0x12a6e
leaq 0x78(%rsp), %rdi
callq 0x3040
jmp 0x129ef
jmp 0x129f1
movq 0x48(%rsp), %rax
movq %rax, %rdi
addq $0x20, %rdi
movslq (%rax), %rsi
callq 0x190d0
jmp 0x12a07
movl $0x0, 0x58(%rsp)
movq 0x48(%rsp), %rcx
movl 0x58(%rsp), %eax
cmpl (%rcx), %eax
jge 0x12a50
movq 0x48(%rsp), %rdi
addq $0x20, %rdi
movslq 0x58(%rsp), %rsi
callq 0x19170
movq %rax, %rdi
movq 0x48(%rsp), %rax
movslq (%rax), %rsi
callq 0x19190
jmp 0x12a41
jmp 0x12a43
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x12a0f
movq 0x48(%rsp), %rdi
callq 0x19230
jmp 0x12a5c
leaq 0x78(%rsp), %rdi
callq 0x30c0
addq $0x298, %rsp            # imm = 0x298
retq
movq 0x50(%rsp), %rdi
callq 0x19320
movq 0x40(%rsp), %rdi
callq 0x19380
movq 0x70(%rsp), %rdi
callq 0x3460
nopl (%rax)
// File: Manca[P]algorithms2/./assignment5.hpp
// Function: assignment5::TSP::next_subset(int)
int next_subset(int x)
        {
            int y = x & -x;
            int c = x + y;
            x = (((x ^ c) >> 2) / y) | c;
            return x;
        }

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl -0xc(%rsp), %eax
xorl %ecx, %ecx
subl -0xc(%rsp), %ecx
andl %ecx, %eax
movl %eax, -0x10(%rsp)
movl -0xc(%rsp), %eax
addl -0x10(%rsp), %eax
movl %eax, -0x14(%rsp)
movl -0xc(%rsp), %eax
xorl -0x14(%rsp), %eax
sarl $0x2, %eax
cltd
idivl -0x10(%rsp)
orl -0x14(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x18(%rcx)
cmpq $0x186a0, %rax          # imm = 0x186A0
jb 0x11a67e
callq 0x111650
movq 0x8(%rsp), %rsi
movq %rax, 0x10(%rsp)
addq $0x20, %rsi
leaq 0x10(%rsp), %rdi
callq 0x11a8c0
testb $0x1, %al
jne 0x11a66a
jmp 0x11a671
movb $0x0, 0x27(%rsp)
jmp 0x11a683
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: tdv[P]boss/boss/examples/simple_enum/main.cpp
// Function: main
int main()
{
  try
  {
    auto Collection = CreateTestCollection();
    std::cout << "--------------- Before --------------- " << std::endl;
    ShowAllObjects(Collection);
    SetMyOffers(Collection, 5, 7);
    SetMyBets(Collection, 7);
    std::cout << "--------------- After --------------- " << std::endl;
    ShowAllObjects(Collection);
  }
  catch (std::exception const &e)
  {
    std::cerr << "Error: " << e.what() << std::endl;
  }
  return 0;
}

// Assembly:
subq $0x68, %rsp
movl $0x0, 0x64(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x183a0
jmp 0x19858
leaq 0xefc01(%rip), %rdi     # 0x109460
leaq 0xada2d(%rip), %rsi     # 0xc7293
callq 0x8ef10
movq %rax, 0x18(%rsp)
jmp 0x19872
movq 0x18(%rsp), %rdi
leaq 0x74f72(%rip), %rsi     # 0x8e7f0
callq 0x8da00
jmp 0x19885
leaq 0x40(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x1b520
jmp 0x19896
leaq 0x40(%rsp), %rdi
callq 0x186d0
jmp 0x198a2
leaq 0x40(%rsp), %rdi
callq 0x1a980
leaq 0x38(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x1b520
jmp 0x198bd
leaq 0x38(%rsp), %rdi
movl $0x5, %esi
movl $0x7, %edx
callq 0x19060
jmp 0x198d3
leaq 0x38(%rsp), %rdi
callq 0x1a980
leaq 0x30(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x1b520
jmp 0x198ee
leaq 0x30(%rsp), %rdi
movl $0x7, %esi
callq 0x194c0
jmp 0x198ff
leaq 0x30(%rsp), %rdi
callq 0x1a980
leaq 0xefb50(%rip), %rdi     # 0x109460
leaq 0xad9a4(%rip), %rsi     # 0xc72bb
callq 0x8ef10
movq %rax, 0x10(%rsp)
jmp 0x19923
movq 0x10(%rsp), %rdi
leaq 0x74ec1(%rip), %rsi     # 0x8e7f0
callq 0x8da00
jmp 0x19936
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x1b520
jmp 0x19947
leaq 0x28(%rsp), %rdi
callq 0x186d0
jmp 0x19953
leaq 0x28(%rsp), %rdi
callq 0x1a980
leaq 0x58(%rsp), %rdi
callq 0x1a980
jmp 0x19a6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x199ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x199f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1a980
jmp 0x199f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1a980
jmp 0x199f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1a980
jmp 0x199f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1a980
leaq 0x58(%rsp), %rdi
callq 0x1a980
movl 0x4c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x19a8b
movq 0x50(%rsp), %rdi
callq 0x23160
movq %rax, 0x20(%rsp)
leaq 0xef91e(%rip), %rdi     # 0x109340
leaq 0xad8b9(%rip), %rsi     # 0xc72e2
callq 0x8ef10
movq %rax, 0x8(%rsp)
jmp 0x19a35
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x8ef10
movq %rax, (%rsp)
jmp 0x19a56
movq (%rsp), %rdi
leaq 0x74d8f(%rip), %rsi     # 0x8e7f0
callq 0x8da00
jmp 0x19a68
callq 0x231d0
xorl %eax, %eax
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x231d0
jmp 0x19a89
jmp 0x19a8b
movq 0x50(%rsp), %rdi
callq 0xc42f0
movq %rax, %rdi
callq 0x1b560
nopl (%rax)
// File: tdv[P]boss/boss/include/common/enum_helper.h
// Function: Boss::EnumHelper<Boss::IBase>::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:
subq $0x88, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, 0x40(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x21370
movq 0x40(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x213b0
jmp 0x1ac5f
jmp 0x1ac61
movq 0x38(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x213f0
jmp 0x1ac72
leaq 0x68(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1ad90
movq %rax, 0x20(%rsp)
jmp 0x1ac88
movq 0x20(%rsp), %rdi
callq 0x1a460
movq %rax, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1add0
movq 0x18(%rsp), %rax
cmpq $0x0, %rax
jne 0x1acf3
movl $0x2, 0x4c(%rsp)
jmp 0x1ad34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x1ad7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x1ad40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1add0
jmp 0x1ad40
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x21520
movq %rax, 0x10(%rsp)
jmp 0x1ad09
movq 0x10(%rsp), %rdi
callq 0x215e0
movq %rax, 0x8(%rsp)
jmp 0x1ad1a
movq 0x8(%rsp), %rax
cmpq $0x0, %rax
je 0x1ad2f
movl $0x2, 0x4c(%rsp)
jmp 0x1ad34
jmp 0x1ac61
leaq 0x68(%rsp), %rdi
callq 0x1add0
jmp 0x1ad4c
leaq 0x68(%rsp), %rdi
callq 0x1add0
jmp 0x1ad7c
movq 0x28(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x215f0
jmp 0x1ad5d
movl $0x1, 0x4c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x1ce80
movq 0x30(%rsp), %rax
addq $0x88, %rsp
retq
leaq 0x70(%rsp), %rdi
callq 0x1ce80
movq 0x60(%rsp), %rdi
callq 0xc42f0
// File: tdv[P]boss/boss/include/core/ref_obj_ptr.h
// Function: Boss::RefObjPtr<MyNs::IFaces::IFixPrice>::operator=(Boss::RefObjPtr<MyNs::IFaces::IFixPrice>&&)
RefObjPtr& operator = (RefObjPtr &&ptr)
    {
      Release();
      Ptr = ptr.Ptr;
      ptr.Ptr = 0;
      return *this;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x21960
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq $0x0, (%rcx)
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x1c4db
movq 0x60(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1c4e8
movl $0x5, 0x74(%rsp)
jmp 0x1c5f9
movq 0x20(%rsp), %rsi
addq $0x18, %rsi
leaq 0x58(%rsp), %rdi
callq 0x1d350
jmp 0x1c4fd
movq 0x20(%rsp), %rdi
movq %rdi, %rax
addq $0x58, %rax
movq %rax, 0x10(%rsp)
addq $0x40, %rdi
callq 0x1d3a0
movq %rax, 0x18(%rsp)
jmp 0x1c51e
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x1d380
testb $0x1, %al
jne 0x1c53d
jmp 0x1c5ad
movl $0x1, 0x74(%rsp)
movl $0x1, 0x3c(%rsp)
jmp 0x1c5ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x1c57a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1d470
movl 0x4c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1c602
movq 0x50(%rsp), %rdi
callq 0x23160
movq %rax, 0x28(%rsp)
movl $0x2, 0x74(%rsp)
movl $0x1, 0x3c(%rsp)
callq 0x231d0
jmp 0x1c5f9
movq 0x20(%rsp), %rdi
addq $0x58, %rdi
xorl %esi, %esi
callq 0x1d3d0
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1d400
movq %rax, %rdi
movq 0x60(%rsp), %rsi
callq 0x1d420
movl %eax, 0xc(%rsp)
jmp 0x1c5df
movl 0xc(%rsp), %eax
movl %eax, 0x74(%rsp)
movl $0x1, 0x3c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1d470
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0xc42f0
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x18, %rsi
leaq 0x30(%rsp), %rdi
callq 0x1d350
jmp 0x1c633
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
callq 0x1cc70
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x58(%rax)
leaq 0x30(%rsp), %rdi
callq 0x1d470
jmp 0x1c69c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1c6ad
movq 0x28(%rsp), %rdi
callq 0x23160
movq %rax, 0x10(%rsp)
movl $0x2, 0x44(%rsp)
callq 0x231d0
jmp 0x1c6a4
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xc42f0
nopw (%rax,%rax)
// File: tdv[P]boss/boss/examples/simple_enum/main.cpp
// Function: MyNs::Impl::FixPrice::GetPrice(double*) const
virtual Boss::RetCode BOSS_CALL GetPrice(double *price) const
      {
        if (!price)
          return Boss::Status::InvalidArgument;
        *price = Price;
        return Boss::Status::Ok;
      }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x18(%rsp)
jne 0x1df76
movl $0x5, -0x4(%rsp)
jmp 0x1df91
movq -0x20(%rsp), %rax
movsd 0x18(%rax), %xmm0
movq -0x18(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
xorps %xmm0, %xmm0
ucomisd 0x20(%rsp), %xmm0
jbe 0x1ec8d
movl $0x5, 0x34(%rsp)
jmp 0x1ece4
movq (%rsp), %rdi
addq $0x38, %rdi
leaq 0x20(%rsp), %rsi
callq 0x1a730
jmp 0x1eca1
jmp 0x1ecdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1eced
movq 0x18(%rsp), %rdi
callq 0x23160
movq %rax, 0x8(%rsp)
movl $0x2, 0x34(%rsp)
callq 0x231d0
jmp 0x1ece4
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xc42f0
nopw (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x19bf0
jmp 0x1ed24
movq 0x10(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x1fa20
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x1fa50
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1fa80
testb $0x1, %al
jne 0x1ed68
jmp 0x1edfd
leaq 0x38(%rsp), %rdi
callq 0x1fac0
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x19ce0
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1fad0
jmp 0x1ed9c
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x19cf0
jmp 0x1edad
leaq 0x20(%rsp), %rdi
callq 0x19e90
leaq 0x38(%rsp), %rdi
callq 0x1fbc0
jmp 0x1ed50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x1ee30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x1ee26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x19e90
jmp 0x1ee26
movq 0x60(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x1fbe0
movl %eax, 0x4(%rsp)
jmp 0x1ee12
movl 0x4(%rsp), %eax
movl %eax, 0x74(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1a290
jmp 0x1ee59
leaq 0x58(%rsp), %rdi
callq 0x1a290
movl 0x4c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1ee62
movq 0x50(%rsp), %rdi
callq 0x23160
movq %rax, 0x18(%rsp)
callq 0x231d0
movl $0x2, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0xc42f0
nopl (%rax)
// File: tdv[P]boss/boss/examples/simple_enum/main.cpp
// Function: MyNs::Impl::Auction::MyBet(double)
virtual Boss::RetCode BOSS_CALL MyBet(double bet)
      {
        if (GetPriceValue() < bet)
        {
          SetPrice(bet);
          return Boss::Status::Ok;
        }
        return Boss::Status::False;
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
callq 0x20eb0
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2040f
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x1f240
movl $0x0, 0x24(%rsp)
jmp 0x20417
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
xorl %eax, %eax
movl %eax, %esi
leaq 0x60(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x213b0
movq 0x28(%rsp), %rdi
callq 0x212d0
movq 0x30(%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x21670
movq %rax, 0x40(%rsp)
jmp 0x21448
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
movl %eax, 0x14(%rsp)
jmp 0x21461
movl 0x14(%rsp), %eax
movl %eax, 0x5c(%rsp)
cmpl $0x0, 0x5c(%rsp)
je 0x214de
cmpl $0x1, 0x5c(%rsp)
je 0x214de
movl $0x10, %edi
callq 0x23000
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0xa5eb0(%rip), %rsi     # 0xc7343
callq 0x21680
jmp 0x2149a
movq 0x8(%rsp), %rdi
leaq 0xe0bea(%rip), %rsi     # 0x102090
leaq -0x2dd(%rip), %rdx      # 0x211d0
callq 0x24050
jmp 0x21517
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x21503
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x23060
jmp 0x21503
movq 0x18(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x212a0
jmp 0x214ef
leaq 0x60(%rsp), %rdi
callq 0x1add0
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
leaq 0x60(%rsp), %rdi
callq 0x1add0
movq 0x50(%rsp), %rdi
callq 0xc42f0
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21370
movq 0x38(%rsp), %rax
cmpq $0x0, (%rax)
je 0x21599
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x21710
movq %rax, 0x10(%rsp)
jmp 0x2156c
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x216c0
jmp 0x2157d
jmp 0x21599
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1ce80
jmp 0x215ca
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x21720
jmp 0x215aa
movq 0x38(%rsp), %rdi
callq 0x21320
jmp 0x215b6
leaq 0x30(%rsp), %rdi
callq 0x1ce80
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xc42f0
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x90, %rsp
callq 0x2490
movq 0xcb01(%rip), %rdi      # 0xefd8
movq %rdi, -0x50(%rbp)
leaq 0x6bcf(%rip), %rsi      # 0x90b1
callq 0x20f0
movq %rax, %rdi
movq 0xcacf(%rip), %rsi      # 0xefc0
callq 0x2100
leaq -0x10(%rbp), %rdi
callq 0x3310
movq -0x50(%rbp), %rdi
leaq 0x6bd4(%rip), %rsi      # 0x90de
callq 0x20f0
movq %rax, -0x48(%rbp)
jmp 0x2515
movq -0x48(%rbp), %rdi
movl $0x10, %esi
callq 0x2040
movq %rax, -0x58(%rbp)
jmp 0x2529
movq -0x58(%rbp), %rdi
movq 0xca8c(%rip), %rsi      # 0xefc0
callq 0x2100
jmp 0x253b
movq 0xca96(%rip), %rdi      # 0xefd8
leaq 0x6bbc(%rip), %rsi      # 0x9105
callq 0x20f0
movq %rax, -0x60(%rbp)
jmp 0x2554
movq -0x60(%rbp), %rdi
movl $0x420, %esi            # imm = 0x420
callq 0x2040
movq %rax, -0x68(%rbp)
jmp 0x2568
movq -0x68(%rbp), %rdi
movq 0xca4d(%rip), %rsi      # 0xefc0
callq 0x2100
jmp 0x257a
leaq -0x30(%rbp), %rdi
callq 0x3330
jmp 0x2585
leaq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x30(%rbp), %rsi
movq %rsi, -0x88(%rbp)
callq 0x33a0
movq -0x88(%rbp), %rdi
callq 0x33d0
movq -0x80(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x33f0
movq -0x78(%rbp), %rdi
callq 0x33d0
movq 0xca0e(%rip), %rdi      # 0xefd8
leaq 0x6b5b(%rip), %rsi      # 0x912c
callq 0x20f0
movq %rax, -0x70(%rbp)
jmp 0x25dc
movq -0x70(%rbp), %rdi
movq 0xc9d9(%rip), %rsi      # 0xefc0
callq 0x2100
jmp 0x25ee
leaq -0x10(%rbp), %rdi
callq 0x33d0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x33d0
movq -0x18(%rbp), %rdi
callq 0x2190
nop
// File: 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
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x24c0
callq 0x2620
callq 0x2930
callq 0x2490
movq 0xc04e(%rip), %rdi      # 0xefd8
leaq 0x668f(%rip), %rsi      # 0x9620
callq 0x20f0
movq %rax, %rdi
movq 0xc020(%rip), %rsi      # 0xefc0
callq 0x2100
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
callq 0x68e0
testb $0x1, %al
jne 0x37f2
jmp 0x37f4
jmp 0x3813
leaq 0x66c2(%rip), %rdi      # 0x9ebd
leaq 0x5ed8(%rip), %rsi      # 0x96da
movl $0x18d, %edx            # imm = 0x18D
leaq 0x66b6(%rip), %rcx      # 0x9ec4
callq 0x20a0
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x5920
movq %rax, %rdi
callq 0x6990
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3847
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x3500
jmp 0x389e
movq -0x48(%rbp), %rdi
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x3500
movq -0x48(%rbp), %rdi
callq 0x3590
movq %rax, %rdi
callq 0x51e0
jmp 0x3870
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x389c
jmp 0x3893
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3630
jmp 0x38a8
movq -0x48(%rbp), %rdi
callq 0x3630
jmp 0x389e
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2190
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdx, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
callq 0x8210
testb $0x1, %al
jne 0x3b5a
jmp 0x3b5c
jmp 0x3b7b
leaq 0x635a(%rip), %rdi      # 0x9ebd
leaq 0x5b70(%rip), %rsi      # 0x96da
movl $0x1b5, %edx            # imm = 0x1B5
leaq 0x6919(%rip), %rcx      # 0xa48f
callq 0x20a0
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x7300
movq %rax, %rdi
callq 0x82c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3bb2
movq -0x58(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x8560
jmp 0x3c62
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7cd0
movq -0x48(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x85b0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x63b0
jmp 0x3beb
leaq -0x28(%rbp), %rdi
callq 0x4300
movq -0x58(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x8560
movq -0x58(%rbp), %rdi
callq 0x3c80
movq %rax, %rdi
callq 0x51e0
jmp 0x3c1d
movb $0x1, -0x3d(%rbp)
testb $0x1, -0x3d(%rbp)
jne 0x3c60
jmp 0x3c57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4300
jmp 0x3c6c
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x3d70
jmp 0x3c6c
movq -0x58(%rbp), %rdi
callq 0x3d70
jmp 0x3c62
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2190
nopw %cs:(%rax,%rax)
nop
// File: f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::intrusive_ptr_release(memorypool::boost_intrusive_pool_item*)
inline void intrusive_ptr_release(boost_intrusive_pool_item* x)
{
#if BOOST_INTRUSIVE_POOL_DEBUG_CHECKS
    x->check();
#endif
    if (--x->m_boost_intrusive_pool_refcount == 0) {
        if (x->m_boost_intrusive_pool_owner)
            x->m_boost_intrusive_pool_owner->recycle(x);
        else
            // assume the item has been allocated out of the pool:
            delete x;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x51e0
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x51d6
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x52f0
testb $0x1, %al
jne 0x519e
jmp 0x51ba
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x5310
movq %rax, %rdi
movq -0x8(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x51d4
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x51d2
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x51d4
jmp 0x51d6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x5360
testb $0x1, %al
jne 0x5202
jmp 0x52e3
movq -0x10(%rbp), %rax
cmpq $0x400, 0x8(%rax)       # imm = 0x400
jae 0x5212
jmp 0x5231
leaq 0x4526(%rip), %rdi      # 0x973f
leaq 0x44ba(%rip), %rsi      # 0x96da
movl $0xc2, %edx
leaq 0x455d(%rip), %rcx      # 0x9789
callq 0x20a0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x52b3
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x10(%rcx)
movb %al, -0x11(%rbp)
jne 0x5287
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x5310
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x5287
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x5310
movq %rax, %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x5290
jmp 0x5292
jmp 0x52b1
leaq 0x452a(%rip), %rdi      # 0x97c3
leaq 0x443a(%rip), %rsi      # 0x96da
movl $0xca, %edx
leaq 0x44dd(%rip), %rcx      # 0x9789
callq 0x20a0
jmp 0x52e1
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x52c0
jmp 0x52df
leaq 0x4588(%rip), %rdi      # 0x984f
leaq 0x440c(%rip), %rsi      # 0x96da
movl $0xcd, %edx
leaq 0x44af(%rip), %rcx      # 0x9789
callq 0x20a0
jmp 0x52e1
jmp 0x52e3
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyClass>::impl::impl(unsigned long, unsigned long, memorypool::recycle_method_e, std::function<void (DummyClass&)>)
impl(size_t enlarge_size, size_t max_size, recycle_method_e method, recycle_function recycle)
        {
            // assert(enlarge_size > 0); // NOTE: enlarge_size can be zero to create a limited-size memory pool

            // configurations
            m_recycle_method = method;
            m_recycle_fn = recycle;
            m_enlarge_step = enlarge_size;
            m_max_size = max_size;

            // status
            m_first_free_item = nullptr;
            m_first_arena = nullptr;
            m_last_arena = nullptr;
            m_memory_exhausted = false;
            m_trigger_self_destruction = false;

            // stats
            m_free_count = 0;
            m_inuse_count = 0;
            m_total_count = 0;

#if BOOST_INTRUSIVE_POOL_DEBUG_THREAD_ACCESS
            m_allowed_thread = 0;
#endif
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %r8, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5b40
movq -0x50(%rbp), %rdi
leaq 0x9469(%rip), %rax      # 0xec10
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x48(%rbp)
callq 0x5b80
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x1c(%rbp), %ecx
movl %ecx, 0xc(%rax)
callq 0x5bc0
jmp 0x57d4
movq -0x50(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x48(%rax)
movb $0x0, 0x58(%rax)
movb $0x0, 0x78(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x68(%rax)
movq $0x0, 0x70(%rax)
movq $0x0, 0x80(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x37a0
movq -0x50(%rbp), %rdi
callq 0x5fe0
movq -0x30(%rbp), %rdi
callq 0x2190
nopl (%rax,%rax)