LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::incrby(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long)
int64_t Redis::incrby(const std::string& key, int64_t incr)
{
    int64_t ret = 0;
    std::string cmd =  "INCRBY " + key + " " + num2str<int64_t>(incr);
    execReplyInt(cmd, ret);
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rdx, 0x70(%rsp)
movq $0x0, 0x8(%rsp)
leaq 0xdc4a(%rip), %rsi      # 0x1417b
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0xa756
leaq 0xe6aa(%rip), %rsi      # 0x14bf2
movq %r14, %rdi
callq 0x3600
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6577
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
jmp 0x657e
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x38(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rdx
movq %rbx, %rsi
callq 0xa7d8
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x58(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r14, %rcx
je 0x65ca
movq 0x40(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x65e9
leaq 0x60(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x65e4
movq 0x60(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x65fa
movq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x3110
jmp 0x6608
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33e0
leaq 0x20(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x662c
movq %rsi, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x6632
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6662
callq 0x3350
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x6671
callq 0x3350
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6687
callq 0x3350
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x4910
movq 0x8(%rsp), %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x66b1
callq 0x3350
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
jmp 0x6700
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x66e4
callq 0x3350
jmp 0x66e4
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x66f8
callq 0x3350
jmp 0x66f8
movq %rax, %rbx
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x670e
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::incrbyfloat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, float)
float Redis::incrbyfloat(const std::string& key, float incr)
{
    float ret  = 0;
    std::string cmd =  "INCRBYFLOAT " + key + " " + num2str<float>(incr);
    std::string s;
    if (execReplyString(cmd, s))
    {
        ret = str2num<float>(s);
        return ret;
    }
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
movss %xmm0, 0x4(%rsp)
leaq 0xda17(%rip), %rsi      # 0x1414a
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0xa756
leaq 0xe4ab(%rip), %rsi      # 0x14bf2
movq %r14, %rdi
callq 0x3600
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6776
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x677d
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x48(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movq %rbx, %rsi
callq 0xaa7a
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x50(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r14, %rcx
je 0x67c9
movq 0x18(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x67e8
leaq 0x58(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x67e3
movq 0x58(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x67f9
movq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x3110
jmp 0x6807
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33e0
leaq 0x38(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x682b
movq %rsi, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x6831
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6861
callq 0x3350
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x6870
callq 0x3350
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6883
callq 0x3350
leaq 0x8(%rsp), %rdx
movq %r14, (%rdx)
movq $0x0, 0x8(%rdx)
movb $0x0, 0x10(%rdx)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x5d5e
xorps %xmm0, %xmm0
testb %al, %al
je 0x68b8
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xab2e
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
movss %xmm0, (%rsp)
je 0x68d1
callq 0x3350
movss (%rsp), %xmm0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x68e9
callq 0x3350
movss (%rsp), %xmm0
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x690f
callq 0x3350
jmp 0x690f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x6923
callq 0x3350
jmp 0x6923
movq %rax, %rbx
leaq 0x78(%rsp), %rax
jmp 0x6941
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x693c
callq 0x3350
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x694f
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::decr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int64_t Redis::decr(const std::string& key)
{
    int64_t ret = 0;
    std::string cmd =  "DECR " + key;
    execReplyInt(cmd, ret);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
leaq 0xd7dd(%rip), %rsi      # 0x14157
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xa756
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4910
movq 0x8(%rsp), %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x69ad
callq 0x3350
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x69d0
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::decrby(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long)
int64_t Redis::decrby(const std::string& key, int64_t decr)
{
    int64_t ret = 0;
    std::string cmd =  "DECRBY " + key + " " + num2str<int64_t>(decr);
    execReplyInt(cmd, ret);
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rdx, 0x70(%rsp)
movq $0x0, 0x8(%rsp)
leaq 0xd760(%rip), %rsi      # 0x1415d
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0xa756
leaq 0xe1de(%rip), %rsi      # 0x14bf2
movq %r14, %rdi
callq 0x3600
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6a43
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
jmp 0x6a4a
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x38(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rdx
movq %rbx, %rsi
callq 0xa7d8
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x58(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r14, %rcx
je 0x6a96
movq 0x40(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x6ab5
leaq 0x60(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x6ab0
movq 0x60(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x6ac6
movq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x3110
jmp 0x6ad4
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33e0
leaq 0x20(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x6af8
movq %rsi, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x6afe
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b2e
callq 0x3350
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x6b3d
callq 0x3350
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b53
callq 0x3350
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x4910
movq 0x8(%rsp), %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b7d
callq 0x3350
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
jmp 0x6bcc
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6bb0
callq 0x3350
jmp 0x6bb0
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x6bc4
callq 0x3350
jmp 0x6bc4
movq %rax, %rbx
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6bda
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::zcard(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int64_t Redis::zcard(const std::string& key)
{
    int64_t ret = -1;
    std::string cmd =  "ZCARD " + key;
    execReplyInt(cmd, ret);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $-0x1, (%r14)
leaq 0xd359(%rip), %rsi      # 0x1416b
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xa756
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4910
movq 0x8(%rsp), %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6e45
callq 0x3350
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6e68
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::zscore(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Redis::zscore(const std::string& key, const std::string& member)
{
    std::string score;
    std::string cmd = "ZSCORE " + key + " " + member;
    execReplyString(cmd, score);
    return score;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0xbb09(%rip), %rsi      # 0x141c5
leaq 0x40(%rsp), %rdi
callq 0xa756
leaq 0xc525(%rip), %rsi      # 0x14bf2
leaq 0x40(%rsp), %rdi
callq 0x3600
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x86fe
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x8706
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
callq 0x3110
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x8754
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x875b
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x8782
callq 0x3350
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8795
callq 0x3350
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5d5e
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x87b1
callq 0x3350
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x87f5
jmp 0x87ff
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x87e7
callq 0x3350
jmp 0x87e7
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x87ff
callq 0x3350
jmp 0x87ff
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x880c
callq 0x3350
movq %r14, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::exec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Redis::exec(const std::string& cmd)
{
    if(_context==NULL) 
    {
        return false;
    }
    redisReply* _reply = (redisReply*)::redisCommand(_context, cmd.c_str());
    if(isError(_reply))
    {
        freeReply(_reply);
        return false;
    }
    return true;
}

// Assembly:
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x984f
pushq %rax
movq (%rsi), %rsi
xorl %eax, %eax
callq 0xe300
testq %rax, %rax
setne %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::hmget(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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>>>> const&, 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>>>>&)
bool Redis::hmget(const std::string& key, const std::vector<std::string> & fields, std::vector<std::string> & values)
{
    if(_context == NULL) 
    {
        return false;
    }
    values.clear();
    std::string cmd = "HMGET " + key;
    for(uint32_t i = 0; i < fields.size(); ++i)
    {
        cmd = cmd + " " + fields[i];
    }
    return exec(cmd, values);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
cmpq $0x0, 0x8(%rdi)
je 0x99b0
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rcx, %rdi
callq 0xa88a
leaq 0xa958(%rip), %rsi      # 0x141e2
leaq 0x38(%rsp), %rdi
movq %rbx, %rdx
callq 0xa756
movq 0x8(%r15), %rax
cmpq (%r15), %rax
je 0x9985
leaq 0x68(%rsp), %r14
movl $0x1, %r13d
leaq 0x28(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x58(%rsp), %r12
movq %r14, 0x58(%rsp)
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0xacf4
movq %r12, %rdi
leaq 0xb313(%rip), %rsi      # 0x14bf2
callq 0x3600
movq (%r15), %rax
shlq $0x5, %rbx
movq (%rax,%rbx), %rsi
movq 0x8(%rax,%rbx), %rdx
movq %r12, %rdi
callq 0x3110
movq %rbp, 0x18(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x991f
movq %rdx, 0x18(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x28(%rsp)
jmp 0x9926
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
movq %rdx, 0x20(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3440
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0x995c
callq 0x3350
movq 0x58(%rsp), %rdi
cmpq %r14, %rdi
je 0x996b
callq 0x3350
movq 0x8(%r15), %rax
subq (%r15), %rax
movl %r13d, %ebx
sarq $0x5, %rax
incl %r13d
cmpq %rbx, %rax
ja 0x98bb
leaq 0x38(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0x4548
movl %eax, %ebx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x99b2
callq 0x3350
jmp 0x99b2
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x99c5
movq %rax, %rbx
jmp 0x99de
jmp 0x99cc
movq %rax, %rbx
movq 0x58(%rsp), %rdi
cmpq %r14, %rdi
je 0x99de
callq 0x3350
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x99f1
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/./credis.h
// Function: int Redis::str2num<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
T str2num(const std::string& str)
    {
        std::stringstream ss;
        T num;
        ss << str;
        ss >> num;
        return num;
    }

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x32a0
leaq 0x18(%rsp), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x33f0
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x3250
movl 0x4(%rsp), %ebx
movq 0xf58a(%rip), %rsi      # 0x19fb8
leaq 0x8(%rsp), %rdi
callq 0x32c0
leaq 0x88(%rsp), %rdi
callq 0x3130
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
movq 0xf55e(%rip), %rsi      # 0x19fb8
leaq 0x8(%rsp), %rdi
callq 0x32c0
leaq 0x88(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x35b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/redis_connect_pool.cpp
// Function: RedisConnectPool::~RedisConnectPool()
RedisConnectPool::~RedisConnectPool()
{
    {
	MutexGuard guard(&_mutex);
	list<redisContext*>::iterator it = _connectPool.begin();
	list<redisContext*>::iterator itEnd = _connectPool.end();
	for (; it != itEnd; ++it)
	{
	    //if(*it != NULL)
            {
                redisFree(*it);
                *it = NULL;
            }
	}
	_connectPool.clear();
    }

	pthread_mutex_destroy(&_mutex);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x68(%rdi), %r14
movq %r14, %rdi
callq 0x34b0
leaq 0x50(%rbx), %r15
movq 0x50(%rbx), %r12
cmpq %r15, %r12
je 0xb62d
movq 0x10(%r12), %rdi
callq 0xd540
movq $0x0, 0x10(%r12)
movq (%r12), %r12
jmp 0xb60f
movq (%r15), %rdi
cmpq %r15, %rdi
je 0xb645
movq (%rdi), %r12
callq 0x3350
movq %r12, %rdi
cmpq %r15, %r12
jne 0xb635
movq %r15, 0x58(%rbx)
movq %r15, 0x50(%rbx)
movq $0x0, 0x60(%rbx)
movq %r14, %rdi
callq 0x32e0
movq %r14, %rdi
callq 0x3410
movq 0x50(%rbx), %rdi
cmpq %r15, %rdi
je 0xb67e
movq (%rdi), %r14
callq 0x3350
movq %r14, %rdi
cmpq %r15, %r14
jne 0xb66e
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0xb690
callq 0x3350
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
addq $0x8, %rsp
cmpq %rbx, %rdi
je 0xb6ad
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3350
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0xa74b
nop
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/redis_connect_pool.cpp
// Function: RedisConnectPool::init(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool RedisConnectPool::init(int iPoolSize, const string& redisIP, int redisPort, const string& passwd)
{
    MutexGuard guard(&_mutex);    
    _redisIP = redisIP;
    _redisProt = redisPort;
    _passwd = passwd;
    _iPoolSize = iPoolSize;
    _iUsedCount = 0;
    _needPasswd = true;
    return initConnectPool();   
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
leaq 0x68(%rdi), %rbx
movq %rbx, %rdi
callq 0x34b0
leaq 0x8(%r14), %rdi
movq %r13, %rsi
callq 0x3200
movl %r12d, 0x48(%r14)
leaq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x3200
movl %ebp, (%r14)
movl $0x0, 0x4(%r14)
movb $0x1, 0x90(%r14)
movq %r14, %rdi
callq 0xb746
movq %rbx, %rdi
callq 0x32e0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x32e0
movq %r14, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/redis_connect_pool.cpp
// Function: RedisConnectPool::initConnectPool()
bool RedisConnectPool::initConnectPool()
{
	for (int i = 0; i < _iPoolSize; ++i)
	{
	    redisContext *redisConn = connect();
            if(redisConn)
            {
    	        _connectPool.push_back(redisConn);
            }
        }
	
	return true;
}

// Assembly:
cmpl $0x0, (%rdi)
jle 0xb798
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x50(%rdi), %r14
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0xb79c
testq %rax, %rax
je 0xb788
movq %rax, %r15
movl $0x18, %edi
callq 0x3380
movq %r15, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3070
incq 0x60(%rbx)
incl %ebp
cmpl (%rbx), %ebp
jl 0xb75b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/redis_connect_pool.cpp
// Function: RedisConnectPool::reConnect(redisContext*&)
bool RedisConnectPool::reConnect(redisContext* &redisConn)
{
    if(redisConn)
    {
	redisFree(redisConn);
        redisConn = NULL;
    }
	redisConn = connect();
    if(redisConn == NULL)
        return false;
    
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xb988
callq 0xd540
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0xb79c
movq %rax, (%rbx)
testq %rax, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/redis_connect_pool.cpp
// Function: RedisConnectPool::getConnect()
redisContext * RedisConnectPool::getConnect()
{
	redisContext *retConn = NULL;
	MutexGuard guard(&_mutex);    
	{
		if (_connectPool.empty())
		{
			return retConn;
		}
		else
		{
		    retConn = _connectPool.front();
		    _connectPool.pop_front();
                    _iUsedCount++;
		}
	}

	if (retConn == NULL)
	{
		reConnect(retConn);
	}

	return retConn;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x68(%rdi), %rbx
movq %rbx, %rdi
callq 0x34b0
leaq 0x50(%r15), %rax
movq 0x50(%r15), %r12
cmpq %rax, %r12
je 0xb9f5
movq 0x10(%r12), %r14
decq 0x60(%r15)
movq %r12, %rdi
callq 0x3540
movq %r12, %rdi
callq 0x3350
incl 0x4(%r15)
testq %r14, %r14
jne 0xb9f8
movq %r15, %rdi
callq 0xb79c
movq %rax, %r14
jmp 0xb9f8
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x32e0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x32e0
movq %r14, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/redis_connect_pool.cpp
// Function: RedisConnectPool::getConnect(int)
redisContext * RedisConnectPool::getConnect(int retry)
{
    redisContext * context = getConnect();
    while(context == NULL && retry-->0)
    {
        context = getConnect();
    }
    if(context == NULL)
    {
        return NULL;
    }

    return context;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
callq 0xb9a2
testq %rax, %rax
setne %cl
testl %r14d, %r14d
setle %dl
orb %cl, %dl
jne 0xba5b
movq %rbx, %rdi
callq 0xb9a2
testq %rax, %rax
jne 0xba5b
leal -0x1(%r14), %ecx
cmpl $0x1, %r14d
movl %ecx, %r14d
jg 0xba41
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/redis_connect_pool.cpp
// Function: RedisConnectPool::releaseConnect(redisContext*)
void RedisConnectPool::releaseConnect(redisContext *redisConn)
{
    if(redisConn == NULL)
        return ;
    if(find(_connectPool.begin(), _connectPool.end(), redisConn) != _connectPool.end())
    {
        return;
    }
    MutexGuard guard(&_mutex);    
	if(redisConn != NULL)
    {
            if(redisConn->err)
            {
                if (!reConnect(redisConn)) 
                {
                    return;
                }
            }
        if(isUseful(redisConn))
        {
	        _connectPool.push_back(redisConn);
            _iUsedCount--;
        }
	}

	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
testq %rsi, %rsi
je 0xba98
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x50(%rdi), %r14
movq 0x50(%rdi), %rax
cmpq %r14, %rax
je 0xba93
cmpq %r12, 0x10(%rax)
je 0xba93
movq (%rax), %rax
jmp 0xba83
cmpq %r14, %rax
je 0xbaa4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x68(%rbx), %r15
movq %r15, %rdi
callq 0x34b0
cmpl $0x0, (%r12)
je 0xbad8
movq %r12, %rdi
callq 0xd540
movq $0x0, (%rsp)
movq %rbx, %rdi
callq 0xb79c
movq %rax, (%rsp)
testq %rax, %rax
je 0xbb08
movq %rsp, %rsi
callq 0xbb2e
testb %al, %al
je 0xbb08
movl $0x18, %edi
callq 0x3380
movq (%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3070
incq 0x60(%rbx)
decl 0x4(%rbx)
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x32e0
movq %rax, %rbx
movq %r15, %rdi
callq 0x32e0
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/Sherhang[P]redis-for-cpp/redis_connect_pool.cpp
// Function: RedisConnectPool::isUseful(redisContext*&)
bool RedisConnectPool::isUseful(redisContext* &redisConn)
{
	if (NULL == redisConn)
	{
		return false;
	}
    
	bool bPingRet = true;
	string command = "PING";
	redisReply *reply = (redisReply*)redisCommand(redisConn, command.c_str());
	if (reply == NULL && redisConn->err != 0)
	{
		bPingRet = false;
	}

	if (reply->type == REDIS_REPLY_STATUS)
	{
		string strRet = reply->str;
		if (strRet.find("PONG") != string::npos)
		{
			freeReplyObject(reply);
            reply = NULL;
		}
	}
    if(reply)
    {
	    freeReplyObject(reply);
        reply = NULL;
    }
	
	return bPingRet;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, (%rsi)
je 0xbbfe
movq %rsi, %r15
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8565(%rip), %rsi      # 0x140bc
leaq 0x8562(%rip), %rdx      # 0x140c0
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x42a6
movq (%r15), %rdi
movq (%rbx), %rsi
xorl %eax, %eax
callq 0xe300
movq %rax, %r14
movb $0x1, %bl
testq %rax, %rax
jne 0xbb8b
movq (%r15), %rax
cmpl $0x0, (%rax)
sete %bl
cmpl $0x5, (%r14)
jne 0xbbe0
movq 0x18(%r14), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3170
leaq 0x8516(%rip), %rsi      # 0x140c1
leaq 0x8(%rsp), %rdi
movl $0x4, %ecx
xorl %edx, %edx
callq 0x35a0
cmpq $-0x1, %rax
je 0xbbcd
movq %r14, %rdi
callq 0xbc50
xorl %r14d, %r14d
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbbe0
callq 0x3350
testq %r14, %r14
je 0xbbed
movq %r14, %rdi
callq 0xbc50
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xbc00
callq 0x3350
jmp 0xbc00
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbc2b
callq 0x3350
jmp 0xbc2b
jmp 0xbc28
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xbc3a
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-cli/machine-connection.cc
// Function: OpenTCPSocket(char const*)
int OpenTCPSocket(const char *host) {
    char *host_copy = NULL;
    const char *port = "8888";
    const char *colon_pos;
    if ((colon_pos = strchr(host, ':')) != NULL) {
        port = colon_pos + 1;
        host_copy = strdup(host);
        host_copy[colon_pos - host] = '\0';
        host = host_copy;
    }
    struct addrinfo addr_hints = {};
    addr_hints.ai_family = AF_INET;
    addr_hints.ai_socktype = SOCK_STREAM;

    struct addrinfo *addr_result = NULL;
    int rc;
    if ((rc = getaddrinfo(host, port, &addr_hints, &addr_result)) != 0) {
        // We're in OpenTCPSocket(), because opening as a tty failed before,
        // so make reference of that in this error message.
        fprintf(stderr,
                "Not a tty and "
                "can't resolve as TCP endpoint '%s' (port %s): %s\n",
                host, port, gai_strerror(rc));
        free(host_copy);
        return -1;
    }
    free(host_copy);
    if (addr_result == NULL) return -1;
    int fd = socket(addr_result->ai_family, addr_result->ai_socktype,
                    addr_result->ai_protocol);
    if (fd >= 0 &&
        connect(fd, addr_result->ai_addr, addr_result->ai_addrlen) < 0) {
        perror("TCP connect()");
        close(fd);
        fd = -1;
    }

    freeaddrinfo(addr_result);
    return fd;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl $0x3a, %esi
callq 0x20e0
testq %rax, %rax
je 0x2f3b
movq %rax, %r12
leaq 0x1(%rax), %r15
movq %rbx, %rdi
callq 0x2310
movq %rax, %r14
subq %rbx, %r12
movb $0x0, (%rax,%r12)
movq %rax, %rbx
jmp 0x2f45
leaq 0x1a93(%rip), %r15      # 0x49d5
xorl %r14d, %r14d
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movabsq $0x100000002, %rax      # imm = 0x100000002
movq %rax, 0x4(%rdx)
leaq 0x8(%rsp), %rcx
movq $0x0, (%rcx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2200
testl %eax, %eax
jne 0x2fca
movq %r14, %rdi
callq 0x21e0
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x2ffd
movl 0x4(%rax), %edi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2080
movl %eax, %ebx
testl %eax, %eax
js 0x2fbe
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
movl 0x10(%rax), %edx
movl %ebx, %edi
callq 0x2160
testl %eax, %eax
js 0x3010
movq 0x8(%rsp), %rdi
callq 0x2230
jmp 0x3002
movq 0x4007(%rip), %rcx      # 0x6fd8
movq (%rcx), %r12
movl %eax, %edi
callq 0x2240
leaq 0x19f8(%rip), %rsi      # 0x49da
movq %r12, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x2280
movq %r14, %rdi
callq 0x21e0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1a03(%rip), %rdi      # 0x4a1a
callq 0x2170
movl %ebx, %edi
callq 0x2330
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x2fbe
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-cli/machine-connection.cc
// Function: MachineConnection::DiscardPendingInput(int, _IO_FILE*)
int MachineConnection::DiscardPendingInput(int timeout_ms,
                                           FILE *echo_discarded) {
    if (input_fd_ < 0) return 0;
    int total_bytes = 0;
    char buf[128];
    while (AwaitReadReady(input_fd_, timeout_ms) > 0) {
        int r = read(input_fd_, buf, sizeof(buf));
        if (r < 0) {
            perror("reading trouble");
            return -1;
        }
        total_bytes += r;
        if (r > 0 && echo_discarded) {
            fwrite(buf, r, 1, echo_discarded);
        }
    }
    return total_bytes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
cmpl $0x0, 0x4(%rdi)
js 0x35b5
movq %rdx, %rbx
movq %rdi, %r14
movslq %esi, %rax
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rcx
addl %edx, %ecx
movslq %ecx, %r13
imull $0x3e8, %r13d, %ecx     # imm = 0x3E8
subl %ecx, %eax
imull $0x3e8, %eax, %eax      # imm = 0x3E8
movslq %eax, %rbp
xorl %r15d, %r15d
movl 0x4(%r14), %edi
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
leal 0x3f(%rdi), %eax
testl %edi, %edi
cmovnsl %edi, %eax
movl %eax, %edx
andl $-0x40, %edx
movl %edi, %ecx
subl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
sarl $0x6, %eax
cltq
orq %rdx, 0x10(%rsp,%rax,8)
movq %r13, (%rsp)
movq %rbp, 0x8(%rsp)
incl %edi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rsp, %r8
callq 0x2180
testl %eax, %eax
js 0x35c0
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x8(%rsp)
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x7, %rdx
addl %eax, %edx
testl %edx, %edx
jle 0x35c0
movl 0x4(%r14), %edi
movl $0x80, %edx
leaq 0x90(%rsp), %rsi
callq 0x2290
movq %rax, %r12
testl %r12d, %r12d
js 0x35a7
testq %rbx, %rbx
sete %al
addl %r12d, %r15d
testl %r12d, %r12d
sete %cl
orb %al, %cl
jne 0x359c
movl %r12d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movl $0x1, %edx
leaq 0x90(%rsp), %rdi
movq %rbx, %rcx
callq 0x2320
testl %r12d, %r12d
jns 0x34b4
jmp 0x35ba
leaq 0x147a(%rip), %rdi      # 0x4a28
callq 0x2170
jmp 0x359c
xorl %r15d, %r15d
jmp 0x35c0
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-cli/machine-connection.cc
// Function: MachineConnection::WriteBlocks(char*, std::vector<std::basic_string_view<char, std::char_traits<char>>, std::allocator<std::basic_string_view<char, std::char_traits<char>>>> const&)
bool MachineConnection::WriteBlocks(
    char *scratch_buffer, const std::vector<std::string_view> &blocks) {
    // Note: not using writev(), as snippets can be a lot and writev() has a
    // bunch of limitations (e.g. UIO_MAXIOV == 1024). Thus simply
    // reassmbling into buffer.
    char *pos = scratch_buffer;
    for (auto block : blocks) {
        memcpy(pos, block.data(), block.size());
        pos += block.size();
    }
    return reliable_write(output_fd_, scratch_buffer, pos - scratch_buffer);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %r13
movq 0x8(%rdx), %rbp
movq %rsi, %r14
cmpq %rbp, %r13
je 0x3618
movq %rbx, %r14
movq (%r13), %r12
movq 0x8(%r13), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x2150
addq %r12, %r14
addq $0x10, %r13
cmpq %rbp, %r13
jne 0x35f9
movl (%r15), %ebp
subl %ebx, %r14d
xorl %r15d, %r15d
movl %r14d, %r12d
testl %r14d, %r14d
je 0x3659
movslq %r12d, %rdx
movl %ebp, %edi
movq %rbx, %rsi
callq 0x20c0
movl %eax, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
testl %eax, %eax
cmovsq %r15, %rcx
movl $0x0, %edx
cmovgl %eax, %edx
addq %rcx, %rbx
movl %r12d, %r14d
subl %edx, %r14d
testl %eax, %eax
jns 0x3621
testl %r12d, %r12d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-cli/buffered-line-reader.cc
// Function: BufferedLineReader::Refill()
bool BufferedLineReader::Refill() {
    data_begin_ = buffer_;
    data_end_ = data_begin_;
    if (eof_) return false;
    if (!remainder_.empty()) {
        // get remainder to the beginning of the buffer.
        memmove(data_begin_, remainder_.data(), remainder_.size());
        data_end_ += remainder_.size();
    }
    const ssize_t r = read(fd_, data_end_, buffer_size_ - remainder_.size());
    if (r > 0) {
        data_end_ += r;
    } else {
        eof_ = true;
        if (r < 0) perror("Reading input");
        if (!remainder_.empty()) {
            // Close remainder with a newline
            *data_end_++ = '\n';
        }
    }
    remainder_ = {};
    return data_end_ > data_begin_;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq %rdi, 0x20(%rbx)
movq %rdi, 0x28(%rbx)
cmpb $0x0, 0x19(%rbx)
je 0x39a3
xorl %eax, %eax
jmp 0x3a0c
movq 0x30(%rbx), %rdx
testq %rdx, %rdx
je 0x39bd
movq 0x38(%rbx), %rsi
callq 0x22d0
movq 0x30(%rbx), %rax
addq %rax, 0x28(%rbx)
leaq 0x30(%rbx), %r14
movl (%rbx), %edi
movq 0x28(%rbx), %rsi
movq 0x8(%rbx), %rdx
subq 0x30(%rbx), %rdx
callq 0x2290
testq %rax, %rax
jle 0x39df
addq %rax, 0x28(%rbx)
jmp 0x39fa
movb $0x1, 0x19(%rbx)
js 0x3a14
cmpq $0x0, (%r14)
je 0x39fa
movq 0x28(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x28(%rbx)
movb $0xa, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq 0x28(%rbx), %rax
cmpq 0x20(%rbx), %rax
seta %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1113(%rip), %rdi      # 0x4b2e
callq 0x2170
jmp 0x39e5
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-cli/buffered-line-reader.cc
// Function: BufferedLineReader::ReadNextLines(unsigned long)
std::vector<std::string_view> BufferedLineReader::ReadNextLines(size_t n) {
    std::vector<std::string_view> result;
    result.reserve(n);
    if (data_begin_ >= data_end_ && !Refill()) {
        return result;
    }
    char *end_line;
    while ((end_line = std::find_if(data_begin_, data_end_, [](char c) {
                return c == '\n' || c == '\r';
            })) != data_end_) {
        auto line = MakeCommentFreeLine(data_begin_, end_line);
        if (!line.empty()) result.push_back(line);
        data_begin_ = end_line + 1;
        if (result.size() >= n) {
            return result;
        }
    }
    remainder_ = std::string_view(data_begin_, data_end_ - data_begin_);
    data_begin_ = data_end_;  // consume all.
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rdx, %rsi
callq 0x3d24
movq 0x20(%r14), %rax
cmpq 0x28(%r14), %rax
jb 0x3a68
movq %r14, %rdi
callq 0x3986
testb %al, %al
je 0x3bbc
movq %rsp, %r12
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rax
movq %rax, %rcx
subq %rsi, %rcx
movq %rcx, %rdi
sarq $0x2, %rdi
movq %rsi, %rdx
testq %rdi, %rdi
jle 0x3aee
movq %rcx, %rdx
andq $-0x4, %rdx
addq %rsi, %rdx
incq %rdi
leaq 0x3(%rsi), %r13
movzbl -0x3(%r13), %r8d
cmpl $0xa, %r8d
je 0x3b2b
cmpl $0xd, %r8d
je 0x3b2b
movzbl -0x2(%r13), %r8d
cmpl $0xa, %r8d
je 0x3b31
cmpl $0xd, %r8d
je 0x3b31
movzbl -0x1(%r13), %r8d
cmpl $0xa, %r8d
je 0x3b37
cmpl $0xd, %r8d
je 0x3b37
movzbl (%r13), %r8d
cmpl $0xa, %r8d
je 0x3b52
cmpl $0xd, %r8d
je 0x3b52
decq %rdi
addq $0x4, %r13
cmpq $0x1, %rdi
jg 0x3a99
movq %rax, %rdi
subq %rdx, %rdi
cmpq $0x1, %rdi
je 0x3b3f
cmpq $0x2, %rdi
je 0x3b19
movq %rax, %r13
cmpq $0x3, %rdi
jne 0x3b52
movzbl (%rdx), %edi
cmpl $0xa, %edi
je 0x3b26
cmpl $0xd, %edi
je 0x3b26
incq %rdx
movzbl (%rdx), %edi
cmpl $0xa, %edi
je 0x3b26
cmpl $0xd, %edi
jne 0x3b3c
movq %rdx, %r13
jmp 0x3b52
addq $-0x3, %r13
jmp 0x3b52
addq $-0x2, %r13
jmp 0x3b52
decq %r13
jmp 0x3b52
incq %rdx
movq %rdx, %r13
movzbl (%rdx), %edx
cmpl $0xa, %edx
je 0x3b52
cmpl $0xd, %edx
je 0x3b52
movq %rax, %r13
cmpq %rax, %r13
je 0x3bb0
movq %r14, %rdi
movq %r13, %rdx
callq 0x3bee
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
testq %rax, %rax
je 0x3b93
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3b88
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x3b93
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3de8
incq %r13
movq %r13, 0x20(%r14)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x4, %rax
cmpq %r15, %rax
jb 0x3a6b
jmp 0x3bbc
movq %rcx, 0x30(%r14)
movq %rsi, 0x38(%r14)
movq %rax, 0x20(%r14)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3bcf
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3be6
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-cli/buffered-line-reader.cc
// Function: BufferedLineReader::MakeCommentFreeLine(char*, char*)
std::string_view BufferedLineReader::MakeCommentFreeLine(char *first,
                                                         char *last) {
    if (remove_comments_) {
        char *start_of_comment = (char *)memchr(first, ';', last - first + 1);
        if (start_of_comment) last = start_of_comment - 1;
    }
    while (first <= last && isspace(*first)) first++;
    while (last >= first && isspace(*last)) last--;  // also removing newline
    if (last < first) return {};
    *++last = '\n';  // Fresh newline behind resulting new last.
    return std::string_view(first, last - first + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
cmpb $0x1, 0x18(%rdi)
jne 0x3c22
movq %rbx, %rdx
subq %r14, %rdx
incq %rdx
movq %r14, %rdi
movl $0x3b, %esi
callq 0x21c0
leaq -0x1(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rbx
cmpq %r14, %rbx
jb 0x3c3c
movsbl (%r14), %edi
callq 0x2060
testl %eax, %eax
je 0x3c3c
incq %r14
cmpq %rbx, %r14
jbe 0x3c27
xorl %r15d, %r15d
movl $0x0, %edx
cmpq %r14, %rbx
setb %bpl
jb 0x3c9e
movsbl (%rbx), %edi
callq 0x2060
testl %eax, %eax
je 0x3c7a
decq %rbx
xorl %r15d, %r15d
cmpq %r14, %rbx
setb %bpl
jb 0x3c9c
movsbl (%rbx), %edi
callq 0x2060
decq %rbx
testl %eax, %eax
jne 0x3c5f
incq %rbx
xorl %r15d, %r15d
movl $0x0, %edx
testb %bpl, %bpl
jne 0x3c9e
movb $0xa, 0x1(%rbx)
incq %rbx
subq %r14, %rbx
incq %rbx
movq %rbx, %r15
movq %r14, %rdx
jmp 0x3c9e
xorl %edx, %edx
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-cli/buffered-line-reader.cc
// Function: BufferedLineReader::ReadLine()
std::string_view BufferedLineReader::ReadLine() {
    while (!is_eof()) {
        auto lines = ReadNextLines(1);
        if (lines.empty()) continue;  // could happen at buffer switchover
        return lines[0];
    }
    return {};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %rsp, %r12
cmpb $0x0, 0x19(%r14)
jne 0x3d09
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x3a22
movq (%rsp), %r13
movq 0x8(%rsp), %rbp
cmpq %rbp, %r13
je 0x3ced
movq (%r13), %rbx
movq 0x8(%r13), %r15
testq %r13, %r13
je 0x3d02
movq 0x10(%rsp), %rsi
subq %r13, %rsi
movq %r13, %rdi
callq 0x21a0
cmpq %rbp, %r13
je 0x3cc0
jmp 0x3d0e
xorl %ebx, %ebx
xorl %r15d, %r15d
movq %rbx, %rax
movq %r15, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Hybryd[P]HyRoadGenerator/Polygon.cpp
// Function: Polygon::area()
double Polygon::area()
{
  double res=0;
  for(int i=0;i<size();++i)
    res+=(poly[i].second.x()-poly[i].first.x())*(poly[i].first.y()+poly[i].second.y());
  return fabs(res)/2.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
testl %ecx, %ecx
jle 0x162b
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
shlq $0x4, %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movss 0x8(%rax,%rdx), %xmm1
subss (%rax,%rdx), %xmm1
movss 0x4(%rax,%rdx), %xmm2
addss 0xc(%rax,%rdx), %xmm2
mulss %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtss2sd %xmm2, %xmm1
addsd %xmm1, %xmm0
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x15fa
jmp 0x162f
xorpd %xmm0, %xmm0
andpd 0x29d9(%rip), %xmm0     # 0x4010
mulsd 0x2a01(%rip), %xmm0     # 0x4040
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Hybryd[P]HyRoadGenerator/Polygon.cpp
// Function: Polygon::width()
double Polygon::width()
{
  double res=100000000; // the power of infinity
  for(int i=0;i<size();++i)
    res=MINI(res,sqrt((poly[i].second.x() - poly[i].first.x())*(poly[i].second.x() - poly[i].first.x()) + (poly[i].second.y() - poly[i].first.y())*(poly[i].second.y() - poly[i].first.y())));
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
testl %ecx, %ecx
jle 0x183b
movq %rdi, %rbx
movsd 0x28d7(%rip), %xmm3     # 0x4048
movl $0xc, %r14d
xorl %r15d, %r15d
xorpd %xmm2, %xmm2
movss -0x4(%rax,%r14), %xmm0
movss (%rax,%r14), %xmm1
subss -0xc(%rax,%r14), %xmm0
subss -0x8(%rax,%r14), %xmm1
mulss %xmm1, %xmm1
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm2, %xmm0
jb 0x17b5
sqrtsd %xmm0, %xmm0
jmp 0x17c8
movsd %xmm3, -0x20(%rbp)
callq 0x10b0
movsd -0x20(%rbp), %xmm3
xorpd %xmm2, %xmm2
ucomisd %xmm3, %xmm0
ja 0x1818
movq (%rbx), %rax
movss -0x4(%rax,%r14), %xmm0
movss (%rax,%r14), %xmm1
subss -0xc(%rax,%r14), %xmm0
subss -0x8(%rax,%r14), %xmm1
mulss %xmm1, %xmm1
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm2, %xmm0
jb 0x180b
xorps %xmm3, %xmm3
sqrtsd %xmm0, %xmm3
jmp 0x1818
callq 0x10b0
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm3
incq %r15
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
movslq %ecx, %rcx
addq $0x10, %r14
cmpq %rcx, %r15
jl 0x177e
jmp 0x1843
movsd 0x2805(%rip), %xmm3     # 0x4048
movapd %xmm3, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Hybryd[P]HyRoadGenerator/Polygon.cpp
// Function: Polygon::isClosed()
bool Polygon::isClosed()
{
  bool res=true;
  for(int i=0;i<size()-1;++i)
    res &= (poly[i].second == poly[i+1].first);
  res &= (poly[size()-1].second == poly[0].first);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
subq %rax, %rsi
shrq $0x4, %rsi
leal -0x1(%rsi), %edx
movb $0x1, %cl
cmpl $0x2, %esi
jl 0x18a3
movl %edx, %esi
leaq 0x14(%rax), %rdi
movss -0x8(%rdi), %xmm0
movss (%rdi), %xmm1
movss -0x4(%rdi), %xmm2
movss -0xc(%rdi), %xmm3
cmpeqps %xmm2, %xmm3
cmpeqps %xmm0, %xmm1
andps %xmm3, %xmm1
movd %xmm1, %r8d
andb %r8b, %cl
addq $0x10, %rdi
decq %rsi
jne 0x1874
movslq %edx, %rdx
shlq $0x4, %rdx
movss 0xc(%rax,%rdx), %xmm0
movss 0x4(%rax), %xmm1
movss 0x8(%rax,%rdx), %xmm2
movss (%rax), %xmm3
cmpeqps %xmm2, %xmm3
cmpeqps %xmm0, %xmm1
andps %xmm3, %xmm1
movd %xmm1, %eax
andb %cl, %al
andb $0x1, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Hybryd[P]HyRoadGenerator/Polygon.cpp
// Function: Polygon::isAcceptable(double)
bool Polygon::isAcceptable(double x)
{
  //return (area()/perimeter() > x); // notgood
  bool res;
  double w=width();
  if(w==0)
    res=false;
  else
  {
    res = (diameter()/w < x);
//    if(res)
//      std::cerr << diameter()/w << std::endl;
  }
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, -0x18(%rbp)
movq %rdi, %rbx
callq 0x1746
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x18fa
jp 0x18fa
xorl %eax, %eax
jmp 0x1918
movq %rbx, %rdi
movsd %xmm0, -0x10(%rbp)
callq 0x1642
divsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
ucomisd %xmm0, %xmm1
seta %al
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Hybryd[P]HyRoadGenerator/Polygon.cpp
// Function: Polygon::getBary()
Point Polygon::getBary()
{
  Point res(0,0);
  
  for(int i=0;i<size();++i)
  {
    res.x(res.x() + poly[i].first.x());
    res.y(res.y() + poly[i].first.y());
  }
  
  res.x(res.x()/size());
  res.y(res.y()/size());

  return res;
}

// Assembly:
movq %rdi, %rax
movq $0x0, (%rdi)
movq (%rsi), %rdx
movq 0x8(%rsi), %rcx
subq %rdx, %rcx
shrq $0x4, %rcx
xorps %xmm0, %xmm0
testl %ecx, %ecx
jle 0x196b
pushq %rbp
movq %rsp, %rbp
movl %ecx, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
shlq $0x4, %rsi
xorl %edi, %edi
xorps %xmm1, %xmm1
addss (%rdx,%rdi), %xmm0
addss 0x4(%rdx,%rdi), %xmm1
addq $0x10, %rdi
cmpq %rdi, %rsi
jne 0x1954
popq %rbp
jmp 0x196e
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm2
divss %xmm2, %xmm0
movss %xmm0, (%rax)
divss %xmm2, %xmm1
movss %xmm1, 0x4(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/Hybryd[P]HyRoadGenerator/Polygon.cpp
// Function: Polygon::randPoint()
std::pair<int,Point> Polygon::randPoint()
{
  Point res(0,0);
  
  int rEdge = rand()%size();
  double t=((double)rand()/(double)RAND_MAX);
  
  res.x(poly[rEdge].first.x() + t*(poly[rEdge].second.x() - poly[rEdge].first.x()));
  res.y(poly[rEdge].first.y() + t*(poly[rEdge].second.y() - poly[rEdge].first.y()));

  return std::pair<int,Point>(rEdge,res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1040
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x4, %rcx
cltd
idivl %ecx
movl %edx, %r15d
callq 0x1040
cvtsi2sd %eax, %xmm0
divsd 0x2695(%rip), %xmm0     # 0x4050
movslq %r15d, %rax
movq (%r14), %rcx
movq %rax, %rdx
shlq $0x4, %rdx
movss (%rcx,%rdx), %xmm1
movss 0x4(%rcx,%rdx), %xmm2
cvtss2sd %xmm1, %xmm3
movss 0x8(%rcx,%rdx), %xmm4
subss %xmm1, %xmm4
xorps %xmm1, %xmm1
cvtss2sd %xmm4, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm3, %xmm1
cvtsd2ss %xmm1, %xmm1
xorps %xmm3, %xmm3
cvtss2sd %xmm2, %xmm3
movss 0xc(%rcx,%rdx), %xmm4
subss %xmm2, %xmm4
xorps %xmm2, %xmm2
cvtss2sd %xmm4, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
movl %eax, (%rbx)
movss %xmm1, 0x4(%rbx)
movss %xmm0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop