LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::schedule(std::vector<sgd2::term_sparse, std::allocator<sgd2::term_sparse>> const&, unsigned long, double)
std::vector<double> schedule(const std::vector<term_sparse> &terms, uint64_t t_max, double eps)
{
    double w_min = std::numeric_limits<double>::max();
    double w_max = std::numeric_limits<double>::min();
    for (const auto& term : terms)
    {
        if (term.w_ij < w_min && term.w_ij != 0) w_min = term.w_ij;
        if (term.w_ji < w_min && term.w_ji != 0) w_min = term.w_ji;

        if (term.w_ij > w_max) w_max = term.w_ij;
        if (term.w_ji > w_max) w_max = term.w_ji;
    }
    double eta_max = 1.0 / w_min;
    double eta_min = eps / w_max;

    double lambda = log(eta_max/eta_min) / ((double)t_max-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_max * exp(-lambda * t));

    return etas;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movsd 0x5d81(%rip), %xmm1     # 0xb028
movsd 0x5d81(%rip), %xmm3     # 0xb030
xorpd %xmm2, %xmm2
cmpq %rcx, %rax
je 0x531b
movsd 0x18(%rax), %xmm4
movapd %xmm4, %xmm5
cmpneqsd %xmm2, %xmm5
movapd %xmm5, %xmm7
andpd %xmm4, %xmm7
movapd %xmm4, %xmm6
maxsd %xmm3, %xmm4
movsd 0x20(%rax), %xmm3
andnpd %xmm1, %xmm5
orpd %xmm7, %xmm5
cmpltsd %xmm1, %xmm6
andpd %xmm6, %xmm5
andnpd %xmm1, %xmm6
orpd %xmm5, %xmm6
movapd %xmm3, %xmm5
cmpneqsd %xmm2, %xmm5
movapd %xmm3, %xmm1
minsd %xmm6, %xmm1
andpd %xmm5, %xmm1
andnpd %xmm6, %xmm5
orpd %xmm5, %xmm1
maxsd %xmm4, %xmm3
addq $0x28, %rax
jmp 0x52b3
movsd 0x5ce5(%rip), %xmm2     # 0xb008
divsd %xmm1, %xmm2
divsd %xmm3, %xmm0
movsd %xmm2, -0x38(%rbp)
movapd %xmm2, %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x2100
movapd %xmm0, -0x30(%rbp)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x61fc
movq %r14, %xmm0
punpckldq 0x5cf5(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x5cfd(%rip), %xmm0     # 0xb070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
addsd 0x5c99(%rip), %xmm1     # 0xb020
movapd -0x30(%rbp), %xmm2
xorpd 0x5cfc(%rip), %xmm2     # 0xb090
divsd %xmm1, %xmm2
xorl %r12d, %r12d
leaq -0x40(%rbp), %r15
movapd %xmm2, -0x30(%rbp)
cmpq %r12, %r14
je 0x53f2
movq %r12, %xmm1
punpckldq 0x5caa(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x5cb2(%rip), %xmm1     # 0xb070
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
callq 0x2220
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8c50
incq %r12
movapd -0x30(%rbp), %xmm2
jmp 0x53a4
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5404
movq %rax, %r14
movq %rbx, %rdi
callq 0x89de
movq %r14, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x18(%rbp)
movq %r9, %r14
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x48(%rbp), %rdi
callq 0x2528
leaq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x37c2
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x3b4b
movq 0x10(%rbp), %rdx
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
callq 0x5283
leaq -0x30(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x35f3
leaq -0x60(%rbp), %rdi
callq 0x89de
leaq -0x30(%rbp), %rdi
callq 0x9c3c
leaq -0x78(%rbp), %rdi
callq 0x7894
leaq -0x48(%rbp), %rdi
callq 0x5e36
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x89de
jmp 0x54c6
movq %rdx, %r14
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9c3c
jmp 0x54d7
movq %rdx, %r14
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x7894
jmp 0x54e8
movq %rdx, %r14
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x5e36
jmp 0x54f9
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x5542
movq %rbx, %rdi
callq 0x2050
movq %rax, %rbx
movq 0xbadf(%rip), %rdi      # 0x10ff0
leaq 0x5c14(%rip), %rsi      # 0xb12c
callq 0x2140
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x2080
callq 0x21e0
jmp 0x54a6
movq %rax, %rbx
callq 0x21e0
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x18(%rbp)
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x48(%rbp), %rdi
callq 0x28ea
movq 0x10(%rbp), %rdx
leaq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
xorl %ecx, %ecx
callq 0x44aa
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x48b6
movq 0x18(%rbp), %rdx
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
callq 0x5283
leaq -0x30(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x35f3
leaq -0x60(%rbp), %rdi
callq 0x89de
leaq -0x30(%rbp), %rdi
callq 0x9c3c
leaq -0x78(%rbp), %rdi
callq 0x7894
leaq -0x48(%rbp), %rdi
callq 0x606c
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x89de
jmp 0x55f7
movq %rdx, %r14
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9c3c
jmp 0x5608
movq %rdx, %r14
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x7894
jmp 0x5619
movq %rdx, %r14
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x606c
jmp 0x562a
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x5673
movq %rbx, %rdi
callq 0x2050
movq %rax, %rbx
movq 0xb9ae(%rip), %rdi      # 0x10ff0
leaq 0x5ae3(%rip), %rsi      # 0xb12c
callq 0x2140
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x2080
callq 0x21e0
jmp 0x55d7
movq %rax, %rbx
callq 0x21e0
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/ekg[P]sgd2/src/main.cpp
// Function: main
int main(void) {
    uint64_t n = 8;
    uint64_t len_I = 9;
    //uint64_t I[len_I] = { 0,0,1,2,3,4,4,5,6 };
    //uint64_t J[len_I] = { 1,2,3,3,4,5,6,7,7 };
    std::vector<uint64_t> I = { 0,0,1,2,3,4,4,5,6 };
    std::vector<uint64_t> J = { 1,2,3,3,4,5,6,7,7 };
    //double V[len_I] = { 1,2,1,1,3,1,2,2,1 };
    //double X[2*n]; // = { 0,0, .1,.1, .2,.2, .3,.3, .4,.4, .5,.5, .6,.6, .7,.7 };
    std::vector<double> X(2*n);
    std::random_device dev;
    // todo, seed with graph topology/contents to get a stable result
    std::mt19937 rng(dev());
    std::uniform_real_distribution<double> dist(0,1);
    for (uint64_t i = 0; i < 2*n; ++i) {
        X[i] = dist(rng);
    }
    //double X[2*n];
    uint64_t p = 10;
    uint64_t t_max = 30;
    double eps = 0.01;
    //layout_sparse_weighted(n, X, len_I, I, J, V, p, t_max, eps);
    sgd2::layout_sparse_unweighted(n, X.data(), I.size(), I.data(), J.data(), p, t_max, eps);
    /*
    for (uint64_t i = 0; i < n; ++i) {
        std::cout << X[i*2] << " " << X[i*2+1] << std::endl;
    }
    */
    draw_svg(n, X, len_I, I, J);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2778, %rsp           # imm = 0x2778
leaq 0x5997(%rip), %rsi      # 0xb310
pushq $0x9
popq %rbx
leaq -0x13f8(%rbp), %rax
movq %rbx, %rcx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq -0x48(%rbp), %rdi
leaq -0x2780(%rbp), %rcx
movq %rax, %rsi
movq %rbx, %rdx
callq 0x657e
leaq 0x59af(%rip), %rsi      # 0xb358
leaq -0x13f8(%rbp), %rax
movq %rbx, %rcx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq -0x60(%rbp), %rdi
leaq -0x2780(%rbp), %rcx
movq %rax, %rsi
movq %rbx, %rdx
callq 0x657e
leaq -0x30(%rbp), %rdi
pushq $0x10
popq %rsi
leaq -0x13f8(%rbp), %rdx
callq 0x65b4
leaq -0x13f8(%rbp), %rdi
callq 0x5b0e
leaq -0x13f8(%rbp), %rdi
callq 0x2180
movl %eax, %esi
leaq -0x2780(%rbp), %rdi
callq 0x6ccc
leaq -0x70(%rbp), %rbx
andq $0x0, (%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x8(%rbx)
xorl %r15d, %r15d
leaq -0x2780(%rbp), %r14
cmpq $0x10, %r15
je 0x5a48
movq %rbx, %rdi
movq %r14, %rsi
callq 0x651c
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
jmp 0x5a28
movq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movq -0x60(%rbp), %r8
movq $0x1e, (%rsp)
pushq $0x8
popq %rdi
pushq $0xa
popq %r9
movsd 0x55da(%rip), %xmm0     # 0xb050
callq 0x5417
pushq $0x8
popq %rdi
leaq -0x30(%rbp), %rsi
pushq $0x9
popq %rdx
leaq -0x48(%rbp), %rcx
leaq -0x60(%rbp), %r8
callq 0x567b
leaq -0x13f8(%rbp), %rdi
callq 0x5d56
leaq -0x30(%rbp), %rdi
callq 0x89de
leaq -0x60(%rbp), %rdi
callq 0x7894
leaq -0x48(%rbp), %rdi
callq 0x7894
xorl %eax, %eax
addq $0x2778, %rsp           # imm = 0x2778
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x5aeb
movq %rax, %rbx
jmp 0x5af4
movq %rax, %rbx
jmp 0x5afd
jmp 0x5adc
jmp 0x5adc
movq %rax, %rbx
leaq -0x13f8(%rbp), %rdi
callq 0x5d56
leaq -0x30(%rbp), %rdi
callq 0x89de
leaq -0x60(%rbp), %rdi
callq 0x7894
leaq -0x48(%rbp), %rdi
callq 0x7894
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/Marm0t[P]dji-phantom3-parser/packet.cpp
// Function: Packet::doubleFromBytePos(int) const
const double Packet::doubleFromBytePos(int iPosition) const
{
    uint8_t aBytes[8]; // 8 - sizeof(double)

    // copy 8 bytes to aBytes
    for (int j = 0; j<sizeof(double); ++j)
    {
        aBytes[j] = _packv[j+iPosition];
    }
    // convert aBytes to double
   return  Packet::doubleFromBytes(aBytes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rax
addq 0x8(%rdi), %rax
xorl %ecx, %ecx
cmpq $0x8, %rcx
je 0x2bf1
movb (%rax,%rcx), %dl
movb %dl, -0x8(%rbp,%rcx)
incq %rcx
jmp 0x2bdf
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Marm0t[P]dji-phantom3-parser/packet.cpp
// Function: Packet::floatFromBytePos(int) const
const float Packet::floatFromBytePos(int iPosition) const
{
    uint8_t aBytes[4]; // 4 - sizeof(float)

    // copy 4 bytes to aBytes
    for (int j = 0; j<sizeof(float); ++j)
    {
        aBytes[j] = _packv[iPosition+j];
    }
    // convert aBytes to double
   return  Packet::floatFromBytes(aBytes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rax
addq 0x8(%rdi), %rax
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x2c17
movb (%rax,%rcx), %dl
movb %dl, -0x4(%rbp,%rcx)
incq %rcx
jmp 0x2c05
movss -0x4(%rbp), %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Marm0t[P]dji-phantom3-parser/packet.cpp
// Function: Packet::dateFromFourBytes[abi:cxx11](unsigned char const*)
string Packet::dateFromFourBytes(const uint8_t* iBytes)
{
    // NOTE: it's only for test purpose!
    // We are not sure that date and time envoded in this particular format!!!

    //Convert 4 bytes to datetime according to this rule
    // YYYYYYYMMMMDDDDDHHHHMMMMMMSSSSSS
    //    7     4   5    4    6     6  
    // stored as little endian 32bit unsigned integer
    
    unsigned int aValue;
    memcpy(&aValue, iBytes, sizeof(unsigned int)); 
    
    int sec = aValue &  0x3f; //0x3F(16) = 0011 1111 (2)
    aValue = aValue >> 6; // move to minutes
    int min = aValue & 0x3f;
    aValue = aValue >> 6; // move to hours
    int hour = aValue & 0xf; // 0xf = 1111
    aValue = aValue >> 4; // move to day
    int day = aValue & 0x1f; // 0x1f = 0001 1111
    aValue = aValue >> 5; // move to month
    int month = aValue & 0xf; // 0xf = 1111
    aValue = aValue >> 4; // ove to year
    int year = aValue & 0x7F; // 0x7F = 0011 1111
    stringstream ss;
    ss << day<<"/"<<month<<"/"<<year<<" "
       << hour<<":"<<min<<":"<<sec;
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rbx
movl (%rsi), %r14d
movl %r14d, %r15d
shrl $0x10, %r15d
andl $0x1f, %r15d
leaq -0x1a0(%rbp), %rdi
callq 0x20d0
leaq -0x190(%rbp), %rdi
movl %r15d, %esi
callq 0x2210
leaq 0x14cf(%rip), %rsi      # 0x4130
movq %rax, %rdi
callq 0x2150
movl %r14d, %esi
shrl $0x15, %esi
andl $0xf, %esi
movq %rax, %rdi
callq 0x2210
leaq 0x14af(%rip), %rsi      # 0x4130
movq %rax, %rdi
callq 0x2150
movl %r14d, %esi
shrl $0x19, %esi
movq %rax, %rdi
callq 0x2210
leaq 0x15a8(%rip), %rsi      # 0x4246
movq %rax, %rdi
callq 0x2150
movl %r14d, %esi
shrl $0xc, %esi
andl $0xf, %esi
movq %rax, %rdi
callq 0x2210
leaq 0x1608(%rip), %rsi      # 0x42c6
movq %rax, %rdi
callq 0x2150
movl %r14d, %esi
shrl $0x6, %esi
andl $0x3f, %esi
movq %rax, %rdi
callq 0x2210
leaq 0x15e8(%rip), %rsi      # 0x42c6
movq %rax, %rdi
callq 0x2150
andl $0x3f, %r14d
movq %rax, %rdi
movl %r14d, %esi
callq 0x2210
leaq -0x188(%rbp), %rsi
movq %rbx, %rdi
callq 0x21d0
leaq -0x1a0(%rbp), %rdi
callq 0x2100
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Marm0t[P]dji-phantom3-parser/packet.cpp
// Function: Packet::datetimeFromBytePos[abi:cxx11](int) const
const string Packet::datetimeFromBytePos(int iPos) const
{
    uint8_t aBytes[4]; // 4 - sizeof(unsigned int)
    // copy 4 bytes to aBytes
    for (int j = 0; j<sizeof(float); ++j)
    {
        aBytes[j] = _packv[iPos+j];
    }
    // convert aBytes to double
   return  Packet::dateFromFourBytes(aBytes);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %edx, %rax
addq 0x8(%rsi), %rax
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x2d5c
movb (%rax,%rcx), %dl
movb %dl, -0xc(%rbp,%rcx)
incq %rcx
jmp 0x2d4a
leaq -0xc(%rbp), %rsi
movq %rbx, %rdi
callq 0x2c1e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Marm0t[P]dji-phantom3-parser/packet.cpp
// Function: Packet::dataToDoubles()
void Packet::dataToDoubles()
{
    uint8_t aBytes[8]; // 8 - sizeof(double)

    for (int i = PACKET_HEADER_LEN; i<_packv.size()-7; ++i)
    {
        // copy 8 bytes to aBytes
        for (int j = 0; j<8; ++j)
        {
            aBytes[j] = _packv[i+j];
        }
        // convert aBytes to double
        _dataDoubles.push_back(doubleFromBytes(aBytes));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
pushq $0xa
popq %r12
leaq -0x28(%rbp), %r15
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
addq $-0x7, %rcx
cmpq %r12, %rcx
jbe 0x2dd5
addq %r12, %rax
xorl %ecx, %ecx
cmpq $0x8, %rcx
je 0x2dbb
movb (%rax,%rcx), %dl
movb %dl, -0x30(%rbp,%rcx)
incq %rcx
jmp 0x2da9
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3c04
incq %r12
jmp 0x2d90
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
subq %rax, %rcx
cmpq $0x9, %rcx
ja 0x304f
movq 0x3fd7(%rip), %rdi      # 0x6ff0
leaq 0x112b(%rip), %rsi      # 0x414b
callq 0x2150
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x20c0
jmp 0x30eb
movzbl 0x1(%rax), %edx
movb %dl, 0x20(%rbx)
cmpq %rdx, %rcx
jne 0x3074
xorl %ecx, %ecx
cmpq $0x2, %rcx
je 0x30f9
movb 0x3(%rax,%rcx), %dl
movb %dl, -0xa(%rbp,%rcx)
incq %rcx
jmp 0x305d
movq 0x3f75(%rip), %rdi      # 0x6ff0
leaq 0x10ff(%rip), %rsi      # 0x4181
callq 0x2150
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movzbl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x2210
leaq 0x110a(%rip), %rsi      # 0x41b9
movq %rax, %rdi
callq 0x2150
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x20c0
leaq 0x1108(%rip), %rsi      # 0x41eb
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20a0
movb $0x0, 0x28(%rbx)
jmp 0x3128
movzwl -0xa(%rbp), %ecx
movw %cx, 0x22(%rbx)
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x3116
movb 0x6(%rax,%rcx), %dl
movb %dl, -0x10(%rbp,%rcx)
incq %rcx
jmp 0x3103
movl -0x10(%rbp), %eax
movl %eax, 0x24(%rbx)
movb $0x1, 0x28(%rbx)
movq %rbx, %rdi
callq 0x2d72
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2ff8
cmpw $0x1cf, 0x22(%rbx)      # imm = 0x1CF
jne 0x3150
movq 0x8(%rbx), %rax
cmpb $0x0, 0x6(%rax)
je 0x315c
xorl %eax, %eax
movb %al, 0x5c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x2bd2
mulsd 0xf99(%rip), %xmm0      # 0x4108
divsd 0xf99(%rip), %xmm0      # 0x4110
movsd %xmm0, 0x48(%rbx)
pushq $0x12
popq %rsi
movq %rbx, %rdi
callq 0x2bd2
mulsd 0xf79(%rip), %xmm0      # 0x4108
divsd 0xf79(%rip), %xmm0      # 0x4110
movsd %xmm0, 0x50(%rbx)
pushq $0x1a
popq %rsi
movq %rbx, %rdi
callq 0x2bf8
movss %xmm0, 0x58(%rbx)
pushq $0x1e
popq %rsi
movq %rbx, %rdi
callq 0x2bf8
movss %xmm0, 0x60(%rbx)
pushq $0x22
popq %rsi
movq %rbx, %rdi
callq 0x2bf8
movss %xmm0, 0x64(%rbx)
pushq $0x26
popq %rsi
movq %rbx, %rdi
callq 0x2bf8
movss %xmm0, 0x68(%rbx)
pushq $0x2a
popq %rsi
movq %rbx, %rdi
callq 0x2bf8
movss %xmm0, 0x6c(%rbx)
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0x2bf8
movss %xmm0, 0x70(%rbx)
pushq $0x32
popq %rsi
movq %rbx, %rdi
callq 0x2bf8
movss %xmm0, 0x74(%rbx)
pushq $0x36
popq %rsi
movq %rbx, %rdi
callq 0x2bf8
movss %xmm0, 0x78(%rbx)
pushq $0x3a
popq %rsi
movq %rbx, %rdi
callq 0x2bf8
movss %xmm0, 0x7c(%rbx)
movb $0x1, %al
jmp 0x3152
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x161ee
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1625e
movq 0x8(%rsp), %rdi
callq 0x16063
leaq 0x8(%rsp), %rdi
callq 0x16278
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x16288
movq 0x8(%rsp), %rdi
callq 0x160a1
leaq 0x8(%rsp), %rdi
callq 0x162a2
leaq 0x10(%rsp), %rdi
callq 0x162b2
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x162a2
jmp 0x16176
jmp 0x16170
movq %rdx, %r14
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x16278
jmp 0x16176
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x162b2
jmp 0x16188
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x161dd
movq %rbx, %rdi
callq 0x16840
movq %rax, %rbx
leaq 0xdf140(%rip), %rdi     # 0xf52e0
leaq 0xa3ea6(%rip), %rsi     # 0xba04d
callq 0x80810
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x80810
movq %rax, %rdi
callq 0x800f0
callq 0x168b0
jmp 0x16140
movq %rax, %rbx
callq 0x168b0
movq %rbx, %rdi
callq 0xb71c0
movq %rax, %rdi
callq 0x162c2
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpl $0x2, %edi
jne 0x110263
movq 0x8(%rsi), %rdi
callq 0x10e180
movslq %eax, %rbx
jmp 0x110266
pushq $0x5
popq %rbx
movq %rbx, %r14
subq $0x1, %r14
jb 0x110276
callq 0x110375
jmp 0x110269
leaq 0x130468(%rip), %rdi    # 0x2406e5
callq 0x10e520
subq $0x1, %rbx
jb 0x11028f
callq 0x1106e5
jmp 0x110282
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/pair.cc
// Function: preliminaries(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>>>>&)
void preliminaries(vector<string>& v)
{
	// process v
	istream_iterator<string> input(cin), eof;
	copy(input, eof, back_inserter(v));
	sort(v.begin(), v.end(),
		 [](const string& a, const string& b)
		 { return a.size() < b.size(); });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %r14
movq 0x3b48(%rip), %rsi      # 0x4fe0
leaq -0xe0(%rbp), %r15
movq %r15, %rdi
callq 0x1e16
leaq -0xa8(%rbp), %rbx
andq $0x0, -0x8(%rbx)
leaq -0x98(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
movb %cl, 0x10(%rax)
leaq -0x80(%rbp), %rdi
movq %r15, %rsi
callq 0x1f3c
leaq -0x50(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1f3c
leaq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq %r14, %rdx
callq 0x1e56
leaq -0x48(%rbp), %rdi
callq 0x1070
leaq -0x78(%rbp), %rdi
callq 0x1070
movq (%r14), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
je 0x1572
movq %r14, %r12
subq %r15, %r12
movq %r12, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1883
cmpq $0x201, %r12            # imm = 0x201
jl 0x1567
leaq 0x200(%r15), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1c18
cmpq %r14, %r12
je 0x1572
movq %r12, %rdi
callq 0x1ca7
addq $0x20, %r12
jmp 0x1554
movq %r15, %rdi
movq %r14, %rsi
callq 0x1c18
movq %rbx, %rdi
callq 0x1070
leaq -0xd8(%rbp), %rdi
callq 0x1070
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x1070
jmp 0x15a7
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x1070
jmp 0x15b5
movq %rax, %r14
movq %rbx, %rdi
callq 0x1070
leaq -0xd8(%rbp), %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpq %rsi, (%rax)
je 0x15f9
movl -0x18(%rsi), %r14d
addq $-0x20, %rsi
movq %rbx, %rdi
callq 0x1140
jmp 0x160c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $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_O2/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 %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpq %rsi, (%rax)
je 0x1661
movq -0x18(%rsi), %r15
addq $-0x20, %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x1140
movq %r15, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f68
movq %r14, %rdi
callq 0x1070
jmp 0x1675
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
andl $0x0, 0x20(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpq %rsi, (%rax)
je 0x16ab
movl -0x18(%rsi), %r14d
addq $-0x20, %rsi
movq %rbx, %rdi
callq 0x1140
jmp 0x16be
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $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_O2/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/pair.cc
// Function: main
int main()
{
	vector<string> v;
	string s;
	while (cin >> s)
		v.push_back(s);

	preliminaries(v);  // sort v into size order

	// all three output statements should be the same
	auto biggest = process(v);
	cout << biggest.first << " " << biggest.second << endl;
	biggest = process2(v);
	cout << biggest.first << " " << biggest.second << endl;
	biggest = process3(v);
	cout << biggest.first << " " << biggest.second << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rbx
andq $0x0, 0x10(%rbx)
leaq -0x68(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movaps %xmm0, (%rbx)
movb $0x0, (%rax)
movq 0x38e0(%rip), %r14      # 0x4fe0
leaq -0x78(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1120
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x172a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f86
jmp 0x1704
leaq -0x30(%rbp), %rdi
callq 0x147c
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x15d1
movq 0x3889(%rip), %rdi      # 0x4fd0
leaq -0x58(%rbp), %rsi
callq 0x10d0
leaq 0x18d3(%rip), %rsi      # 0x302a
movq %rax, %rdi
callq 0x10e0
movl -0x38(%rbp), %esi
movq %rax, %rdi
callq 0x1180
movq %rax, %rdi
callq 0x1080
leaq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1618
leaq -0x58(%rbp), %rbx
leaq -0xa0(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fc2
movq %r14, %rdi
callq 0x1070
movq 0x3829(%rip), %rdi      # 0x4fd0
movq %rbx, %rsi
callq 0x10d0
leaq 0x1874(%rip), %rsi      # 0x302a
movq %rax, %rdi
callq 0x10e0
movl -0x38(%rbp), %esi
movq %rax, %rdi
callq 0x1180
movq %rax, %rdi
callq 0x1080
leaq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1683
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fc2
movq %r14, %rdi
callq 0x1070
movq 0x37d5(%rip), %rdi      # 0x4fd0
movq %rbx, %rsi
callq 0x10d0
leaq 0x1820(%rip), %rsi      # 0x302a
movq %rax, %rdi
callq 0x10e0
movl -0x38(%rbp), %esi
movq %rax, %rdi
callq 0x1180
movq %rax, %rdi
callq 0x1080
leaq -0x58(%rbp), %rdi
callq 0x1070
leaq -0x78(%rbp), %rdi
callq 0x1070
leaq -0x30(%rbp), %rdi
callq 0x1fe4
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1858
jmp 0x1858
jmp 0x1866
jmp 0x1866
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x1070
jmp 0x1869
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x1070
leaq -0x30(%rbp), %rdi
callq 0x1fe4
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/vianna274[P]dropbox/client.cpp
// Function: getArguments[abi:cxx11]()
vector<string> getArguments(){
	string input;
	cout << "> ";
	getline(cin, input);
	input.erase(std::remove(input.begin(), input.end(), '\n'), input.end());
	vector<string> arguments;
	boost::split(arguments, input, [](char c){return c == ' ';});
	return arguments;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x821a(%rip), %rdi      # 0x14fc0
leaq 0x2875(%rip), %rsi      # 0xf622
callq 0x4370
movq 0x8227(%rip), %rdi      # 0x14fe0
leaq -0x50(%rbp), %rsi
callq 0x4090
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq %rdi, %rsi
leaq -0x1a0(%rbp), %rdx
movb $0xa, (%rdx)
callq 0xd67b
leaq -0x50(%rbp), %rdi
movq (%rdi), %rdx
addq 0x8(%rdi), %rdx
movq %rax, %rsi
callq 0x40b0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
leaq (%rax,%rcx), %rdx
movabsq $0x100000000, %rsi      # imm = 0x100000000
movq %rsi, -0x90(%rbp)
leaq 0x7df3(%rip), %rsi      # 0x14c11
movq %rsi, -0x98(%rbp)
movq %rax, -0x78(%rbp)
movq %rax, -0x70(%rbp)
movq %rax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movb $0x0, -0x58(%rbp)
testq %rcx, %rcx
je 0xce4a
leaq -0x98(%rbp), %rdi
callq 0xd86c
leaq -0x1a0(%rbp), %r14
leaq -0x98(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xd7e8
leaq -0x98(%rbp), %rdi
callq 0xdd6e
leaq -0x238(%rbp), %r13
andq $0x0, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r13)
movups %xmm0, 0x30(%r13)
movb $0x1, 0x40(%r13)
leaq -0x1f0(%rbp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0xd7e8
leaq -0x238(%rbp), %rdi
callq 0xdd6e
leaq -0x150(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xd7e8
leaq -0x100(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0xd7e8
leaq -0xb0(%rbp), %rdi
leaq -0x150(%rbp), %rsi
leaq -0x100(%rbp), %rdx
leaq -0x29(%rbp), %rcx
callq 0xd74a
leaq -0x100(%rbp), %rdi
callq 0xdd6e
leaq -0x150(%rbp), %rdi
callq 0xdd6e
leaq -0xb0(%rbp), %rdi
movq (%rdi), %rax
movq %rax, (%rbx)
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0xb146
leaq -0x1f0(%rbp), %rdi
callq 0xdd6e
leaq -0x1a0(%rbp), %rdi
callq 0xdd6e
leaq -0x50(%rbp), %rdi
callq 0x41b0
movq %rbx, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq -0x98(%rbp), %rdi
jmp 0xcfb6
movq %rax, %r15
leaq -0x100(%rbp), %rdi
callq 0xdd6e
jmp 0xcf8a
movq %rax, %r15
leaq -0x150(%rbp), %rdi
callq 0xdd6e
jmp 0xcfa3
movq %rax, %r15
jmp 0xcfa3
movq %rax, %r15
movq %r13, %r12
movq %r12, %rdi
callq 0xdd6e
jmp 0xcfb3
movq %rax, %r15
movq %r12, %r14
movq %r14, %rdi
callq 0xdd6e
movq %rbx, %rdi
callq 0xb146
jmp 0xcfcc
jmp 0xcfc9
jmp 0xcfc9
movq %rax, %r15
leaq -0x50(%rbp), %rdi
callq 0x41b0
movq %r15, %rdi
callq 0x4600
// File: /workspace/github_cpp_makefile_star2_O2/legendddhgf[P]Text2RPG/common.cpp
// Function: stringTrim(char*, char const*, char*)
void stringTrim (char *s, const char *trim, char *ret) {
  size_t i = 0;
  // first pass skips front
  while (i < strlen(s)) { // sufficient condition because srlen decreases
    if (strchr(trim, s[i]) == nullptr) {
      break; // if beginning doesn't need to be trimmed anymore
    }
    i++;
  }
  // second pass puts the rest of s in ret
  strncpy(ret, s + i, strlen(s + i) + 1); //copy the null character too

  // third pass trims back of ret
  for (int i = strlen(ret) - 1; i >= 0; i--) {
    if (strchr(trim, ret[i]) == nullptr) {
      ret[i + 1] = '\0'; // trim everything after this character
      break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x20b0
movq %rax, %r12
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x240d
movsbl (%r15,%r13), %esi
movq %r14, %rdi
callq 0x2080
testq %rax, %rax
je 0x240a
incq %r13
jmp 0x23ee
movq %r13, %r12
addq %r12, %r15
movq %r15, %rdi
callq 0x20b0
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20e0
movq %rbx, %rdi
callq 0x20b0
movl %eax, %r15d
incq %r15
leaq -0x2(%r15), %rax
testl %eax, %eax
js 0x245d
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movsbl (%rbx,%rax), %esi
movq %r14, %rdi
callq 0x2080
decq %r15
testq %rax, %rax
jne 0x2435
movl %r15d, %eax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x58, %rsp
movq %rdx, %r14
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
leaq 0x4d89(%rip), %rsi      # 0x7217
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %r12
movq %r12, %rdx
callq 0x2090
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x20b0
cmpq %rax, %r13
jae 0x2512
movsbl (%r15,%r13), %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x2080
testq %rax, %rax
je 0x24ff
cmpq $0x0, -0x50(%rbp)
je 0x250d
movq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2556
movq %r12, %rdi
leaq 0x4d37(%rip), %rsi      # 0x7217
leaq -0x29(%rbp), %rdx
callq 0x2090
leaq -0x58(%rbp), %rdi
movq %r12, %rsi
callq 0x21f0
movq %r12, %rdi
callq 0x20d0
jmp 0x250d
leaq -0x58(%rbp), %rdi
pushq $0x1
popq %rsi
movl %ebx, %edx
callq 0x2190
incq %r13
jmp 0x24a1
cmpq $0x0, -0x50(%rbp)
je 0x2526
leaq -0x58(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x2556
leaq -0x58(%rbp), %rdi
callq 0x20d0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2542
jmp 0x2542
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq 0x877f(%rip), %r12      # 0xafe0
movq (%r12), %rdi
movq (%rsi), %rdx
leaq 0x47d9(%rip), %rsi      # 0x7048
xorl %eax, %eax
callq 0x2230
movq (%r12), %rcx
leaq 0x47dd(%rip), %rdi      # 0x705e
pushq $0x11
popq %rsi
pushq $0x1
popq %rdx
callq 0x22b0
movq 0x50(%r14), %rbx
movq 0x58(%r14), %r13
leaq -0x48(%rbp), %r14
leaq 0x47d1(%rip), %r15      # 0x7070
cmpq %r13, %rbx
je 0x28cf
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2220
movq (%r12), %rdi
movq -0x48(%rbp), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x2230
movq %r14, %rdi
callq 0x20d0
addq $0x20, %rbx
jmp 0x289f
pushq $0x1
popq %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq 0x86ed(%rip), %r12      # 0xafe0
movq (%r12), %rdi
movq (%rsi), %rdx
leaq 0x4774(%rip), %rsi      # 0x7075
xorl %eax, %eax
callq 0x2230
movq (%r12), %rcx
leaq 0x474b(%rip), %rdi      # 0x705e
pushq $0x11
popq %rsi
pushq $0x1
popq %rdx
callq 0x22b0
movq 0x50(%r14), %rbx
movq 0x58(%r14), %r13
leaq -0x48(%rbp), %r14
leaq 0x473f(%rip), %r15      # 0x7070
cmpq %r13, %rbx
je 0x2961
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2220
movq (%r12), %rdi
movq -0x48(%rbp), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x2230
movq %r14, %rdi
callq 0x20d0
addq $0x20, %rbx
jmp 0x2931
pushq $0x1
popq %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3b64
testq %rax, %rax
je 0x2c4d
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b92
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2220
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x838c(%rip), %rax      # 0xafe0
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0x4436(%rip), %rsi      # 0x7097
xorl %eax, %eax
callq 0x2230
pushq $0x1
popq %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/legendddhgf[P]Text2RPG/main.cpp
// Function: main
int main (int argc, char **argv) {
  ArgParser *parser = new ArgParser();
  parser->SetExpected({string("infile"), string("config")});
  parser->ArgParse(argc, argv);
  // open files
  string infile = parser->GetTarget(string("infile"));
  FILE *fp = fopen(infile.c_str(), "r");
  if (fp == nullptr) {
    fprintf(stderr, "%s: File not found\n", infile.c_str());
    exit(1);
  }
  GameEngine *game = new GameEngine(fp);

  // end
  delete game;
  delete parser;
  fclose(fp);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movl %edi, %r15d
pushq $0x68
popq %rdi
callq 0x2180
movq %rax, %rbx
movq %rax, %rdi
callq 0x27b0
leaq 0x138f(%rip), %rsi      # 0x75b9
leaq -0x68(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x2090
leaq -0x48(%rbp), %rdi
leaq 0x137e(%rip), %rsi      # 0x75c0
leaq -0x23(%rbp), %rdx
callq 0x2090
leaq -0x80(%rbp), %rdi
leaq -0x68(%rbp), %rsi
pushq $0x2
popq %rdx
leaq -0x22(%rbp), %rcx
callq 0x63da
leaq -0x80(%rbp), %rsi
movq %rbx, %rdi
callq 0x2cea
leaq -0x80(%rbp), %rdi
callq 0x2d80
pushq $0x20
popq %r12
leaq (%r12,%rbp), %rdi
addq $-0x68, %rdi
callq 0x20d0
addq $-0x20, %r12
cmpq $-0x20, %r12
jne 0x6278
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x296a
leaq 0x1315(%rip), %rsi      # 0x75b9
leaq -0xa0(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x2090
leaq -0x68(%rbp), %rdi
leaq -0xa0(%rbp), %rdx
movq %rbx, %rsi
callq 0x2c02
leaq -0xa0(%rbp), %rdi
callq 0x20d0
movq -0x68(%rbp), %rdi
leaq 0x12e9(%rip), %rsi      # 0x75c7
callq 0x21c0
testq %rax, %rax
je 0x6346
movq %rax, %r14
movl $0x150, %edi            # imm = 0x150
callq 0x2180
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x3bb4
movq %r15, %rdi
callq 0x6414
movq %r15, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x6462
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2170
leaq -0x68(%rbp), %rdi
callq 0x20d0
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x4c93(%rip), %rax      # 0xafe0
movq (%rax), %rdi
movq -0x68(%rbp), %rdx
leaq 0x126e(%rip), %rsi      # 0x75c9
xorl %eax, %eax
callq 0x2230
pushq $0x1
popq %rdi
callq 0x21e0
movq %rax, %r14
movq %r15, %rdi
callq 0x2160
jmp 0x63b7
jmp 0x63b4
movq %rax, %r14
leaq -0xa0(%rbp), %rdi
jmp 0x63bb
jmp 0x63c2
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x2d80
jmp 0x6398
movq %rax, %r14
pushq $0x20
popq %rbx
leaq (%rbx,%rbp), %rdi
addq $-0x68, %rdi
callq 0x20d0
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0x639b
jmp 0x63d2
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x20d0
jmp 0x63d2
movq %rax, %r14
jmp 0x63d2
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/sfl2pts/sfl2pts.cpp
// Function: ComparePlyPoints(void const*, void const*)
static int
ComparePlyPoints(const void *data1, const void *data2)
{
  // Sort by confidence
  PlyPoint *point1 = *((PlyPoint **) data1);
  PlyPoint *point2 = *((PlyPoint **) data2);
  unsigned char c1 = point1->confidence;
  unsigned char c2 = point2->confidence;
  if (c1 > c2) return -1;
  else if (c2 > c1) return 1;
  else return 0;
}

// Assembly:
movq (%rdi), %rax
cvttss2si 0x1c(%rax), %eax
movq (%rsi), %rcx
cvttss2si 0x1c(%rcx), %ecx
xorl %edx, %edx
cmpb %al, %cl
seta %dl
pushq $-0x1
popq %rax
cmovael %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/enferex[P]fnplot/cs.cc
// Function: CS::CS(char const*)
CS::CS(const char *fname)
{
    FILE *fp;
    uint8_t *data;
    struct stat st;

    if (!(fp = fopen(fname, "r")))
      throw("Could not open cscope database file");

    // mmap the input cscope database
    fstat(fileno(fp), &st);
    data = (uint8_t *)mmap(NULL, st.st_size,
                           PROT_READ, MAP_PRIVATE, fileno(fp), 0);
    if (!data)
      throw("Error memory maping cscope database");

    // Initialize the data
    initHeader(data, st.st_size);
    initTrailer(data, st.st_size);
    initSymbols(data, st.st_size);

    // Done loading data
    munmap(data, st.st_size);
    fclose(fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rax
movq %rdi, %r15
leaq 0x60(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rdi)
andq $0x0, 0x70(%rdi)
leaq 0x2aeb(%rip), %rsi      # 0x5210
movq %rax, %rdi
callq 0x2210
testq %rax, %rax
je 0x27c6
movq %rax, %r14
movq %rax, %rdi
callq 0x21f0
movq %rsp, %r12
movl %eax, %edi
movq %r12, %rsi
callq 0x2300
movq 0x30(%r12), %r12
movq %r14, %rdi
callq 0x21f0
pushq $0x1
popq %rdx
pushq $0x2
popq %rcx
xorl %edi, %edi
movq %r12, %rsi
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x2330
testq %rax, %rax
je 0x27cf
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x2806
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x293e
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2a38
movq %r13, %rdi
movq %r12, %rsi
callq 0x2150
movq %r14, %rdi
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21c0
leaq 0x2a45(%rip), %r14      # 0x5212
jmp 0x27d6
leaq 0x2a60(%rip), %r14      # 0x5236
pushq $0x8
popq %rdi
callq 0x2120
movq %r14, (%rax)
movq 0x57d8(%rip), %rsi      # 0x7fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x2310
movq %rax, %r14
movq %rbx, %rdi
callq 0x4488
movq %r14, %rdi
callq 0x2320
nop