LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/dtoa.h
// Function: rapidjson::internal::CountDecimalDigit32(unsigned int)
inline int CountDecimalDigit32(uint32_t n) {
    // Simple pure C++ implementation was faster than __builtin_clz version in this situation.
    if (n < 10) return 1;
    if (n < 100) return 2;
    if (n < 1000) return 3;
    if (n < 10000) return 4;
    if (n < 100000) return 5;
    if (n < 1000000) return 6;
    if (n < 10000000) return 7;
    if (n < 100000000) return 8;
    // Will not reach 10 digits in DigitGen()
    //if (n < 1000000000) return 9;
    //return 10;
    return 9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xa, -0x8(%rbp)
jae 0x16bb9
movl $0x1, -0x4(%rbp)
jmp 0x16c3b
cmpl $0x64, -0x8(%rbp)
jae 0x16bc8
movl $0x2, -0x4(%rbp)
jmp 0x16c3b
cmpl $0x3e8, -0x8(%rbp)      # imm = 0x3E8
jae 0x16bda
movl $0x3, -0x4(%rbp)
jmp 0x16c3b
cmpl $0x2710, -0x8(%rbp)     # imm = 0x2710
jae 0x16bec
movl $0x4, -0x4(%rbp)
jmp 0x16c3b
cmpl $0x186a0, -0x8(%rbp)    # imm = 0x186A0
jae 0x16bfe
movl $0x5, -0x4(%rbp)
jmp 0x16c3b
cmpl $0xf4240, -0x8(%rbp)    # imm = 0xF4240
jae 0x16c10
movl $0x6, -0x4(%rbp)
jmp 0x16c3b
cmpl $0x989680, -0x8(%rbp)   # imm = 0x989680
jae 0x16c22
movl $0x7, -0x4(%rbp)
jmp 0x16c3b
cmpl $0x5f5e100, -0x8(%rbp)  # imm = 0x5F5E100
jae 0x16c34
movl $0x8, -0x4(%rbp)
jmp 0x16c3b
movl $0x9, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/dtoa.h
// Function: rapidjson::internal::GrisuRound(char*, int, unsigned long, unsigned long, unsigned long, unsigned long)
inline void GrisuRound(char* buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w) {
    while (rest < wp_w && delta - rest >= ten_kappa &&
           (rest + ten_kappa < wp_w ||  /// closer
            wp_w - rest > rest + ten_kappa - wp_w)) {
        buffer[len - 1]--;
        rest += ten_kappa;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0x16cb3
movq -0x18(%rbp), %rcx
subq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x31(%rbp)
jb 0x16cb3
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
movb $0x1, %al
cmpq -0x30(%rbp), %rcx
movb %al, -0x32(%rbp)
jb 0x16cad
movq -0x30(%rbp), %rax
subq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
subq -0x30(%rbp), %rcx
cmpq %rcx, %rax
seta %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x16cbc
jmp 0x16ce3
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
addb $-0x1, %dl
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x16c5b
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/dtoa.h
// Function: rapidjson::internal::WriteExponent(int, char*)
inline char* WriteExponent(int K, char* buffer) {
    if (K < 0) {
        *buffer++ = '-';
        K = -K;
    }

    if (K >= 100) {
        *buffer++ = static_cast<char>('0' + static_cast<char>(K / 100));
        K %= 100;
        const char* d = GetDigitsLut() + K * 2;
        *buffer++ = d[0];
        *buffer++ = d[1];
    }
    else if (K >= 10) {
        const char* d = GetDigitsLut() + K * 2;
        *buffer++ = d[0];
        *buffer++ = d[1];
    }
    else
        *buffer++ = static_cast<char>('0' + static_cast<char>(K));

    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x16d1f
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x2d, (%rax)
xorl %eax, %eax
subl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
cmpl $0x64, -0x4(%rbp)
jl 0x16d9c
movl -0x4(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x4(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
callq 0xe840
movl -0x4(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x16e05
cmpl $0xa, -0x4(%rbp)
jl 0x16de7
callq 0xe840
movl -0x4(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x16e03
movl -0x4(%rbp), %eax
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x16e05
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/writer.h
// Function: rapidjson::Writer<rapidjson::GenericStringBuffer<rapidjson::UTF8<char>, rapidjson::CrtAllocator>, rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator, 0u>::WriteInt(int)
inline bool Writer<StringBuffer>::WriteInt(int i) {
    char *buffer = os_->Push(11);
    const char* end = internal::i32toa(i, buffer);
    os_->Pop(static_cast<size_t>(11 - (end - buffer)));
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rdi
movl $0xb, %esi
callq 0xe060
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0xeef0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl $0xb, %esi
subq %rax, %rsi
callq 0xea50
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/itoa.h
// Function: rapidjson::internal::i32toa(int, char*)
inline char* i32toa(int32_t value, char* buffer) {
    RAPIDJSON_ASSERT(buffer != 0);
    uint32_t u = static_cast<uint32_t>(value);
    if (value < 0) {
        *buffer++ = '-';
        u = ~u + 1;
    }

    return u32toa(u, buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x16f28
jmp 0x16f47
leaq 0x81b0(%rip), %rdi      # 0x1f0df
leaq 0x81b5(%rip), %rsi      # 0x1f0eb
movl $0x74, %edx
leaq 0x81d5(%rip), %rcx      # 0x1f117
callq 0xe600
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x16f71
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x2d, (%rax)
movl -0x14(%rbp), %eax
xorl $-0x1, %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xf470
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/writer.h
// Function: rapidjson::Writer<rapidjson::GenericStringBuffer<rapidjson::UTF8<char>, rapidjson::CrtAllocator>, rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator, 0u>::WriteUint(unsigned int)
inline bool Writer<StringBuffer>::WriteUint(unsigned u) {
    char *buffer = os_->Push(10);
    const char* end = internal::u32toa(u, buffer);
    os_->Pop(static_cast<size_t>(10 - (end - buffer)));
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rdi
movl $0xa, %esi
callq 0xe060
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0xf470
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl $0xa, %esi
subq %rax, %rsi
callq 0xea50
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/writer.h
// Function: rapidjson::Writer<rapidjson::GenericStringBuffer<rapidjson::UTF8<char>, rapidjson::CrtAllocator>, rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator, 0u>::WriteInt64(long)
inline bool Writer<StringBuffer>::WriteInt64(int64_t i64) {
    char *buffer = os_->Push(21);
    const char* end = internal::i64toa(i64, buffer);
    os_->Pop(static_cast<size_t>(21 - (end - buffer)));
    return true;
}

// 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)
movq (%rax), %rdi
movl $0x15, %esi
callq 0xe060
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe290
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl $0x15, %esi
subq %rax, %rsi
callq 0xea50
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/itoa.h
// Function: rapidjson::internal::i64toa(long, char*)
inline char* i64toa(int64_t value, char* buffer) {
    RAPIDJSON_ASSERT(buffer != 0);
    uint64_t u = static_cast<uint64_t>(value);
    if (value < 0) {
        *buffer++ = '-';
        u = ~u + 1;
    }

    return u64toa(u, buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x174e9
jmp 0x17508
leaq 0x7bef(%rip), %rdi      # 0x1f0df
leaq 0x7bf4(%rip), %rsi      # 0x1f0eb
movl $0x127, %edx            # imm = 0x127
leaq 0x7c7b(%rip), %rcx      # 0x1f17e
callq 0xe600
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jge 0x17539
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x2d, (%rax)
movq -0x18(%rbp), %rax
xorq $-0x1, %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe2a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/writer.h
// Function: rapidjson::Writer<rapidjson::GenericStringBuffer<rapidjson::UTF8<char>, rapidjson::CrtAllocator>, rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator, 0u>::WriteUint64(unsigned long)
inline bool Writer<StringBuffer>::WriteUint64(uint64_t u) {
    char *buffer = os_->Push(20);
    const char* end = internal::u64toa(u, buffer);
    os_->Pop(static_cast<size_t>(20 - (end - buffer)));
    return true;
}

// 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)
movq (%rax), %rdi
movl $0x14, %esi
callq 0xe060
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe2a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl $0x14, %esi
subq %rax, %rsi
callq 0xea50
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::AddMember(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>&, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
GenericValue& AddMember(GenericValue& name, GenericValue& value, Allocator& allocator) {
        RAPIDJSON_ASSERT(IsObject());
        RAPIDJSON_ASSERT(name.IsString());

        ObjectData& o = data_.o;
        if (o.size >= o.capacity)
            MemberReserve(o.capacity == 0 ? kDefaultObjectCapacity : (o.capacity + (o.capacity + 1) / 2), allocator);
        Member* members = GetMembersPointer();
        members[o.size].name.RawAssign(name);
        members[o.size].value.RawAssign(value);
        o.size++;
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xe660
testb $0x1, %al
jne 0x1846b
jmp 0x1846d
jmp 0x1848c
leaq 0x631a(%rip), %rdi      # 0x1e78e
leaq 0x5e03(%rip), %rsi      # 0x1e27e
movl $0x526, %edx            # imm = 0x526
leaq 0x6ede(%rip), %rcx      # 0x1f365
callq 0xe600
movq -0x10(%rbp), %rdi
callq 0xe1d0
testb $0x1, %al
jne 0x1849b
jmp 0x1849d
jmp 0x184bc
leaq 0x5dca(%rip), %rdi      # 0x1e26e
leaq 0x5dd3(%rip), %rsi      # 0x1e27e
movl $0x527, %edx            # imm = 0x527
leaq 0x6eae(%rip), %rcx      # 0x1f365
callq 0xe600
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jb 0x1850f
movq -0x28(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x184e7
movl $0x10, %eax
movl %eax, -0x3c(%rbp)
jmp 0x184ff
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
movl 0x4(%rcx), %ecx
addl $0x1, %ecx
shrl %ecx
addl %ecx, %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0xe3e0
movq -0x38(%rbp), %rdi
callq 0xe6f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %eax
shlq $0x5, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xe4f0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %eax
shlq $0x5, %rax
addq %rax, %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0xe4f0
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %edx
addl $0x1, %edx
movl %edx, (%rcx)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::MemberReserve(unsigned int, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
GenericValue& MemberReserve(SizeType newCapacity, Allocator &allocator) {
        RAPIDJSON_ASSERT(IsObject());
        if (newCapacity > data_.o.capacity) {
            SetMembersPointer(reinterpret_cast<Member*>(allocator.Realloc(GetMembersPointer(), data_.o.capacity * sizeof(Member), newCapacity * sizeof(Member))));
            data_.o.capacity = newCapacity;
        }
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xe660
testb $0x1, %al
jne 0x18596
jmp 0x18598
jmp 0x185b7
leaq 0x61ef(%rip), %rdi      # 0x1e78e
leaq 0x5cd8(%rip), %rsi      # 0x1e27e
movl $0x4b9, %edx            # imm = 0x4B9
leaq 0x6eb0(%rip), %rcx      # 0x1f462
callq 0xe600
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x1860c
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xe6f0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
shlq $0x5, %rdx
movl -0xc(%rbp), %eax
movl %eax, %ecx
shlq $0x5, %rcx
callq 0xed90
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xe950
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/allocators.h
// Function: rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>::Realloc(void*, unsigned long, unsigned long)
void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
        if (originalPtr == 0)
            return Malloc(newSize);

        if (newSize == 0)
            return NULL;

        originalSize = RAPIDJSON_ALIGN(originalSize);
        newSize = RAPIDJSON_ALIGN(newSize);

        // Do not shrink if new size is smaller than original
        if (originalSize >= newSize)
            return originalPtr;

        // Simply expand it if it is the last allocation and there is sufficient space
        if (originalPtr == reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size - originalSize) {
            size_t increment = static_cast<size_t>(newSize - originalSize);
            if (chunkHead_->size + increment <= chunkHead_->capacity) {
                chunkHead_->size += increment;
                return originalPtr;
            }
        }

        // Realloc process: allocate and copy memory, do not free original buffer.
        if (void* newBuffer = Malloc(newSize)) {
            if (originalSize)
                std::memcpy(newBuffer, originalPtr, originalSize);
            return newBuffer;
        }
        else
            return NULL;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x186bd
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xe1f0
movq %rax, -0x8(%rbp)
jmp 0x187b0
cmpq $0x0, -0x28(%rbp)
jne 0x186d1
movq $0x0, -0x8(%rbp)
jmp 0x187b0
movq -0x20(%rbp), %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x18708
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x187b0
movq -0x40(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rdx), %rcx
addq $0x18, %rcx
movq (%rdx), %rdx
addq 0x8(%rdx), %rcx
xorl %edx, %edx
subq -0x20(%rbp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jne 0x1876e
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rcx), %rax
movq 0x8(%rax), %rax
addq -0x30(%rbp), %rax
movq (%rcx), %rcx
cmpq (%rcx), %rax
ja 0x1876c
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x187b0
jmp 0x1876e
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xe1f0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x187a8
cmpq $0x0, -0x20(%rbp)
je 0x1879e
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xe780
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x187b0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/allocators.h
// Function: rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>::Malloc(unsigned long)
void* Malloc(size_t size) {
        if (!size)
            return NULL;

        size = RAPIDJSON_ALIGN(size);
        if (chunkHead_ == 0 || chunkHead_->size + size > chunkHead_->capacity)
            if (!AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size))
                return NULL;

        void *buffer = reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size;
        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)
cmpq $0x0, -0x18(%rbp)
jne 0x187ec
movq $0x0, -0x8(%rbp)
jmp 0x1888b
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $0x7, %rcx
andq $-0x8, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, (%rax)
je 0x1881d
movq -0x28(%rbp), %rcx
movq (%rcx), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq (%rcx), %rcx
cmpq (%rcx), %rax
jbe 0x1885e
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0x18839
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x18841
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xed20
testb $0x1, %al
jne 0x1885c
movq $0x0, -0x8(%rbp)
jmp 0x1888b
jmp 0x1885e
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $0x18, %rcx
movq (%rax), %rdx
addq 0x8(%rdx), %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
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
nopw %cs:(%rax,%rax)
nop
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/allocators.h
// Function: rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>::AddChunk(unsigned long)
bool AddChunk(size_t capacity) {
        if (!baseAllocator_)
            ownBaseAllocator_ = baseAllocator_ = RAPIDJSON_NEW(BaseAllocator)();
        if (ChunkHeader* chunk = reinterpret_cast<ChunkHeader*>(baseAllocator_->Malloc(RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + capacity))) {
            chunk->capacity = capacity;
            chunk->size = 0;
            chunk->next = chunkHead_;
            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, 0x18(%rax)
jne 0x188d8
movl $0x1, %edi
callq 0xe9a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
callq 0xe270
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1892b
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x20(%rbp), %rcx
movq $0x0, 0x8(%rcx)
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
movq %rdx, 0x10(%rcx)
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1892f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/allocators.h
// Function: rapidjson::CrtAllocator::Malloc(unsigned long)
void* Malloc(size_t size) { 
        if (size) //  behavior of malloc(0) is implementation defined.
            return std::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 0x18966
movq -0x18(%rbp), %rdi
callq 0xedd0
movq %rax, -0x8(%rbp)
jmp 0x1896e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::SetStringRaw(rapidjson::GenericStringRef<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
void SetStringRaw(StringRefType s, Allocator& allocator) {
        Ch* str = 0;
        if (ShortString::Usable(s.length)) {
            data_.f.flags = kShortStringFlag;
            data_.ss.SetLength(s.length);
            str = data_.ss.str;
        } else {
            data_.f.flags = kCopyStringFlag;
            data_.s.length = s.length;
            str = static_cast<Ch *>(allocator.Malloc((s.length + 1) * sizeof(Ch)));
            SetStringPointer(str);
        }
        std::memcpy(str, s, s.length * sizeof(Ch));
        str[s.length] = '\0';
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movl 0x8(%rsi), %edi
callq 0xf380
testb $0x1, %al
jne 0x18a36
jmp 0x18a56
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movw $0x1c05, 0xe(%rdi)      # imm = 0x1C05
movl 0x8(%rax), %esi
callq 0xf3e0
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x18a91
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movw $0xc05, 0xe(%rcx)       # imm = 0xC05
movl 0x8(%rax), %edx
movl %edx, (%rcx)
movq -0x18(%rbp), %rdi
movl 0x8(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x0, %rsi
callq 0xe1f0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0xee60
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xe370
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
shlq $0x0, %rdx
callq 0xe780
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movl 0x8(%rcx), %ecx
movb $0x0, (%rax,%rcx)
addq $0x40, %rsp
popq %rbp
retq
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>& rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>::ParseStream<0u, rapidjson::UTF8<char>, rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&)
GenericDocument& ParseStream(InputStream& is) {
        GenericReader<SourceEncoding, Encoding, StackAllocator> reader(
            stack_.HasAllocator() ? &stack_.GetAllocator() : 0);
        ClearStackOnExit scope(*this);
        parseResult_ = reader.template Parse<parseFlags>(is, *this);
        if (parseResult_) {
            RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object
            ValueType::operator=(*stack_.template Pop<ValueType>(1));// Move value from stack to document
        }
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x20, %rdi
callq 0xe640
testb $0x1, %al
jne 0x18c3d
jmp 0x18c56
movq -0x88(%rbp), %rdi
addq $0x20, %rdi
callq 0xe8d0
movq %rax, -0x90(%rbp)
jmp 0x18c61
xorl %eax, %eax
movq %rax, -0x90(%rbp)
jmp 0x18c61
movq -0x90(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movl $0x100, %edx            # imm = 0x100
callq 0xe0f0
movq -0x88(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0xf520
jmp 0x18c88
movq -0x88(%rbp), %rdx
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xee70
movq %rdx, -0xa0(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x18cab
movq -0x88(%rbp), %rax
movq -0xa0(%rbp), %rcx
movl -0x94(%rbp), %edx
movl %edx, -0x80(%rbp)
movq %rcx, -0x78(%rbp)
movq %rax, %rdi
addq $0x50, %rdi
movups -0x80(%rbp), %xmm0
movups %xmm0, 0x50(%rax)
callq 0xf180
movq %rax, -0xa8(%rbp)
jmp 0x18ce3
movq -0xa8(%rbp), %rax
cmpq $0x0, %rax
je 0x18d81
movq -0x88(%rbp), %rdi
addq $0x20, %rdi
callq 0xeee0
cmpq $0x10, %rax
jne 0x18d0c
jmp 0x18d50
leaq 0x686e(%rip), %rdi      # 0x1f581
leaq 0x5564(%rip), %rsi      # 0x1e27e
movl $0x8f7, %edx            # imm = 0x8F7
leaq 0x6881(%rip), %rcx      # 0x1f5a7
callq 0xe600
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x18da3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xe2c0
jmp 0x18da3
movq -0x88(%rbp), %rdi
addq $0x20, %rdi
movl $0x1, %esi
callq 0xec20
movq %rax, -0xb0(%rbp)
jmp 0x18d6e
movq -0xb0(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0xf1e0
leaq -0x60(%rbp), %rdi
callq 0xe2c0
leaq -0x58(%rbp), %rdi
callq 0xe430
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0xe430
movq -0x68(%rbp), %rdi
callq 0xf2f0
nopw %cs:(%rax,%rax)
nop
// File: cqbqdd11519[P]DockerClient/rapidjson/include/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)) {
            this->~GenericValue();
            RawAssign(rhs);
        }
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x19219
jmp 0x1922f
movq -0x18(%rbp), %rdi
callq 0xef70
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe4f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/reader.h
// Function: void rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseValue<0u, rapidjson::GenericStringStream<rapidjson::UTF8<char>>, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>&)
void ParseValue(InputStream& is, Handler& handler) {
        switch (is.Peek()) {
            case 'n': ParseNull  <parseFlags>(is, handler); break;
            case 't': ParseTrue  <parseFlags>(is, handler); break;
            case 'f': ParseFalse <parseFlags>(is, handler); break;
            case '"': ParseString<parseFlags>(is, handler); break;
            case '{': ParseObject<parseFlags>(is, handler); break;
            case '[': ParseArray <parseFlags>(is, handler); break;
            default :
                      ParseNumber<parseFlags>(is, handler);
                      break;

        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xebe0
movsbl %al, %eax
movl %eax, -0x1c(%rbp)
subl $0x22, %eax
je 0x19481
jmp 0x19412
movl -0x1c(%rbp), %eax
subl $0x5b, %eax
je 0x194a9
jmp 0x19420
movl -0x1c(%rbp), %eax
subl $0x66, %eax
je 0x1946e
jmp 0x1942a
movl -0x1c(%rbp), %eax
subl $0x6e, %eax
je 0x19448
jmp 0x19434
movl -0x1c(%rbp), %eax
subl $0x74, %eax
je 0x1945b
jmp 0x1943e
movl -0x1c(%rbp), %eax
subl $0x7b, %eax
je 0x19496
jmp 0x194bc
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe4b0
jmp 0x194cd
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf1d0
jmp 0x194cd
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf0d0
jmp 0x194cd
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0xee20
jmp 0x194cd
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf000
jmp 0x194cd
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf3b0
jmp 0x194cd
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe7a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/reader.h
// Function: void rapidjson::SkipWhitespace<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&)
void SkipWhitespace(InputStream& is) {
    internal::StreamLocalCopy<InputStream> copy(is);
    InputStream& s(copy.s);

    typename InputStream::Ch c;
    while ((c = s.Peek()) == ' ' || c == '\n' || c == '\r' || c == '\t')
        s.Take();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xef90
leaq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xebe0
movb %al, -0x29(%rbp)
movsbl %al, %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x2a(%rbp)
je 0x195a3
movsbl -0x29(%rbp), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x2a(%rbp)
je 0x195a3
movsbl -0x29(%rbp), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x2a(%rbp)
je 0x195a3
movsbl -0x29(%rbp), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x195ac
jmp 0x195b7
movq -0x28(%rbp), %rdi
callq 0xee40
jmp 0x19561
leaq -0x20(%rbp), %rdi
callq 0xe790
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/reader.h
// Function: bool rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::Consume<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&, rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Ch)
RAPIDJSON_FORCEINLINE static bool Consume(InputStream& is, typename InputStream::Ch expect) {
        if (RAPIDJSON_LIKELY(is.Peek() == expect)) {
            is.Take();
            return true;
        }
        else
            return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0xebe0
movsbl %al, %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1ba81
jmp 0x1ba90
movq -0x10(%rbp), %rdi
callq 0xee40
movb $0x1, -0x1(%rbp)
jmp 0x1ba94
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>::String(char const*, unsigned int, bool)
bool String(const Ch* str, SizeType length, bool copy) { 
        if (copy) 
            new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
        else
            new (stack_.template Push<ValueType>()) ValueType(str, length);
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x15(%rbp)
je 0x1c32a
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movl $0x1, %esi
callq 0xe3f0
movq -0x20(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0xe5c0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x24(%rbp), %edx
movq %rax, %rcx
callq 0xe5b0
jmp 0x1c34b
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movl $0x1, %esi
callq 0xe3f0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0xead0
movb $0x1, %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/reader.h
// Function: unsigned int rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseHex4<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&, unsigned long)
unsigned ParseHex4(InputStream& is, size_t escapeOffset) {
        unsigned codepoint = 0;
        for (int i = 0; i < 4; i++) {
            Ch c = is.Peek();
            codepoint <<= 4;
            codepoint += static_cast<unsigned>(c);
            if (c >= '0' && c <= '9')
                codepoint -= '0';
            else if (c >= 'A' && c <= 'F')
                codepoint -= 'A' - 10;
            else if (c >= 'a' && c <= 'f')
                codepoint -= 'a' - 10;
            else {
                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorStringUnicodeEscapeInvalidHex, escapeOffset);
                RAPIDJSON_PARSE_ERROR_EARLY_RETURN(0);
            }
            is.Take();
        }
        return codepoint;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jge 0x1c4f3
movq -0x18(%rbp), %rdi
callq 0xebe0
movb %al, -0x29(%rbp)
movl -0x24(%rbp), %eax
shll $0x4, %eax
movl %eax, -0x24(%rbp)
movsbl -0x29(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movsbl -0x29(%rbp), %eax
cmpl $0x30, %eax
jl 0x1c433
movsbl -0x29(%rbp), %eax
cmpl $0x39, %eax
jg 0x1c433
movl -0x24(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x24(%rbp)
jmp 0x1c4dc
movsbl -0x29(%rbp), %eax
cmpl $0x41, %eax
jl 0x1c453
movsbl -0x29(%rbp), %eax
cmpl $0x46, %eax
jg 0x1c453
movl -0x24(%rbp), %eax
subl $0x37, %eax
movl %eax, -0x24(%rbp)
jmp 0x1c4da
movsbl -0x29(%rbp), %eax
cmpl $0x61, %eax
jl 0x1c470
movsbl -0x29(%rbp), %eax
cmpl $0x66, %eax
jg 0x1c470
movl -0x24(%rbp), %eax
subl $0x57, %eax
movl %eax, -0x24(%rbp)
jmp 0x1c4d8
jmp 0x1c472
movq -0x38(%rbp), %rdi
callq 0xeb20
xorb $-0x1, %al
testb $0x1, %al
jne 0x1c483
jmp 0x1c485
jmp 0x1c4a4
leaq 0x32fd(%rip), %rdi      # 0x1f789
leaq 0x3307(%rip), %rsi      # 0x1f79a
movl $0x396, %edx            # imm = 0x396
leaq 0x3cf1(%rip), %rcx      # 0x20190
callq 0xe600
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x8, %esi
callq 0xe410
jmp 0x1c4b8
movq -0x38(%rbp), %rdi
callq 0xeb20
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1c4cb
jmp 0x1c4d4
movl $0x0, -0x4(%rbp)
jmp 0x1c4f9
jmp 0x1c4d6
jmp 0x1c4d8
jmp 0x1c4da
jmp 0x1c4dc
movq -0x18(%rbp), %rdi
callq 0xee40
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1c3ea
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::GenericValue(rapidjson::Type)
explicit GenericValue(Type type) RAPIDJSON_NOEXCEPT : data_() {
        static const uint16_t defaultFlags[] = {
            kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag,
            kNumberAnyFlag
        };
        RAPIDJSON_NOEXCEPT_ASSERT(type >= kNullType && type <= kNumberType);
        data_.f.flags = defaultFlags[type];

        // Use ShortString to store empty string.
        if (type == kStringType)
            data_.ss.SetLength(0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0xe510
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0xd(%rbp)
jl 0x1c938
cmpl $0x6, -0xc(%rbp)
setle %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x1c941
jmp 0x1c943
jmp 0x1c962
leaq 0x289b(%rip), %rdi      # 0x1f1e5
leaq 0x192d(%rip), %rsi      # 0x1e27e
movl $0x299, %edx            # imm = 0x299
leaq 0x28b1(%rip), %rcx      # 0x1f20e
callq 0xe600
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
movq 0xa616(%rip), %rcx      # 0x26f88
movw (%rcx,%rdx,2), %cx
movw %cx, 0xe(%rax)
cmpl $0x5, -0xc(%rbp)
jne 0x1c98f
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xf3e0
jmp 0x1c98d
jmp 0x1c98f
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x13150
nopl (%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/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 = static_cast<Member*>(allocator.Malloc(count * sizeof(Member)));
            SetMembersPointer(m);
            std::memcpy(static_cast<void*>(m), members, count * sizeof(Member));
        }
        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 0x1cae6
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
shlq $0x5, %rsi
callq 0xe1f0
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0xe950
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
shlq $0x5, %rdx
callq 0xe780
jmp 0x1caf3
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe950
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)
nop
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::SetArrayRaw(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*, unsigned int, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
void SetArrayRaw(GenericValue* values, SizeType count, Allocator& allocator) {
        data_.f.flags = kArrayFlag;
        if (count) {
            GenericValue* e = static_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));
            SetElementsPointer(e);
            std::memcpy(static_cast<void*>(e), values, count * sizeof(GenericValue));
        }
        else
            SetElementsPointer(0);
        data_.a.size = data_.a.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 $0x4, 0xe(%rax)
cmpl $0x0, -0x14(%rbp)
je 0x1cc26
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
shlq $0x4, %rsi
callq 0xe1f0
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0xf2d0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
shlq $0x4, %rdx
callq 0xe780
jmp 0x1cc33
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf2d0
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)
nop
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/strtod.h
// Function: rapidjson::internal::StrtodNormalPrecision(double, int)
inline double StrtodNormalPrecision(double d, int p) {
    if (p < -308) {
        // Prevent expSum < -308, making Pow10(p) = 0
        d = FastPath(d, -308);
        d = FastPath(d, p + 308);
    }
    else
        d = FastPath(d, p);
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
cmpl $0xfffffecc, -0xc(%rbp) # imm = 0xFFFFFECC
jge 0x1cdd7
movsd -0x8(%rbp), %xmm0
movl $0xfffffecc, %edi       # imm = 0xFFFFFECC
callq 0xee10
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movl -0xc(%rbp), %edi
addl $0x134, %edi            # imm = 0x134
callq 0xee10
movsd %xmm0, -0x8(%rbp)
jmp 0x1cde9
movsd -0x8(%rbp), %xmm0
movl -0xc(%rbp), %edi
callq 0xee10
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/strtod.h
// Function: rapidjson::internal::FastPath(double, int)
inline double FastPath(double significand, int exp) {
    if (exp < -308)
        return 0.0;
    else if (exp >= 0)
        return significand * internal::Pow10(exp);
    else
        return significand / internal::Pow10(-exp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x10(%rbp)
movl %edi, -0x14(%rbp)
cmpl $0xfffffecc, -0x14(%rbp) # imm = 0xFFFFFECC
jge 0x1cf73
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1cfc3
cmpl $0x0, -0x14(%rbp)
jl 0x1cf9e
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %edi
callq 0xebc0
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1cfc3
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
xorl %edi, %edi
subl -0x14(%rbp), %edi
callq 0xebc0
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::GenericValue(long)
explicit GenericValue(int64_t i64) RAPIDJSON_NOEXCEPT : data_() {
        data_.n.i64 = i64;
        data_.f.flags = kNumberInt64Flag;
        if (i64 >= 0) {
            data_.f.flags |= kNumberUint64Flag;
            if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
                data_.f.flags |= kUintFlag;
            if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
                data_.f.flags |= kIntFlag;
        }
        else if (i64 >= static_cast<int64_t>(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
            data_.f.flags |= kIntFlag;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0xe510
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movw $0x96, 0xe(%rax)
cmpq $0x0, -0x10(%rbp)
jl 0x1d112
movq -0x18(%rbp), %rax
movzwl 0xe(%rax), %ecx
orl $0x116, %ecx            # imm = 0x116
movw %cx, 0xe(%rax)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
jne 0x1d0f1
movq -0x18(%rbp), %rax
movzwl 0xe(%rax), %ecx
orl $0x40, %ecx
movw %cx, 0xe(%rax)
movq -0x10(%rbp), %rax
andq $-0x80000000, %rax      # imm = 0x80000000
cmpq $0x0, %rax
jne 0x1d110
movq -0x18(%rbp), %rax
movzwl 0xe(%rax), %ecx
orl $0x20, %ecx
movw %cx, 0xe(%rax)
jmp 0x1d12d
cmpq $-0x80000000, -0x10(%rbp) # imm = 0x80000000
jl 0x1d12b
movq -0x18(%rbp), %rax
movzwl 0xe(%rax), %ecx
orl $0x20, %ecx
movw %cx, 0xe(%rax)
jmp 0x1d12d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::GenericValue(unsigned long)
explicit GenericValue(uint64_t u64) RAPIDJSON_NOEXCEPT : data_() {
        data_.n.u64 = u64;
        data_.f.flags = kNumberUint64Flag;
        if (!(u64 & RAPIDJSON_UINT64_C2(0x80000000, 0x00000000)))
            data_.f.flags |= kInt64Flag;
        if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
            data_.f.flags |= kUintFlag;
        if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
            data_.f.flags |= kIntFlag;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0xe510
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movw $0x116, 0xe(%rax)       # imm = 0x116
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
jne 0x1d19b
movq -0x18(%rbp), %rax
movzwl 0xe(%rax), %ecx
orl $0x80, %ecx
movw %cx, 0xe(%rax)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
jne 0x1d1be
movq -0x18(%rbp), %rax
movzwl 0xe(%rax), %ecx
orl $0x40, %ecx
movw %cx, 0xe(%rax)
movq -0x10(%rbp), %rax
andq $-0x80000000, %rax      # imm = 0x80000000
cmpq $0x0, %rax
jne 0x1d1dd
movq -0x18(%rbp), %rax
movzwl 0xe(%rax), %ecx
orl $0x20, %ecx
movw %cx, 0xe(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)