LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Mariotti94[P]BigFloat/BigFloat.cc
// Function: BigFloat::LeadTrim()
void BigFloat::LeadTrim()
{
    for(int i = number.size() - 1; i > decimals; --i) {
        if(number[i] == '0')
            number.pop_back();
        else
            break;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x8, %rdi
callq 0x35c0
subq $0x1, %rax
movl %eax, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x58(%rcx), %eax
jle 0x5d8a
movq (%rsp), %rdi
addq $0x8, %rdi
movslq 0xc(%rsp), %rsi
callq 0xb540
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x5d79
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0xb8d0
jmp 0x5d7b
jmp 0x5d8a
jmp 0x5d7d
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5d43
addq $0x18, %rsp
retq
nop
// File: Mariotti94[P]BigFloat/BigFloat.cc
// Function: BigFloat::operator==(BigFloat const&) const
bool BigFloat::operator== (const BigFloat& right) const
{
    if((error) || (right.error))
        return false;

    int check = CompareNum(*this, right);
    if((check == 0) && (sign == right.sign))
        return true;
    return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x5c(%rax)
jne 0x7e78
movq 0x10(%rsp), %rax
testb $0x1, 0x5c(%rax)
je 0x7e7f
movb $0x0, 0x27(%rsp)
jmp 0x7eb7
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4590
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x7eb2
movq (%rsp), %rax
movsbl (%rax), %eax
movq 0x10(%rsp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x7eb2
movb $0x1, 0x27(%rsp)
jmp 0x7eb7
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Mariotti94[P]BigFloat/BigFloat.cc
// Function: BigFloat::operator>(BigFloat const&) const
bool BigFloat::operator> (const BigFloat& right) const
{
    if((error) || (right.error))
        return false;

    if(((sign == '+') && (right.sign == '+'))) {
        int check = CompareNum(*this, right);
        if(check == 1)
            return true;
        return false;
    }
    if(((sign == '-') && (right.sign == '-'))) {
        int check = CompareNum(*this, right);
        if(check == 2)
            return true;
        return false;
    }
    if(((sign == '-') && (right.sign == '+')))
        return false;
    if(((sign == '+') && (right.sign == '-')))
        return true;

    return false; //all cases are covered above, this is only to prevent compiler warnings
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x5c(%rax)
jne 0x7ef8
movq 0x10(%rsp), %rax
testb $0x1, 0x5c(%rax)
je 0x7f02
movb $0x0, 0x27(%rsp)
jmp 0x7fcd
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x7f48
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x7f48
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4590
movl %eax, 0xc(%rsp)
cmpl $0x1, 0xc(%rsp)
jne 0x7f3e
movb $0x1, 0x27(%rsp)
jmp 0x7fcd
movb $0x0, 0x27(%rsp)
jmp 0x7fcd
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x7f88
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x7f88
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4590
movl %eax, 0x8(%rsp)
cmpl $0x2, 0x8(%rsp)
jne 0x7f81
movb $0x1, 0x27(%rsp)
jmp 0x7fcd
movb $0x0, 0x27(%rsp)
jmp 0x7fcd
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x7fa8
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x7fa8
movb $0x0, 0x27(%rsp)
jmp 0x7fcd
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x7fc8
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x7fc8
movb $0x1, 0x27(%rsp)
jmp 0x7fcd
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: Mariotti94[P]BigFloat/BigFloat.cc
// Function: BigFloat::Power(BigFloat const&, BigFloat const&, int)
BigFloat BigFloat::Power(const BigFloat& left, const BigFloat& right, int div_precision)
{
    BigFloat tmp;

    tmp = BigFloat::Pow(left, right);

    tmp.sign = '+';
    if(left.sign == '-')
        if(right % 2 != 0)
            tmp.sign = '-';

    tmp.decimals = left.decimals;
    tmp.error = 0;
    tmp.LeadTrim();

    if(right.sign == '-')
        tmp = BigFloat::PrecDiv(1, tmp, div_precision);

    return tmp;
}

// Assembly:
subq $0x258, %rsp            # imm = 0x258
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movl %ecx, 0x23c(%rsp)
movb $0x0, 0x23b(%rsp)
callq 0x28c0
movq 0x248(%rsp), %rsi
movq 0x240(%rsp), %rdx
leaq 0x1b8(%rsp), %rdi
callq 0x5340
jmp 0x99cf
movq 0x10(%rsp), %rdi
leaq 0x1b8(%rsp), %rsi
callq 0x2950
leaq 0x1b8(%rsp), %rdi
callq 0x2780
movq 0x10(%rsp), %rax
movb $0x2b, (%rax)
movq 0x248(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x9abc
movq 0x240(%rsp), %rsi
movl $0x2, 0x124(%rsp)
leaq 0x128(%rsp), %rdi
leaq 0x124(%rsp), %rdx
callq 0x5830
jmp 0x9a34
movl $0x0, 0x120(%rsp)
leaq 0x128(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0x9bb0
movb %al, 0xf(%rsp)
jmp 0x9a5a
leaq 0x128(%rsp), %rdi
callq 0x2780
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x9a71
jmp 0x9aba
movq 0x10(%rsp), %rax
movb $0x2d, (%rax)
jmp 0x9aba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1b0(%rsp)
movl %eax, 0x1ac(%rsp)
jmp 0x9b8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1b0(%rsp)
movl %eax, 0x1ac(%rsp)
leaq 0x128(%rsp), %rdi
callq 0x2780
jmp 0x9b8f
jmp 0x9abc
movq 0x10(%rsp), %rdi
movq 0x248(%rsp), %rax
movl 0x58(%rax), %eax
movl %eax, 0x58(%rdi)
movb $0x0, 0x5c(%rdi)
callq 0x5d20
jmp 0x9ada
movq 0x240(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x9b66
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x27b0
jmp 0x9afb
movq 0x10(%rsp), %rdx
movl 0x23c(%rsp), %ecx
leaq 0xa0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x8240
jmp 0x9b1b
movq 0x10(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x2950
leaq 0xa0(%rsp), %rdi
callq 0x2780
leaq 0x20(%rsp), %rdi
callq 0x2780
jmp 0x9b66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1b0(%rsp)
movl %eax, 0x1ac(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2780
jmp 0x9b8f
movb $0x1, 0x23b(%rsp)
testb $0x1, 0x23b(%rsp)
jne 0x9b82
movq 0x10(%rsp), %rdi
callq 0x2780
movq 0x18(%rsp), %rax
addq $0x258, %rsp            # imm = 0x258
retq
movq 0x10(%rsp), %rdi
callq 0x2780
movq 0x1b0(%rsp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: Mariotti94[P]BigFloat/BigFloat.cc
// Function: operator<<(std::ostream&, BigFloat const&)
std::ostream& operator<<(std::ostream& out, const BigFloat& right)
{
    if(right.error) {
        out << "nan";
        return out;
    }

    out << right.sign;
    for(int i = right.number.size() - 1; i >= 0; --i) {
        out << right.number[i];
        if((i == right.decimals) && (i != 0))
            out << '.';
    }
    return out;

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x5c(%rax)
je 0xa559
movq 0x18(%rsp), %rdi
leaq 0x5b29(%rip), %rsi      # 0x1006e
callq 0x21d0
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xa5ed
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movsbl (%rax), %esi
callq 0x2230
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x35c0
subq $0x1, %rax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0xa5e3
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movslq 0xc(%rsp), %rsi
callq 0xb510
movq (%rsp), %rdi
movsbl (%rax), %esi
callq 0x2230
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x58(%rcx), %eax
jne 0xa5d4
cmpl $0x0, 0xc(%rsp)
je 0xa5d4
movq 0x18(%rsp), %rdi
movl $0x2e, %esi
callq 0x2230
jmp 0xa5d6
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xa581
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: Mariotti94[P]BigFloat/BigFloat.cc
// Function: operator>>(std::istream&, BigFloat&)
std::istream& operator>>(std::istream& in, BigFloat& right)
{
    std::string c;
    in >> c;
    right = c;
    return in;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2280
movq 0x10(%rsp), %rsi
movq 0x70(%rsp), %rdi
callq 0x2260
jmp 0xa62e
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x20b0
jmp 0xa63f
movq 0x68(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x5d90
jmp 0xa650
leaq 0x18(%rsp), %rdi
callq 0x20f0
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x20f0
movq 0x8(%rsp), %rax
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0xa6a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x20f0
leaq 0x48(%rsp), %rdi
callq 0x20f0
movq 0x40(%rsp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: Mariotti94[P]BigFloat/BigFloat.cc
// Function: BigFloat::ToDouble() const
double BigFloat::ToDouble() const
{
    double var = 0;

    if(error) {
        var = std::nan("");
        return var;
    }

    double dec = 1;
    if(decimals > 0) {
        int aus = decimals;
        while(aus != 0) {
            dec /= 10;
            aus--;
        }
    }

    for(size_t i = 0; i < number.size(); i++) {
        var += CharToInt(number[i]) * dec;
        dec *= 10;
    }

    if(sign == '-')
        var *= -1;

    return var;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
testb $0x1, 0x5c(%rax)
je 0xa715
leaq 0x5a24(%rip), %rdi      # 0x1011d
callq 0x2040
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0xa823
movq 0x10(%rsp), %rax
movsd 0x58ee(%rip), %xmm0     # 0x10010
movsd %xmm0, 0x28(%rsp)
cmpl $0x0, 0x58(%rax)
jle 0xa768
movq 0x10(%rsp), %rax
movl 0x58(%rax), %eax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0xa766
movsd 0x28(%rsp), %xmm0
movsd 0x58d1(%rip), %xmm1     # 0x10020
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xa73a
jmp 0xa768
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0x35c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xa7f6
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
callq 0xb510
movq %rax, %rdi
callq 0xb570
cvtsi2sd %eax, %xmm0
movsd 0x28(%rsp), %xmm2
movsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x5849(%rip), %xmm0     # 0x10020
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xa771
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xa817
movsd 0x580d(%rip), %xmm0     # 0x10018
mulsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nop
// File: Mariotti94[P]BigFloat/BigFloat.cc
// Function: BigFloat::ToFloat() const
float BigFloat::ToFloat() const
{
    float var = 0;

    if(error) {
        var = std::nan("");
        return var;
    }

    float dec = 1;
    if(decimals > 0) {
        int aus = decimals;
        while(aus != 0) {
            dec /= 10;
            aus--;
        }
    }

    for(size_t i = 0; i < number.size(); i++) {
        var += CharToInt(number[i]) * dec;
        dec *= 10;
    }

    if(sign == '-')
        var *= -1;

    return var;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
testb $0x1, 0x5c(%rax)
je 0xa889
leaq 0x58b4(%rip), %rdi      # 0x1011d
callq 0x2040
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movss 0x24(%rsp), %xmm0
movss %xmm0, 0x34(%rsp)
jmp 0xa992
movq 0x8(%rsp), %rax
movss 0x5792(%rip), %xmm0     # 0x10028
movss %xmm0, 0x20(%rsp)
cmpl $0x0, 0x58(%rax)
jle 0xa8dc
movq 0x8(%rsp), %rax
movl 0x58(%rax), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0xa8da
movss 0x20(%rsp), %xmm0
movss 0x576d(%rip), %xmm1     # 0x10030
divss %xmm1, %xmm0
movss %xmm0, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xa8ae
jmp 0xa8dc
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
addq $0x8, %rdi
callq 0x35c0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xa965
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movq 0x10(%rsp), %rsi
callq 0xb510
movq %rax, %rdi
callq 0xb570
cvtsi2ss %eax, %xmm0
movss 0x20(%rsp), %xmm2
movss 0x24(%rsp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x24(%rsp)
movss 0x56e7(%rip), %xmm0     # 0x10030
mulss 0x20(%rsp), %xmm0
movss %xmm0, 0x20(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xa8e5
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xa986
movss 0x56b2(%rip), %xmm0     # 0x1002c
mulss 0x24(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
movss 0x24(%rsp), %xmm0
movss %xmm0, 0x34(%rsp)
movss 0x34(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: Mariotti94[P]BigFloat/BigFloat.cc
// Function: BigFloat::ToString[abi:cxx11]() const
std::string BigFloat::ToString() const
{
    std::string var;
    std::stringstream ss;

    if(error) {
        var = "nan";
        return var;
    }
    if(sign == '-') {
        ss << sign;
    }
    for(int i = number.size() - 1; i >= 0; i--) {
        ss << number[i];
        if((i == decimals) && (i != 0))
            ss << ".";
    }
    ss >> var;
    return var;
}

// Assembly:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq 0x1c8(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x1c7(%rsp)
callq 0x2280
leaq 0x38(%rsp), %rdi
callq 0x2120
jmp 0xaa1a
movq 0x18(%rsp), %rax
testb $0x1, 0x5c(%rax)
je 0xaa7d
movq 0x8(%rsp), %rdi
leaq 0x563d(%rip), %rsi      # 0x1006e
callq 0x2270
jmp 0xaa38
movb $0x1, 0x1c7(%rsp)
movl $0x1, 0x28(%rsp)
jmp 0xab41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xab6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2140
jmp 0xab6c
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xaaa0
movq 0x18(%rsp), %rax
leaq 0x48(%rsp), %rdi
movsbl (%rax), %esi
callq 0x2230
jmp 0xaa9e
jmp 0xaaa0
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x35c0
subq $0x1, %rax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jl 0xab20
movq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rax
movq %rax, (%rsp)
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0xb510
movq (%rsp), %rdi
movsbl (%rax), %esi
callq 0x2230
jmp 0xaae7
movq 0x18(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0x58(%rcx), %eax
jne 0xab11
cmpl $0x0, 0x24(%rsp)
je 0xab11
leaq 0x48(%rsp), %rdi
leaq 0x556b(%rip), %rsi      # 0x10073
callq 0x21d0
jmp 0xab0f
jmp 0xab11
jmp 0xab13
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xaab6
movq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x2260
jmp 0xab31
movb $0x1, 0x1c7(%rsp)
movl $0x1, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2140
testb $0x1, 0x1c7(%rsp)
jne 0xab5f
movq 0x8(%rsp), %rdi
callq 0x20f0
movq 0x10(%rsp), %rax
addq $0x1d8, %rsp            # imm = 0x1D8
retq
movq 0x8(%rsp), %rdi
callq 0x20f0
movq 0x30(%rsp), %rdi
callq 0x2300
// File: Mariotti94[P]BigFloat/BigFloat.cc
// Function: BigFloat::TrailTrim()
void BigFloat::TrailTrim()
{
    if(!error)
        while((number[0] == '0') && (decimals > 0)) {
            number.pop_front();
            decimals--;
        }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x5c(%rax)
jne 0xaeb5
jmp 0xae5b
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb540
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, 0x7(%rsp)
jne 0xae8b
movq 0x8(%rsp), %rax
cmpl $0x0, 0x58(%rax)
setg %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xae95
jmp 0xaeb3
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0xba50
movq 0x8(%rsp), %rax
movl 0x58(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x58(%rax)
jmp 0xae5b
jmp 0xaeb5
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: NovaGL[P]HarmonyHubControl/HarmonyHubControl.cpp
// Function: connectToHarmony(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, csocket&)
int connectToHarmony(std::string strHarmonyIPAddress, int harmonyPortNumber, csocket& harmonyCommunicationcsocket)
{
    if(strHarmonyIPAddress.length() == 0 || harmonyPortNumber == 0 || harmonyPortNumber > 65535)
    {
        errorString = "connectToHarmony : Empty Harmony IP Address or Port";
        return 1;
    }

    harmonyCommunicationcsocket.connect(strHarmonyIPAddress.c_str(), harmonyPortNumber);

    if (harmonyCommunicationcsocket.getState() != csocket::CONNECTED)
    {
        errorString = "connectToHarmony : Unable to connect to specified IP Address on specified Port";
        return 1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x3540
cmpq $0x0, %rax
je 0x44e1
cmpl $0x0, -0x14(%rbp)
je 0x44e1
cmpl $0xffff, -0x14(%rbp)    # imm = 0xFFFF
jle 0x44fd
leaq 0x1de90(%rip), %rdi     # 0x22378
leaq 0x11de7(%rip), %rsi     # 0x162d6
callq 0x34c0
movl $0x1, -0x4(%rbp)
jmp 0x454e
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x31c0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
callq 0x14bf0
movq -0x20(%rbp), %rdi
callq 0x15180
cmpl $0x1, %eax
je 0x4547
leaq 0x1de46(%rip), %rdi     # 0x22378
leaq 0x11dd1(%rip), %rsi     # 0x1630a
callq 0x34c0
movl $0x1, -0x4(%rbp)
jmp 0x454e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: NovaGL[P]HarmonyHubControl/HarmonyHubControl.cpp
// Function: TryGetMemberString[abi:cxx11](rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, char const*)
std::string TryGetMemberString(const rapidjson::Value& value, const char* memberName)
{
    rapidjson::Value::ConstMemberIterator itr = value.FindMember(memberName);
    if (itr != value.MemberEnd() && itr->value.IsString())
    {
        return itr->value.GetString();
    }
    return std::string();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8ea0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8f10
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8ee0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x3d(%rbp)
jne 0x5f08
jmp 0x5f20
leaq -0x20(%rbp), %rdi
callq 0x8f80
movq %rax, %rdi
addq $0x10, %rdi
callq 0x8fa0
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x5f29
jmp 0x5f84
leaq -0x20(%rbp), %rdi
callq 0x8f80
movq %rax, %rdi
addq $0x10, %rdi
callq 0x8fc0
movq %rax, -0x60(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x35f0
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x8b50
jmp 0x5f62
leaq -0x29(%rbp), %rdi
callq 0x33f0
jmp 0x5f8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x33f0
jmp 0x5f97
movq -0x50(%rbp), %rdi
callq 0x34e0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x35e0
// File: NovaGL[P]HarmonyHubControl/HarmonyHubControl.cpp
// Function: parseAction(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, std::vector<Action, std::allocator<Action>>&)
int parseAction(const rapidjson::Value& function, std::vector<Action>& vecDeviceActions)
{
    Action a;
    std::string action = TryGetMemberString(function, "action");
    rapidjson::Document d;
    d.Parse(action.c_str());
    if (!d.HasParseError())
    {
        a.m_strCommand = TryGetMemberString(d, "command");
    }
    a.m_strName = TryGetMemberString(function, "name");
    a.m_strLabel = TryGetMemberString(function, "label");

    vecDeviceActions.push_back(a);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x9010
movq -0x8(%rbp), %rsi
leaq 0x109da(%rip), %rdx     # 0x169a1
leaq -0x90(%rbp), %rdi
callq 0x5eb0
jmp 0x5fd5
xorl %eax, %eax
movl %eax, %ecx
leaq -0x100(%rbp), %rdi
movl $0x400, %edx            # imm = 0x400
movq %rcx, %rsi
callq 0x9050
jmp 0x5fef
leaq -0x90(%rbp), %rdi
callq 0x31c0
movq %rax, %rsi
leaq -0x100(%rbp), %rdi
callq 0x9150
jmp 0x600c
leaq -0x100(%rbp), %rdi
callq 0x9180
movb %al, -0x161(%rbp)
jmp 0x6020
movb -0x161(%rbp), %al
testb $0x1, %al
jne 0x60bb
jmp 0x6030
leaq 0x10864(%rip), %rdx     # 0x1689b
leaq -0x120(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x5eb0
jmp 0x604c
leaq -0x70(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x3460
leaq -0x120(%rbp), %rdi
callq 0x3698
jmp 0x60bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x617a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x616e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x9220
jmp 0x616e
movq -0x8(%rbp), %rsi
leaq 0x108e2(%rip), %rdx     # 0x169a8
leaq -0x140(%rbp), %rdi
callq 0x5eb0
jmp 0x60d4
leaq -0x50(%rbp), %rdi
leaq -0x140(%rbp), %rsi
movq %rsi, -0x170(%rbp)
callq 0x3460
movq -0x170(%rbp), %rdi
callq 0x3698
movq -0x8(%rbp), %rsi
leaq 0x108ab(%rip), %rdx     # 0x169ad
leaq -0x160(%rbp), %rdi
callq 0x5eb0
jmp 0x6110
leaq -0x30(%rbp), %rdi
leaq -0x160(%rbp), %rsi
movq %rsi, -0x178(%rbp)
callq 0x3460
movq -0x178(%rbp), %rdi
callq 0x3698
movq -0x10(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x91b0
jmp 0x6142
leaq -0x100(%rbp), %rdi
callq 0x9220
leaq -0x90(%rbp), %rdi
callq 0x3698
leaq -0x70(%rbp), %rdi
callq 0x9280
xorl %eax, %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
leaq -0x90(%rbp), %rdi
callq 0x3698
leaq -0x70(%rbp), %rdi
callq 0x9280
movq -0x98(%rbp), %rdi
callq 0x35e0
nop
// File: NovaGL[P]HarmonyHubControl/HarmonyHubControl.cpp
// Function: parseControlGroup(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, std::vector<Function, std::allocator<Function>>&)
int parseControlGroup(const rapidjson::Value& device, std::vector<Function>& vecDeviceFunctions)
{
    rapidjson::Value::ConstMemberIterator itr = device.FindMember("controlGroup");
    if (itr != device.MemberEnd() && itr->value.IsArray())
    {
        for (const auto& controlGroup : itr->value.GetArray())
        {
            if(parseFunction(controlGroup, vecDeviceFunctions) != 0)
            {
                return 1;
            }
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1057e(%rip), %rsi     # 0x169bc
callq 0x8ea0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8f10
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8ee0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x69(%rbp)
jne 0x646f
jmp 0x6487
leaq -0x20(%rbp), %rdi
callq 0x8f80
movq %rax, %rdi
addq $0x10, %rdi
callq 0x92c0
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x6493
jmp 0x6573
leaq -0x20(%rbp), %rdi
callq 0x8f80
movq %rax, %rsi
addq $0x10, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x9310
movq -0x80(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x9380
movq %rax, -0x78(%rbp)
jmp 0x64c7
movq -0x78(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x93a0
movq %rax, -0x88(%rbp)
jmp 0x64e1
movq -0x88(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x58(%rbp), %rax
jne 0x6516
movl $0x2, -0x5c(%rbp)
jmp 0x655e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x93c0
jmp 0x6586
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6190
movl %eax, -0x8c(%rbp)
jmp 0x6533
movl -0x8c(%rbp), %eax
cmpl $0x0, %eax
je 0x654e
movl $0x1, -0x4(%rbp)
movl $0x1, -0x5c(%rbp)
jmp 0x655e
jmp 0x6550
movq -0x40(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
jmp 0x64ec
leaq -0x38(%rbp), %rdi
callq 0x93c0
movl -0x5c(%rbp), %eax
subl $0x1, %eax
je 0x657a
jmp 0x6571
jmp 0x6573
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x35e0
nop
// File: NovaGL[P]HarmonyHubControl/HarmonyHubControl.cpp
// Function: ReadAuthorizationTokenFile[abi:cxx11]()
const std::string ReadAuthorizationTokenFile()
{
    std::string strAuthorizationToken;
    std::ifstream AuthorizationTokenFileStream (HARMONY_HUB_AUTHORIZATION_TOKEN_FILENAME);
    if (!AuthorizationTokenFileStream.is_open())
    {
        return strAuthorizationToken;
    }

    getline (AuthorizationTokenFileStream,strAuthorizationToken);

    AuthorizationTokenFileStream.close();
    
    return strAuthorizationToken;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x238(%rbp)
movq %rdi, %rax
movq %rax, -0x230(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x34e0
leaq 0xfbef(%rip), %rsi      # 0x16a0f
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x3620
jmp 0x6e33
leaq -0x218(%rbp), %rdi
callq 0x3570
movb %al, -0x239(%rbp)
jmp 0x6e47
movb -0x239(%rbp), %al
testb $0x1, %al
jne 0x6e97
jmp 0x6e53
movb $0x1, -0x9(%rbp)
movl $0x1, -0x228(%rbp)
jmp 0x6ec8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x6ef6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x3150
jmp 0x6ef6
movq -0x238(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0x30e0
jmp 0x6eac
leaq -0x218(%rbp), %rdi
callq 0x30f0
jmp 0x6eba
movb $0x1, -0x9(%rbp)
movl $0x1, -0x228(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x3150
testb $0x1, -0x9(%rbp)
jne 0x6ee6
movq -0x238(%rbp), %rdi
callq 0x3698
movq -0x230(%rbp), %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x238(%rbp), %rdi
callq 0x3698
movq -0x220(%rbp), %rdi
callq 0x35e0
nop
// File: NovaGL[P]HarmonyHubControl/HarmonyHubControl.cpp
// Function: WriteAuthorizationTokenFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int WriteAuthorizationTokenFile(const std::string& strAuthorizationToken)
{
    std::ofstream AuthorizationTokenFileStream;
    AuthorizationTokenFileStream.open(HARMONY_HUB_AUTHORIZATION_TOKEN_FILENAME);
    if(!AuthorizationTokenFileStream.is_open())
    {
        return 1;
    }
    AuthorizationTokenFileStream << strAuthorizationToken;
    AuthorizationTokenFileStream.close();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x10(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0x35c0
movq -0x228(%rbp), %rdi
leaq 0xfacf(%rip), %rsi      # 0x16a0f
movl $0x10, %edx
callq 0x3070
jmp 0x6f4c
leaq -0x210(%rbp), %rdi
callq 0x32c0
movb %al, -0x229(%rbp)
jmp 0x6f60
movb -0x229(%rbp), %al
testb $0x1, %al
jne 0x6f9f
jmp 0x6f6c
movl $0x1, -0x4(%rbp)
movl $0x1, -0x220(%rbp)
jmp 0x6fd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x3530
jmp 0x6fe8
movq -0x10(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x3340
jmp 0x6fb1
leaq -0x210(%rbp), %rdi
callq 0x3500
jmp 0x6fbf
movl $0x0, -0x4(%rbp)
movl $0x1, -0x220(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x3530
movl -0x4(%rbp), %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x35e0
nopw %cs:(%rax,%rax)
// File: NovaGL[P]HarmonyHubControl/./rapidjson/document.h
// Function: rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>::~GenericDocument()
~GenericDocument() {
        // Clear the ::ValueType before ownAllocator is destroyed, ~ValueType()
        // runs last and may access its elements or members which would be freed
        // with an allocator like MemoryPoolAllocator (CrtAllocator does not
        // free its data when destroyed, but MemoryPoolAllocator does).
        if (ownAllocator_) {
            ValueType::SetNull();
        }
        Destroy();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x9248
movq -0x10(%rbp), %rdi
callq 0xba20
jmp 0x9246
jmp 0x9248
movq -0x10(%rbp), %rdi
callq 0xba50
jmp 0x9253
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0xb920
movq -0x10(%rbp), %rdi
callq 0xba90
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xa040
nopw (%rax,%rax)
// File: NovaGL[P]HarmonyHubControl/HarmonyHubControl.cpp
// Function: Function::toString[abi:cxx11]()
std::string toString()
    {
        std::string ret=("\"");
	ret.append(m_strName);
	ret.append("\":[");
        std::vector<Action>::iterator it = m_vecActions.begin();
        std::vector<Action>::iterator ite = m_vecActions.end();
        for(; it != ite; ++it)
        {
	ret.append("\n\t");
	ret.append("\"");
        ret.append(it->toString());
	ret.append("\",");
        }
        ret=ret.substr(0, ret.size()-1);
        ret.append("],\n");
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x35f0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rdx
leaq 0xc9f6(%rip), %rsi      # 0x171d8
callq 0x8b50
jmp 0xa7e9
leaq -0x12(%rbp), %rdi
callq 0x33f0
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x3640
jmp 0xa807
movq -0x88(%rbp), %rdi
leaq 0xc9db(%rip), %rsi      # 0x171f0
callq 0x3630
jmp 0xa81c
movq -0x90(%rbp), %rdi
addq $0x20, %rdi
callq 0xaa10
movq -0x90(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x20, %rdi
callq 0xaa40
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xaa70
testb $0x1, %al
jne 0xa85a
jmp 0xa920
movq -0x88(%rbp), %rdi
leaq 0xc98c(%rip), %rsi      # 0x171f4
callq 0x3630
jmp 0xa86f
movq -0x88(%rbp), %rdi
leaq 0xc95b(%rip), %rsi      # 0x171d8
callq 0x3630
jmp 0xa884
leaq -0x30(%rbp), %rdi
callq 0xaab0
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0xaad0
jmp 0xa89b
movq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3640
jmp 0xa8ad
leaq -0x58(%rbp), %rdi
callq 0x3698
movq -0x88(%rbp), %rdi
leaq 0xc59d(%rip), %rsi      # 0x16e61
callq 0x3630
jmp 0xa8cb
jmp 0xa8cd
leaq -0x30(%rbp), %rdi
callq 0xab00
jmp 0xa844
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x33f0
jmp 0xa9b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xa9a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3698
jmp 0xa9a6
movq -0x88(%rbp), %rdi
callq 0x3290
movq -0x88(%rbp), %rsi
movq %rax, %rcx
decq %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x78(%rbp), %rdi
callq 0x33c0
jmp 0xa948
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
callq 0x3460
movq -0xa0(%rbp), %rdi
callq 0x3698
movq -0x88(%rbp), %rdi
leaq 0xc87e(%rip), %rsi      # 0x171f7
callq 0x3630
jmp 0xa980
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xa996
movq -0x88(%rbp), %rdi
callq 0x3698
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x3698
movq -0x20(%rbp), %rdi
callq 0x35e0
nopl (%rax,%rax)
// File: NovaGL[P]HarmonyHubControl/./rapidjson/allocators.h
// Function: rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>::MemoryPoolAllocator(unsigned long, rapidjson::CrtAllocator*)
explicit
    MemoryPoolAllocator(size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) : 
        chunk_capacity_(chunkSize),
        baseAllocator_(baseAllocator ? baseAllocator : RAPIDJSON_NEW(BaseAllocator)()),
        shared_(static_cast<SharedData*>(baseAllocator_ ? baseAllocator_->Malloc(SIZEOF_SHARED_DATA + SIZEOF_CHUNK_HEADER) : 0))
    {
        RAPIDJSON_ASSERT(baseAllocator_ != 0);
        RAPIDJSON_ASSERT(shared_ != 0);
        if (baseAllocator) {
            shared_->ownBaseAllocator = 0;
        }
        else {
            shared_->ownBaseAllocator = baseAllocator_;
        }
        shared_->chunkHead = GetChunkHead(shared_);
        shared_->chunkHead->capacity = 0;
        shared_->chunkHead->size = 0;
        shared_->chunkHead->next = 0;
        shared_->ownBuffer = true;
        shared_->refcount = 1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, -0x21(%rbp)
cmpq $0x0, %rax
je 0xb7d3
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0xb7e9
movl $0x1, %edi
callq 0x3370
movq %rax, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rdx
movq %rdx, (%rcx)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x48(%rbp)
cmpq $0x0, 0x8(%rax)
je 0xb822
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x38, %esi
callq 0xb950
movq %rax, -0x50(%rbp)
jmp 0xb82a
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0xb82a
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq -0x50(%rbp), %rdx
movq %rdx, (%rcx)
cmpq $0x0, 0x8(%rax)
je 0xb842
jmp 0xb861
leaq 0xbb32(%rip), %rdi      # 0x1737b
leaq 0xbb3f(%rip), %rsi      # 0x1738f
movl $0xae, %edx
leaq 0xbb4c(%rip), %rcx      # 0x173a8
callq 0x3260
movq -0x38(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xb86e
jmp 0xb88d
leaq 0xbbac(%rip), %rdi      # 0x17421
leaq 0xbb13(%rip), %rsi      # 0x1738f
movl $0xaf, %edx
leaq 0xbb20(%rip), %rcx      # 0x173a8
callq 0x3260
cmpq $0x0, -0x18(%rbp)
je 0xb8a6
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x8(%rax)
jmp 0xb8b6
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb990
movq %rax, %rdx
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rdx, (%rcx)
movq 0x10(%rax), %rcx
movq (%rcx), %rcx
movq $0x0, (%rcx)
movq 0x10(%rax), %rcx
movq (%rcx), %rcx
movq $0x0, 0x8(%rcx)
movq 0x10(%rax), %rcx
movq (%rcx), %rcx
movq $0x0, 0x10(%rcx)
movq 0x10(%rax), %rcx
movb $0x1, 0x18(%rcx)
movq 0x10(%rax), %rax
movq $0x1, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: NovaGL[P]HarmonyHubControl/./rapidjson/allocators.h
// Function: rapidjson::CrtAllocator::Malloc(unsigned long)
void* Malloc(size_t size) { 
        if (size) //  behavior of malloc(0) is implementation defined.
            return RAPIDJSON_MALLOC(size);
        else
            return NULL; // standardize to returning NULL.
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb976
movq -0x18(%rbp), %rdi
callq 0x34a0
movq %rax, -0x8(%rbp)
jmp 0xb97e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: NovaGL[P]HarmonyHubControl/./rapidjson/allocators.h
// Function: rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>::~MemoryPoolAllocator()
~MemoryPoolAllocator() RAPIDJSON_NOEXCEPT {
        if (!shared_) {
            // do nothing if moved
            return;
        }
        if (shared_->refcount > 1) {
            --shared_->refcount;
            return;
        }
        Clear();
        BaseAllocator *a = shared_->ownBaseAllocator;
        if (shared_->ownBuffer) {
            baseAllocator_->Free(shared_);
        }
        RAPIDJSON_DELETE(a);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xbaed
jmp 0xbb5e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x1, 0x10(%rax)
jbe 0xbb12
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0xbb5e
movq -0x18(%rbp), %rdi
callq 0xbb70
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq 0x10(%rax), %rax
testb $0x1, 0x18(%rax)
je 0xbb42
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xba00
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xbb5e
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x3390
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: NovaGL[P]HarmonyHubControl/./rapidjson/allocators.h
// Function: rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>::Clear()
void Clear() RAPIDJSON_NOEXCEPT {
        RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0);
        for (;;) {
            ChunkHeader* c = shared_->chunkHead;
            if (!c->next) {
                break;
            }
            shared_->chunkHead = c->next;
            baseAllocator_->Free(c);
        }
        shared_->chunkHead->size = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rax
cmpq $0x0, 0x10(%rax)
jbe 0xbb91
jmp 0xbbb0
leaq 0xb896(%rip), %rdi      # 0x1742e
leaq 0xb7f0(%rip), %rsi      # 0x1738f
movl $0x115, %edx            # imm = 0x115
leaq 0xb899(%rip), %rcx      # 0x17444
callq 0x3260
jmp 0xbbb2
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xbbce
jmp 0xbbec
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0xba00
jmp 0xbbb2
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: NovaGL[P]HarmonyHubControl/./rapidjson/document.h
// Function: rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::operator=(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>&)
GenericValue& operator=(GenericValue& rhs) RAPIDJSON_NOEXCEPT {
        if (RAPIDJSON_LIKELY(this != &rhs)) {
            // Can't destroy "this" before assigning "rhs", otherwise "rhs"
            // could be used after free if it's an sub-Value of "this",
            // hence the temporary danse.
            GenericValue temp;
            temp.RawAssign(rhs);
            this->~GenericValue();
            RawAssign(temp);
        }
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq -0x10(%rbp), %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc309
jmp 0xc33e
leaq -0x20(%rbp), %rdi
callq 0xbaa0
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x10f40
movq -0x28(%rbp), %rdi
callq 0xba90
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x10f40
leaq -0x20(%rbp), %rdi
callq 0xba90
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: NovaGL[P]HarmonyHubControl/./rapidjson/allocators.h
// Function: rapidjson::CrtAllocator::Realloc(void*, unsigned long, unsigned long)
void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
        (void)originalSize;
        if (newSize == 0) {
            RAPIDJSON_FREE(originalPtr);
            return NULL;
        }
        return RAPIDJSON_REALLOC(originalPtr, newSize);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xef22
movq -0x18(%rbp), %rdi
callq 0x3450
movq $0x0, -0x8(%rbp)
jmp 0xef33
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3590
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: NovaGL[P]HarmonyHubControl/./rapidjson/allocators.h
// Function: rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>::Malloc(unsigned long)
void* Malloc(size_t size) {
        RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0);
        if (!size)
            return NULL;

        size = RAPIDJSON_ALIGN(size);
        if (RAPIDJSON_UNLIKELY(shared_->chunkHead->size + size > shared_->chunkHead->capacity))
            if (!AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size))
                return NULL;

        void *buffer = GetChunkBuffer(shared_) + shared_->chunkHead->size;
        shared_->chunkHead->size += size;
        return buffer;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rax), %rax
cmpq $0x0, 0x10(%rax)
jbe 0xfef5
jmp 0xff14
leaq 0x7532(%rip), %rdi      # 0x1742e
leaq 0x748c(%rip), %rsi      # 0x1738f
movl $0x141, %edx            # imm = 0x141
leaq 0x85df(%rip), %rcx      # 0x184ee
callq 0x3260
cmpq $0x0, -0x18(%rbp)
jne 0xff28
movq $0x0, -0x8(%rbp)
jmp 0xffdf
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rcx), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq 0x10(%rcx), %rcx
movq (%rcx), %rcx
cmpq (%rcx), %rax
seta %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xff62
jmp 0xffa1
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0xff7c
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xff84
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x10040
testb $0x1, %al
jne 0xff9f
movq $0x0, -0x8(%rbp)
jmp 0xffdf
jmp 0xffa1
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x100f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
movq (%rdx), %rdx
addq 0x8(%rdx), %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq 0x10(%rax), %rax
movq (%rax), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: NovaGL[P]HarmonyHubControl/./rapidjson/allocators.h
// Function: rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>::AddChunk(unsigned long)
bool AddChunk(size_t capacity) {
        if (!baseAllocator_)
            shared_->ownBaseAllocator = baseAllocator_ = RAPIDJSON_NEW(BaseAllocator)();
        if (ChunkHeader* chunk = static_cast<ChunkHeader*>(baseAllocator_->Malloc(SIZEOF_CHUNK_HEADER + capacity))) {
            chunk->capacity = capacity;
            chunk->size = 0;
            chunk->next = shared_->chunkHead;
            shared_->chunkHead = chunk;
            return true;
        }
        else
            return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x1007c
movl $0x1, %edi
callq 0x3370
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
callq 0xb950
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x100d7
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x20(%rbp), %rcx
movq $0x0, 0x8(%rcx)
movq 0x10(%rax), %rcx
movq (%rcx), %rdx
movq -0x20(%rbp), %rcx
movq %rdx, 0x10(%rcx)
movq -0x20(%rbp), %rcx
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x100db
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: NovaGL[P]HarmonyHubControl/./rapidjson/document.h
// Function: rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::SetObjectRaw(rapidjson::GenericMember<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*, unsigned int, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
void SetObjectRaw(Member* members, SizeType count, Allocator& allocator) {
        data_.f.flags = kObjectFlag;
        if (count) {
            Member* m = DoAllocMembers(count, allocator);
            SetMembersPointer(m);
            std::memcpy(static_cast<void*>(m), members, count * sizeof(Member));
#if RAPIDJSON_USE_MEMBERSMAP
            Map* &map = GetMap(m);
            MapIterator* mit = GetMapIterators(map);
            for (SizeType i = 0; i < count; i++) {
                new (&mit[i]) MapIterator(map->insert(MapPair(m[i].name.data_, i)));
            }
#endif
        }
        else
            SetMembersPointer(0);
        data_.o.size = data_.o.capacity = count;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movw $0x3, 0xe(%rax)
cmpl $0x0, -0x14(%rbp)
je 0x104a4
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x104d0
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x10500
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
shlq $0x5, %rdx
callq 0x32f0
jmp 0x104b1
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10500
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: NovaGL[P]HarmonyHubControl/./rapidjson/document.h
// Function: rapidjson::GenericMemberIterator<false, rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::DoFindMember<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&)
MemberIterator DoFindMember(const GenericValue<Encoding, SourceAllocator>& name) {
        MemberIterator member = MemberBegin();
        for ( ; member != MemberEnd(); ++member)
            if (name.StringEqual(member->name))
                break;
        return member;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x28(%rbp)
callq 0x12c90
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x96e0
movq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x12d00
testb $0x1, %al
jne 0x12c4c
jmp 0x12c7e
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x12e20
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x12d30
testb $0x1, %al
jne 0x12c6f
jmp 0x12c71
jmp 0x12c7e
jmp 0x12c73
movq -0x38(%rbp), %rdi
callq 0x12e40
jmp 0x12c2c
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: NovaGL[P]HarmonyHubControl/csocket.cpp
// Function: csocket::csocket()
csocket::csocket() : m_socketState(CLOSED), 
                     m_remotePort(0)
{
    if ( ! s_bSocketsInitialized )
    {
#ifdef _WIN32
        WORD socketVersion;  
        WSADATA socketData; 
        int err; 

        socketVersion = MAKEWORD(2, 0); 
        err = WSAStartup(socketVersion, &socketData); 
#endif
    }
     
    m_socket = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0xd30d(%rip), %rax      # 0x21d98
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x0, 0x2c(%rdi)
addq $0x30, %rdi
callq 0x34e0
movq -0x10(%rbp), %rax
movl $0x0, 0x50(%rax)
testb $0x1, 0x101b8c(%rip)    # 0x116640
jne 0x14ab8
jmp 0x14ab8
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)