LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::layout_weighted(unsigned long, double*, unsigned long, unsigned long*, unsigned long*, double*, unsigned long, double)
void layout_weighted(uint64_t n, double* X, uint64_t m, uint64_t* I, uint64_t* J, double* V, uint64_t t_max, double eps)
{
    try
    {
        std::vector<term> terms = dijkstra(n, m, I, J, V);
        std::vector<double> etas = schedule(terms, t_max, eps);
        sgd(X, terms, etas);
    }
    catch (const char* msg)
    {
        std::cerr << "Error: " << msg << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movsd %xmm0, -0x30(%rbp)
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x28(%rbp), %rdi
callq 0x3036
movq 0x10(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movsd -0x30(%rbp), %xmm0
callq 0x3414
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x263c
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x396f
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x3984
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x39b0
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x39b0
movq %rdx, %r14
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x39cd
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x39cd
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3a1f
movq %rbx, %rdi
callq 0x2060
movq %rax, %rbx
movq 0xb60b(%rip), %rdi      # 0xeff0
leaq 0x7740(%rip), %rsi      # 0xb12c
movl $0x7, %edx
callq 0x2180
movq 0xb5f3(%rip), %rdi      # 0xeff0
movq %rbx, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x2070
callq 0x2200
jmp 0x3984
movq %rax, %rbx
callq 0x2200
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::layout_unweighted_convergent(unsigned long, double*, unsigned long, unsigned long*, unsigned long*, unsigned long, double, double, unsigned long)
void layout_unweighted_convergent(uint64_t n, double* X, uint64_t m, uint64_t* I, uint64_t* J, uint64_t t_max, double eps, double delta, uint64_t t_maxmax)
{
    try
    {
        std::vector<term> terms = bfs(n, m, I, J);
        std::vector<double> etas = schedule_convergent(terms, t_max, eps, t_maxmax);
        sgd(X, terms, etas, delta);
    } 
    catch (const char* msg)
    {
        std::cerr << "Error: " << msg << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movq %r9, %r14
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x28(%rbp), %rdi
callq 0x29de
movq 0x10(%rbp), %rcx
leaq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movq %r14, %rdx
movsd -0x38(%rbp), %xmm0
callq 0x359a
leaq -0x28(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x263c
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3a91
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x3aa6
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3ad2
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x3ad2
movq %rdx, %r14
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x3aef
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x3aef
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3b41
movq %rbx, %rdi
callq 0x2060
movq %rax, %rbx
movq 0xb4e9(%rip), %rdi      # 0xeff0
leaq 0x761e(%rip), %rsi      # 0xb12c
movl $0x7, %edx
callq 0x2180
movq 0xb4d1(%rip), %rdi      # 0xeff0
movq %rbx, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x2070
callq 0x2200
jmp 0x3aa6
movq %rax, %rbx
callq 0x2200
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::layout_weighted_convergent(unsigned long, double*, unsigned long, unsigned long*, unsigned long*, double*, unsigned long, double, double, unsigned long)
void layout_weighted_convergent(uint64_t n, double* X, uint64_t m, uint64_t* I, uint64_t* J, double* V, uint64_t t_max, double eps, double delta, uint64_t t_maxmax)
{
    try
    {
        std::vector<term> terms = dijkstra(n, m, I, J, V);
        std::vector<double> etas = schedule_convergent(terms, t_max, eps, t_maxmax);
        sgd(X, terms, etas, delta);
    }
    catch (const char* msg)
    {
        std::cerr << "Error: " << msg << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x28(%rbp), %rdi
callq 0x3036
movq 0x18(%rbp), %rcx
movq 0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movsd -0x38(%rbp), %xmm0
callq 0x359a
leaq -0x28(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x263c
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3bb1
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x3bc6
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3bf2
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x3bf2
movq %rdx, %r14
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x3c0f
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x3c0f
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3c61
movq %rbx, %rdi
callq 0x2060
movq %rax, %rbx
movq 0xb3c9(%rip), %rdi      # 0xeff0
leaq 0x74fe(%rip), %rsi      # 0xb12c
movl $0x7, %edx
callq 0x2180
movq 0xb3b1(%rip), %rdi      # 0xeff0
movq %rbx, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x2070
callq 0x2200
jmp 0x3bc6
movq %rax, %rbx
callq 0x2200
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::mds_direct(unsigned long, double*, double*, double*, unsigned long, double*)
void mds_direct(uint64_t n, double* X, double* d, double* w, uint64_t t_max, double* eta)
{
    // initialize SGD
    uint64_t nC2 = (n*(n-1))/2;
    std::vector<term> terms;
    terms.reserve(nC2);
    uint64_t ij=0;
    for (uint64_t i=0; i<n; i++) // unpack the condensed distance matrices
    {
        for (uint64_t j=i+1; j<n; j++)
        {
            terms.push_back(term(i, j, d[ij], w[ij]));
            ij += 1;
        }
    }

    // initialize step sizes
    std::vector<double> etas;
    etas.reserve(t_max);
    for (uint64_t t=0; t<t_max; t++)
    {
        etas.push_back(eta[t]);
    }
    
    sgd(X, terms, etas, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, -0x80(%rbp)
movq %r8, -0x88(%rbp)
movq %rcx, -0x98(%rbp)
movq %rdx, %r13
movq %rsi, -0x78(%rbp)
movq %rdi, %rbx
leaq -0x1(%rdi), %rsi
imulq %rdi, %rsi
shrq %rsi
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x744e
testq %rbx, %rbx
je 0x3d44
xorl %r15d, %r15d
xorl %r14d, %r14d
leaq 0x1(%r15), %r12
cmpq %rbx, %r12
movq %r12, -0x90(%rbp)
jae 0x3d38
movsd (%r13,%r14,8), %xmm0
movq -0x98(%rbp), %rax
movsd (%rax,%r14,8), %xmm1
movq %r15, -0x50(%rbp)
movq %r12, -0x48(%rbp)
movsd %xmm0, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
movq -0x68(%rbp), %rsi
cmpq -0x60(%rbp), %rsi
je 0x3d20
movups -0x50(%rbp), %xmm0
movups -0x40(%rbp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, %rsi
movq %rsi, -0x68(%rbp)
jmp 0x3d2d
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x8b9c
incq %r14
incq %r12
cmpq %rbx, %r12
jb 0x3cd7
movq -0x90(%rbp), %r15
cmpq %rbx, %r15
jne 0x3cc7
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq -0x88(%rbp), %r15
movq %r15, %rsi
callq 0x794a
testq %r15, %r15
movq -0x80(%rbp), %r14
je 0x3da3
leaq -0x50(%rbp), %rbx
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x3d8f
movsd (%r14), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3d9a
movq %rbx, %rdi
movq %r14, %rdx
callq 0x95d8
addq $0x8, %r14
decq %r15
jne 0x3d72
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdx
xorps %xmm0, %xmm0
movq -0x78(%rbp), %rdi
callq 0x263c
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3dcc
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x3de1
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e0e
jmp 0x3df4
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3e11
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x3e11
movq %rax, %rbx
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x3e26
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::layout_sparse_unweighted(unsigned long, double*, unsigned long, unsigned long*, unsigned long*, unsigned long, unsigned long, double)
void layout_sparse_unweighted(uint64_t n, double* X, uint64_t m, uint64_t* I, uint64_t* J, uint64_t p, uint64_t t_max, double eps)
{
    try
    {
        std::vector<std::vector<uint64_t>> g = build_graph_unweighted(n, m, I, J);
        auto closest_pivots = maxmin_random_sp_unweighted(g, p, 0);
        auto terms = MSSP_unweighted(g, closest_pivots);
        auto etas = schedule(terms, t_max, eps);
        sgd(X, terms, etas);
    }
    catch (const char* msg)
    {
        std::cerr << "Error: " << msg << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movsd %xmm0, -0x30(%rbp)
movq %r9, %r14
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x78(%rbp), %rdi
callq 0x2839
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x403f
leaq -0x28(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x4562
movq 0x10(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movsd -0x30(%rbp), %xmm0
callq 0x64aa
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x3e2e
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x6705
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x671a
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x672f
movq -0x50(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq -0x78(%rbp), %rdi
callq 0x7396
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x6764
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x6764
movq %rdx, %r14
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x6781
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x6781
movq %rdx, %r14
movq %rax, %rbx
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x679e
movq -0x50(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x679e
movq %rdx, %r14
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x7396
jmp 0x67af
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x6801
movq %rbx, %rdi
callq 0x2060
movq %rax, %rbx
movq 0x8829(%rip), %rdi      # 0xeff0
leaq 0x495e(%rip), %rsi      # 0xb12c
movl $0x7, %edx
callq 0x2180
movq 0x8811(%rip), %rdi      # 0xeff0
movq %rbx, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x2070
callq 0x2200
jmp 0x6738
movq %rax, %rbx
callq 0x2200
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::layout_sparse_weighted(unsigned long, double*, unsigned long, unsigned long*, unsigned long*, double*, unsigned long, unsigned long, double)
void layout_sparse_weighted(uint64_t n, double* X, uint64_t m, uint64_t* I, uint64_t* J, double* V, uint64_t p, uint64_t t_max, double eps)
{
    try
    {
        std::vector<std::vector<edge>> g = build_graph_weighted(n, m, I, J, V);

        auto closest_pivots = maxmin_random_sp_weighted(g, p, 0);
        auto terms = MSSP_weighted(g, closest_pivots);
        auto etas = schedule(terms, t_max, eps);
        sgd(X, terms, etas);
    }
    catch (const char* msg)
    {
        std::cerr << "Error: " << msg << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movsd %xmm0, -0x30(%rbp)
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x78(%rbp), %rdi
callq 0x2dae
movq 0x10(%rbp), %rdx
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
xorl %ecx, %ecx
callq 0x5234
leaq -0x28(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x576e
movq 0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movsd -0x30(%rbp), %xmm0
callq 0x64aa
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x3e2e
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x6887
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x689c
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x68b1
movq -0x50(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq -0x78(%rbp), %rdi
callq 0x76ae
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x68e6
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x68e6
movq %rdx, %r14
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x6903
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x6903
movq %rdx, %r14
movq %rax, %rbx
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x6920
movq -0x50(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x6920
movq %rdx, %r14
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x76ae
jmp 0x6931
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x6983
movq %rbx, %rdi
callq 0x2060
movq %rax, %rbx
movq 0x86a7(%rip), %rdi      # 0xeff0
leaq 0x47dc(%rip), %rsi      # 0xb12c
movl $0x7, %edx
callq 0x2180
movq 0x868f(%rip), %rdi      # 0xeff0
movq %rbx, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x2070
callq 0x2200
jmp 0x68ba
movq %rax, %rbx
callq 0x2200
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/Marm0t[P]dji-phantom3-parser/packet.cpp
// Function: Packet::parseHex()
void Packet::parseHex()
{
    if (_packv.size() < PACKET_HEADER_LEN)
    {
        cerr << "Error while parsing message: message to short, size: " << dec <<_packv.size() << endl;
        _valid = false;
        return;
    }

    // byte 1 - packet len
    _packetLen = _packv[1];
    // packet len in byte1 must be the same as _packv vector length
    // otherwise consider that message is corrupted
    if (_packetLen != _packv.size() )
    {
        cerr << "Error while parsing message: message length in packet ("<< dec << (int)_packetLen
             << ") is not equal to number of bytes read from file("<< dec << _packv.size() << ")" << endl;
        _valid = false;
        return;
    }

    // bytes 3 and 4 - packet type (2 bytes)
    char aType[2];
    for (int i = 0; i<2; ++i) aType[i] = _packv[i+3];
    memcpy(&_packetType, aType, 2);

    // bytes 6-9 - message ID (4 bytes)
    char aMsgId[4];
    for (int i = 0; i<4; ++i)
    {
        aMsgId[i] = _packv[i+6];
    }
    memcpy(&_msgId, aMsgId, 4);

    _valid = true;

    // try to convert all data bytes into doubles
    dataToDoubles();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
subq %rax, %rcx
cmpq $0x9, %rcx
ja 0x330a
movq 0x3d2c(%rip), %r14      # 0x6ff0
leaq 0x1e80(%rip), %rsi      # 0x514b
movl $0x35, %edx
movq %r14, %rdi
callq 0x2170
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%r14,%rax)
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x20c0
movq %rax, %r14
movq (%rax), %rax
jmp 0x33ca
movzbl 0x1(%rax), %edx
movb %dl, 0x20(%rbx)
cmpq %rdx, %rcx
jne 0x3334
movzwl 0x3(%rax), %ecx
movw %cx, 0x22(%rbx)
movl 0x6(%rax), %eax
movl %eax, 0x24(%rbx)
movb $0x1, 0x28(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2eb6
movq 0x3cb5(%rip), %r14      # 0x6ff0
leaq 0x1e3f(%rip), %rsi      # 0x5181
movl $0x37, %edx
movq %r14, %rdi
callq 0x2170
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%r14,%rax)
movzbl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x21e0
movq %rax, %r14
leaq 0x1e3d(%rip), %rsi      # 0x51b9
movl $0x31, %edx
movq %rax, %rdi
callq 0x2170
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%r14,%rax)
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x20c0
movq %rax, %r14
leaq 0x1e31(%rip), %rsi      # 0x51eb
movl $0x1, %edx
movq %rax, %rdi
callq 0x2170
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movb $0x0, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Marm0t[P]dji-phantom3-parser/packet.cpp
// Function: GPSPacket::parseHex()
void GPSPacket::parseHex()
{
    Packet::parseHex();
    
    // first we should check packet type (must be 0x01CF)
    if (this->getPacketType() != 0x01CF)
    {
     //   cout << "GPSPacket: Wrong packet type: " << hex << this->getPacketType();
        _valid = false;
        return;
    }

    // then check byte#6 (must be 0x00 for pgs packet)
    if (this->getPacketRaw()[6] != 0x00)
    {
     //   cout << "GPSPacket: Wrong byte#6 (muxt be 0x00) " << hex << this->getPacketRaw()[6] << endl;
        _valid = false;
        return;
    }

    // now we can get lat/long/alt values
    // TODO
    _lon=convertDoubleToGps(doubleFromBytePos(10)); // byte#10 - beginning of longitude
    _lat=convertDoubleToGps(doubleFromBytePos(18)); // byte#18 - beginning of latitude
    _alt=floatFromBytePos(26);

    _bytes30_33_f=floatFromBytePos(30);
    _bytes34_37_f=floatFromBytePos(34);
    _bytes38_41_f=floatFromBytePos(38);
    _bytes42_45_f=floatFromBytePos(42);
    
    _bytes46_49_f=floatFromBytePos(46);
    _bytes50_53_f=floatFromBytePos(50);
    _bytes54_57_f=floatFromBytePos(54);
    _bytes58_61_f=floatFromBytePos(58);
    
    
    _valid = true;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x32a2
cmpw $0x1cf, 0x22(%rbx)      # imm = 0x1CF
jne 0x3418
movq 0x8(%rbx), %rax
cmpb $0x0, 0x6(%rax)
je 0x3424
xorl %eax, %eax
movb %al, 0x5c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movsd 0x1cdc(%rip), %xmm0     # 0x5108
movsd 0xa(%rax), %xmm1
mulsd %xmm0, %xmm1
movsd 0x1cd3(%rip), %xmm2     # 0x5110
divsd %xmm2, %xmm1
movsd %xmm1, 0x48(%rbx)
mulsd 0x12(%rax), %xmm0
divsd %xmm2, %xmm0
movsd %xmm0, 0x50(%rbx)
movss 0x1a(%rax), %xmm0
movss %xmm0, 0x58(%rbx)
movss 0x1e(%rax), %xmm0
movss %xmm0, 0x60(%rbx)
movss 0x22(%rax), %xmm0
movss %xmm0, 0x64(%rbx)
movss 0x26(%rax), %xmm0
movss %xmm0, 0x68(%rbx)
movss 0x2a(%rax), %xmm0
movss %xmm0, 0x6c(%rbx)
movss 0x2e(%rax), %xmm0
movss %xmm0, 0x70(%rbx)
movss 0x32(%rax), %xmm0
movss %xmm0, 0x74(%rbx)
movss 0x36(%rax), %xmm0
movss %xmm0, 0x78(%rbx)
movss 0x3a(%rax), %xmm0
movss %xmm0, 0x7c(%rbx)
movb $0x1, %al
jmp 0x341a
nop
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/examples/query_interface_2/main.cpp
// Function: main
int main()
{
  try
  {
    auto Obj = Boss::Base<MyNs::Impl::Face_1_2>::Create();
    FuncForIFace1(Boss::RefObjQIPtr<MyNs::IFaces::IFace1>(Obj).Get());
    FuncForIFace2(Boss::RefObjQIPtr<MyNs::IFaces::IFace2>(Obj).Get());
  }
  catch (std::exception const &e)
  {
    std::cerr << "Error: " << e.what() << std::endl;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %rdi
callq 0x162be
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x16182
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movl $0xaec344bf, %esi       # imm = 0xAEC344BF
callq *0x28(%rax)
movq 0x8(%rsp), %rdi
jmp 0x16184
xorl %edi, %edi
callq 0x16073
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x16199
movq (%rdi), %rax
callq *0x18(%rax)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x161c3
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movl $0x37ca1505, %esi       # imm = 0x37CA1505
callq *0x28(%rax)
movq 0x8(%rsp), %rdi
jmp 0x161c5
xorl %edi, %edi
callq 0x160dd
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x161da
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x161ea
movq (%rdi), %rax
callq *0x20(%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x161fa
jmp 0x161fa
jmp 0x16202
movq %rax, %rdi
callq 0x1634e
movq %rdx, %r14
movq %rax, %rbx
jmp 0x1623a
movq %rdx, %r14
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1623a
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x1623a
jmp 0x161fa
movq %rdx, %r14
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1623a
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x16256
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x16256
jmp 0x161fa
jmp 0x161fa
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x162b1
movq %rbx, %rdi
callq 0x16900
movq %rax, %rbx
leaq 0xdf072(%rip), %rdi     # 0xf52e0
leaq 0xa3dd8(%rip), %rsi     # 0xba04d
movl $0x7, %edx
callq 0x803a0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0xdf051(%rip), %rdi     # 0xf52e0
movq %rax, %rsi
callq 0x808d0
movq %rax, %rdi
callq 0x801b0
callq 0x16970
jmp 0x161ea
movq %rax, %rbx
callq 0x16970
movq %rbx, %rdi
callq 0xb7280
jmp 0x161fa
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_rtc_overhead.cpp
// Function: main
int main(int argc, char* argv[])
{
   const std::size_t rounds = ((argc == 2) ? atoi(argv[1]) : 5);

   for (std::size_t i = 0; i < rounds; ++i)
   {
      vector_rtc_overhead_analysis_01<double>();
   }

   printf("-------------------------\n");

   for (std::size_t i = 0; i < rounds; ++i)
   {
      vector_rtc_overhead_analysis_02<double>();
   }

   return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x5, %ebx
cmpl $0x2, %edi
jne 0x11727a
movq 0x8(%rsi), %rdi
callq 0x114170
testl %eax, %eax
je 0x1172a7
movslq %eax, %rbx
movq %rbx, %r14
callq 0x117354
decq %r14
jne 0x11727d
leaq 0x194c22(%rip), %rdi    # 0x2abeb0
callq 0x114500
callq 0x1178c1
decq %rbx
jne 0x117293
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x194c02(%rip), %rdi    # 0x2abeb0
callq 0x114500
jmp 0x11729d
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/pair.cc
// Function: process(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
pair<string, int> process(vector<string>& v)
{
	if (!v.empty())
		return {v.back(), v.back().size()}; // list initialize
	else
		return pair<string, int>(); // explicitly constructed return value
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpq %rax, (%rsi)
je 0x26eb
movq -0x18(%rax), %r14
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq -0x20(%rax), %rsi
leaq (%rsi,%r14), %rdx
movq %rbx, %rdi
callq 0x36b2
jmp 0x2701
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
xorl %r14d, %r14d
movl %r14d, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/pair.cc
// Function: process2(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
pair<string, int> process2(vector<string>& v)
{
	// process v
	if (!v.empty())
		return make_pair(v.back(), v.back().size());
	else
		return pair<string, int>();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpq %rax, (%rsi)
je 0x2765
movq -0x18(%rax), %r15
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x20(%rax), %rsi
leaq (%rsi,%r15), %rdx
leaq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x36b2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rcx
cmpq %r12, %rcx
je 0x2781
movq %rcx, (%rbx)
movq -0x38(%rbp), %rax
movq %rax, 0x10(%rbx)
jmp 0x2789
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movl $0x0, 0x20(%rbx)
jmp 0x2795
movups (%r12), %xmm0
movups %xmm0, (%rax)
movq -0x40(%rbp), %rax
movq %rax, 0x8(%rbx)
movl %r15d, 0x20(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/pair.cc
// Function: process3(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
pair<string, int> process3(vector<string>& v)
{
	// process v
	if (!v.empty())
		return pair<string, int>(v.back(), v.back().size());
	else
		return pair<string, int>();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpq %rax, (%rsi)
je 0x27d5
movq -0x18(%rax), %r14
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq -0x20(%rax), %rsi
leaq (%rsi,%r14), %rdx
movq %rbx, %rdi
callq 0x36b2
jmp 0x27eb
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
xorl %r14d, %r14d
movl %r14d, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/legendddhgf[P]Text2RPG/common.cpp
// Function: stringToParams(char*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*, char const*)
void stringToParams(char *str, vector<string> *params, const char *delimiters) {
  string temp = string("");
  for (size_t i = 0; i < strlen(str); i++) {
    if (strchr(delimiters, str[i]) != nullptr && temp.size() > 0) {
      params->push_back(temp);
      temp = string("");
      continue;
    } else if (strchr(delimiters, str[i]) != nullptr) continue;
    temp.append(1, str[i]); // unfortunately unintuitive way of appending chars
  }
  if (temp.size() > 0) {
    params->push_back(temp);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x59e9(%rip), %rdx      # 0x8247
leaq -0x50(%rbp), %rdi
movq %rdx, %rsi
callq 0x29b2
cmpb $0x0, (%r15)
je 0x2902
xorl %ebx, %ebx
movsbl (%r15,%rbx), %r13d
movq %r14, %rdi
movl %r13d, %esi
callq 0x2090
movq -0x48(%rbp), %rsi
testq %rax, %rax
je 0x28db
testq %rsi, %rsi
je 0x28ee
movq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2958
leaq -0x60(%rbp), %r13
movq %r13, -0x70(%rbp)
leaq -0x70(%rbp), %r12
movq %r12, %rdi
leaq 0x5990(%rip), %rdx      # 0x8247
movq %rdx, %rsi
callq 0x29b2
leaq -0x50(%rbp), %rdi
movq %r12, %rsi
callq 0x2200
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x28ee
callq 0x2160
jmp 0x28ee
movl $0x1, %ecx
leaq -0x50(%rbp), %rdi
xorl %edx, %edx
movl %r13d, %r8d
callq 0x22b0
incq %rbx
movq %r15, %rdi
callq 0x20c0
cmpq %rax, %rbx
jb 0x2876
cmpq $0x0, -0x48(%rbp)
je 0x2916
leaq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x2958
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x2928
callq 0x2160
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x293b
jmp 0x293b
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x2950
callq 0x2160
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/legendddhgf[P]Text2RPG/ArgParser.cpp
// Function: ArgParser::usage1(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ArgParser::usage1(string unexpected) {
  fprintf(stderr, "%s: unexpected field\n", unexpected.c_str());
  fprintf(stderr, "Expected Fields:\n");
  for (string s : expected) {
    fprintf(stderr, "\t%s\n", s.c_str());
  }
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x9233(%rip), %r14      # 0xbfe0
movq (%r14), %rdi
movq (%rsi), %rdx
leaq 0x52be(%rip), %rsi      # 0x8078
xorl %eax, %eax
callq 0x2220
movq (%r14), %rcx
leaq 0x52c3(%rip), %rdi      # 0x808e
movl $0x11, %esi
movl $0x1, %edx
callq 0x22c0
movq 0x50(%rbx), %r12
movq 0x58(%rbx), %r13
cmpq %r13, %r12
je 0x2e3d
leaq -0x38(%rbp), %r15
leaq -0x48(%rbp), %rbx
leaq 0x52aa(%rip), %r14      # 0x80a0
movq %r15, -0x48(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2bfa
movq 0x91cb(%rip), %rax      # 0xbfe0
movq (%rax), %rdi
movq -0x48(%rbp), %rdx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2220
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x2e34
callq 0x2160
addq $0x20, %r12
cmpq %r13, %r12
jne 0x2df6
movl $0x1, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/legendddhgf[P]Text2RPG/ArgParser.cpp
// Function: ArgParser::usage2(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ArgParser::usage2(string expectedstr) {
  fprintf(stderr, "%s: expected field but not found\n", expectedstr.c_str());
  fprintf(stderr, "Expected Fields:\n");
  for (string s : expected) {
    fprintf(stderr, "\t%s\n", s.c_str());
  }
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x917d(%rip), %r14      # 0xbfe0
movq (%r14), %rdi
movq (%rsi), %rdx
leaq 0x5235(%rip), %rsi      # 0x80a5
xorl %eax, %eax
callq 0x2220
movq (%r14), %rcx
leaq 0x520d(%rip), %rdi      # 0x808e
movl $0x11, %esi
movl $0x1, %edx
callq 0x22c0
movq 0x50(%rbx), %r12
movq 0x58(%rbx), %r13
cmpq %r13, %r12
je 0x2ef3
leaq -0x38(%rbp), %r15
leaq -0x48(%rbp), %rbx
leaq 0x51f4(%rip), %r14      # 0x80a0
movq %r15, -0x48(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2bfa
movq 0x9115(%rip), %rax      # 0xbfe0
movq (%rax), %rdi
movq -0x48(%rbp), %rdx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2220
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x2eea
callq 0x2160
addq $0x20, %r12
cmpq %r13, %r12
jne 0x2eac
movl $0x1, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/legendddhgf[P]Text2RPG/ArgParser.cpp
// Function: ArgParser::GetTarget(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string ArgParser::GetTarget(string field) {
  if (fields.find(field) == fields.end()) {
    fprintf(stderr, "%s: Not an existing field\n", field.c_str());
    exit(1);
  }
  return fields.at(field);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x18, %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x448e
testq %rax, %rax
je 0x3317
movq %r15, %rdi
movq %r14, %rsi
callq 0x448e
testq %rax, %rax
je 0x331f
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x28(%rax), %rsi
movq 0x30(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2bfa
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x22f4
leaq 0x4ded(%rip), %rdi      # 0x8113
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/enferex[P]fnplot/cs.cc
// Function: csPrintCallers(_IO_FILE*, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>>>>*, char const*, int)
void csPrintCallers(FILE *out, CSDB *db, const char *fn_name, int depth)
{
    cout << "Building callers... " << std::flush;
    fprintf(out, "digraph \"Callers to %s\" {\n", fn_name);
    printCallersRec(out, db, fn_name, depth);
    fprintf(out, "}\n");
    cout << "Done" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x4a4a(%rip), %rbx      # 0x7fd0
leaq 0x1ce6(%rip), %rsi      # 0x5273
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2140
leaq 0x1cdf(%rip), %rsi      # 0x5288
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2260
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x3622
leaq 0x1cd6(%rip), %rdi      # 0x52a3
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2320
leaq 0x1cc0(%rip), %rsi      # 0x52a6
movl $0x4, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/enferex[P]fnplot/cs.cc
// Function: printCallersRec(_IO_FILE*, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>>>>*, char const*, int)
static void printCallersRec(
    FILE       *out,
    CSDB       *db,
    const char *fn_name,
    int         depth)
{
    if (depth <= 0)
      return;

    for (auto pr: *db) {
        const char *item = pr.first.c_str();
        // Does 'item' call 'fn_name' ?
        if (isCallerOf(db, item, fn_name)) {
            fprintf(out, "    %s -> %s\n", item, fn_name);
            printCallersRec(out, db, item, depth - 1);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movl %ecx, 0x4(%rsp)
testl %ecx, %ecx
jle 0x377a
movq 0x8(%rsp), %rax
movq 0x10(%rax), %r15
testq %r15, %r15
je 0x377a
movq %rdx, %r14
decl 0x4(%rsp)
leaq 0x8(%r15), %rsi
leaq 0x40(%rsp), %rdi
callq 0x3ddc
movq 0x40(%rsp), %rsi
leaq 0x10(%rsp), %rdi
movq %rsi, 0x38(%rsp)
leaq 0x3(%rsp), %rdx
callq 0x3e66
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3ea4
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x36b4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21c0
movq (%rbx), %rbp
movq 0x8(%rbx), %r13
cmpq %r13, %rbp
je 0x373b
movq (%rbp), %rsi
movq (%rsi), %rax
leaq 0x10(%rsp), %rdi
callq *(%rax)
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2250
movl %eax, %r12d
leaq 0x20(%rsp), %rax
cmpq %rax, %rbx
je 0x36fb
movq 0x20(%rsp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x21c0
testl %r12d, %r12d
je 0x3706
addq $0x8, %rbp
jmp 0x36bb
movq 0x30(%rsp), %rbx
movq %rbx, %rdi
leaq 0x1c59(%rip), %rsi      # 0x536e
movq 0x38(%rsp), %r12
movq %r12, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2260
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
movl 0x4(%rsp), %ecx
callq 0x3622
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x3752
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x21c0
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x376e
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x21c0
movq (%r15), %r15
testq %r15, %r15
jne 0x365f
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x37af
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21c0
jmp 0x37af
jmp 0x37ac
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x3e32
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/enferex[P]fnplot/cs.cc
// Function: csPrintCallees(_IO_FILE*, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>>>>*, char const*, int)
void csPrintCallees(FILE *out, CSDB *db, const char *fn_name, int depth)
{
    cout << "Building callees... " << std::flush;
    fprintf(out, "digraph \"Callees of %s\" {\n", fn_name);
    printCalleesRec(out, db, fn_name, depth);
    fprintf(out, "}\n");
    cout << "Done" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x47f5(%rip), %rbx      # 0x7fd0
leaq 0x1ac9(%rip), %rsi      # 0x52ab
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2140
leaq 0x1ac2(%rip), %rsi      # 0x52c0
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2260
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x3877
leaq 0x1a81(%rip), %rdi      # 0x52a3
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2320
leaq 0x1a6b(%rip), %rsi      # 0x52a6
movl $0x4, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/enferex[P]fnplot/cs.cc
// Function: printCalleesRec(_IO_FILE*, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>>>>*, char const*, int)
static void printCalleesRec(
    FILE       *out,
    CSDB       *db,
    const char *fn_name,
    int         depth)
{
    if (depth <= 0)
      return;

    for (auto callee: (*db)[fn_name]) {
        fprintf(out, "    %s -> %s\n", fn_name, callee->getName().c_str());
        printCalleesRec(out, db, callee->getName().c_str(), depth - 1);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %ecx, 0x4(%rsp)
testl %ecx, %ecx
jle 0x3980
movq %rdi, %r12
leaq 0x8(%rsp), %rdi
leaq 0x3(%rsp), %rdx
movq 0x30(%rsp), %rsi
callq 0x3e66
leaq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x3ea4
movq %rax, %r13
leaq 0x18(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x38df
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq (%r13), %r15
movq 0x8(%r13), %rbx
cmpq %rbx, %r15
je 0x3980
decl 0x4(%rsp)
leaq 0x8(%rsp), %r13
movq (%r15), %rbp
movq (%rbp), %rax
movq %r13, %rdi
movq %rbp, %rsi
callq *(%rax)
movq 0x8(%rsp), %rcx
movq %r12, %rdi
leaq 0x1a57(%rip), %rsi      # 0x536e
movq 0x30(%rsp), %rdx
xorl %eax, %eax
callq 0x2260
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x393a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq (%rbp), %rax
movq %r13, %rdi
movq %rbp, %rsi
callq *(%rax)
movq 0x8(%rsp), %rdx
movq %r12, %rdi
movq 0x28(%rsp), %rsi
movl 0x4(%rsp), %ecx
callq 0x3877
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3973
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
addq $0x8, %r15
cmpq %rbx, %r15
jne 0x38f9
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x39b4
jmp 0x39c1
movq %rax, %rbx
jmp 0x39c1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x39c1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::parse()
void TodoList::parse() {
  tasks.clear();

  std::ifstream ifs(path.c_str());

  if (!ifs.good()) {
    std::cerr << "Fatal: Can't open " << path.c_str() << "." << std::endl;
    exit(1);
  }

  while (ifs.good()) {
    std::string line = "";
    getline(ifs, line);

    if (line != "") {
      int taskno = atoi(line.c_str());
      std::string::size_type taskdesc = line.find_first_not_of("1234567890. ");
      if (taskdesc == std::string::npos) continue;
      tasks[taskno] = std::string(line, taskdesc); 
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rdi, %rbx
callq 0x3f42
movq 0x30(%rbx), %rsi
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2350
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x70(%rsp,%rax)
jne 0x2f07
leaq 0x20(%rsp), %r13
leaq 0x135c(%rip), %r15      # 0x415b
leaq 0x10(%rsp), %r12
leaq 0x30(%rsp), %rbp
movq %r13, 0x10(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x2bc4
movq 0x50(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2360
movq %r12, %rdi
movq %r15, %rsi
callq 0x2080
testl %eax, %eax
je 0x2ec0
movq 0x10(%rsp), %rdi
callq 0x22d0
movl %eax, 0xc(%rsp)
movl $0xc, %ecx
movq %r12, %rdi
leaq 0x12e3(%rip), %rsi      # 0x414f
xorl %edx, %edx
callq 0x2310
cmpq $-0x1, %rax
je 0x2ec0
movq %rbp, %rdi
movq %r12, %rsi
movq %rax, %rdx
leaq 0xb(%rsp), %rcx
callq 0x2200
movq %rbx, %rdi
leaq 0xc(%rsp), %rsi
callq 0x36c2
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2270
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x2ec0
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21f0
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x2ed7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
movq 0x50(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x70(%rsp,%rax)
je 0x2e09
leaq 0x50(%rsp), %rdi
callq 0x2060
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x40e2(%rip), %rdi      # 0x6ff0
leaq 0x1301(%rip), %rsi      # 0x4216
movl $0x12, %edx
callq 0x2230
movq 0x30(%rbx), %rsi
movq 0x40c6(%rip), %rdi      # 0x6ff0
callq 0x21d0
movq %rax, %rbx
leaq 0x117d(%rip), %rsi      # 0x40b6
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x20e0
movl $0x1, %edi
callq 0x2250
jmp 0x2f7d
jmp 0x2f82
movq %rax, %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x2f85
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x2f85
movq %rax, %rbx
jmp 0x2f9c
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x2f9c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x50(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void TodoList::add(std::string task) {
  if (task.find_first_not_of("1234567890. ") == std::string::npos) return;

  std::cout << "Added #" << first_unset() << ": " << task << std::endl;
  tasks.insert(std::make_pair(first_unset(), task));
  write();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x118b(%rip), %rsi      # 0x414f
movl $0xc, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x2310
cmpq $-0x1, %rax
je 0x30ae
movq 0x3fec(%rip), %r15      # 0x6fd0
leaq 0x1204(%rip), %rsi      # 0x41ef
movl $0x7, %edx
movq %r15, %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x30da
movq %r15, %rdi
movl %eax, %esi
callq 0x2320
movq %rax, %r15
leaq 0x11e3(%rip), %rsi      # 0x41f7
movl $0x2, %edx
movq %rax, %rdi
callq 0x2230
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x2230
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq %rbx, %rdi
callq 0x30da
leaq 0x10(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x37b0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3b68
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x30a6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x3154
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x30d2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::first_unset()
int TodoList::first_unset() {
  if (tasks.size()) {
    for (int i = 1; i < tasks.rbegin()->first; i++) {
      if (!tasks.count(i)) return i;
    }
    return tasks.rbegin()->first + 1;
  } else {
    return 1;
  }
}

// Assembly:
cmpq $0x0, 0x28(%rdi)
je 0x3144
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x2210
movl 0x20(%rax), %ecx
cmpl $0x2, %ecx
jl 0x313e
movq 0x10(%r14), %rsi
movl $0x1, %eax
movl $0x1, %edx
testq %rsi, %rsi
je 0x314c
movq %rsi, %r8
movq %rbx, %rdi
xorl %r9d, %r9d
cmpl %edx, 0x20(%r8)
setl %r9b
cmovgeq %r8, %rdi
movq 0x10(%r8,%r9,8), %r8
testq %r8, %r8
jne 0x3115
cmpq %rbx, %rdi
je 0x314a
cmpl 0x20(%rdi), %edx
jl 0x314a
incl %edx
cmpl %ecx, %edx
jne 0x310a
incl %ecx
movl %ecx, %eax
jmp 0x314c
movl $0x1, %eax
retq
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::write()
void TodoList::write() {
  std::ofstream ofs(path.c_str());

  tmap::iterator it;

  for (it = tasks.begin(); it != tasks.end(); ++it) {
    ofs << get(it->first) << std::endl;
  }

  ofs.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
movq 0x30(%rdi), %rsi
leaq 0x28(%rsp), %rdi
movl $0x10, %edx
callq 0x2220
movq 0x18(%rbx), %r14
leaq 0x8(%rbx), %rbp
cmpq %rbp, %r14
je 0x320d
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movl 0x20(%r14), %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x33f0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r12, %rdi
callq 0x2230
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x31fd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x2150
movq %rax, %r14
cmpq %rbp, %rax
jne 0x3196
leaq 0x28(%rsp), %rdi
callq 0x2290
movq 0x3da2(%rip), %rax      # 0x6fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x28(%rsp,%rcx)
callq 0x2190
leaq 0x120(%rsp), %rdi
callq 0x20a0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x325d
movq %rax, %rbx
jmp 0x3281
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3281
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x28(%rsp), %rdi
callq 0x22b0
movq %rbx, %rdi
callq 0x2330
nop