LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/docker.cpp
// Function: param(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
std::string param( const std::string& param_name, int param_value){
    if(param_value != -1){
        std::ostringstream convert;
        convert << param_value;
        return "&" + param_name + "=" + convert.str();
    }
    else{
        return "";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xa61b
movl %edx, %r15d
movq %rsi, %r14
leaq -0x1f8(%rbp), %r12
movq %r12, %rdi
callq 0x98e0
movq %r12, %rdi
movl %r15d, %esi
callq 0x9bd0
leaq 0x6cb8(%rip), %rsi      # 0x1126a
leaq -0x60(%rbp), %rdi
movq %r14, %rdx
callq 0x94c0
leaq 0x6b8b(%rip), %rdx      # 0x11150
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x90b0
leaq -0x1f0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x9ac0
leaq -0x80(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x9470
leaq -0x40(%rbp), %rdi
callq 0x9240
leaq -0x80(%rbp), %rdi
callq 0x9240
leaq -0x60(%rbp), %rdi
callq 0x9240
leaq -0x1f8(%rbp), %rdi
callq 0x9100
jmp 0xa631
leaq 0x6c35(%rip), %rsi      # 0x11257
leaq -0x1f8(%rbp), %rdx
movq %rbx, %rdi
callq 0x9200
movq %rbx, %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x9240
jmp 0xa655
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x9240
jmp 0xa663
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x9240
jmp 0xa673
jmp 0xa670
movq %rax, %rbx
leaq -0x1f8(%rbp), %rdi
callq 0x9100
movq %rbx, %rdi
callq 0x9be0
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/docker.cpp
// Function: param(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string param( const std::string& param_name, const std::string& param_value){
    if(!param_value.empty()){
        return "&" + param_name + "=" + param_value;
    }
    else{
        return "";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdx)
je 0xa6ed
movq %rsi, %rdx
leaq 0x6bbf(%rip), %rsi      # 0x1126a
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x94c0
leaq 0x6a92(%rip), %rdx      # 0x11150
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x90b0
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x99d0
leaq -0x38(%rbp), %rdi
callq 0x9240
leaq -0x58(%rbp), %rdi
callq 0x9240
jmp 0xa700
leaq 0x6b63(%rip), %rsi      # 0x11257
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x9200
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x9240
jmp 0xa71f
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x9240
movq %rbx, %rdi
callq 0x9be0
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/docker.cpp
// Function: param(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>&)
std::string param( const std::string& param_name, JSON_DOCUMENT& param_value){
    if(param_value.IsObject()){
        std::string paramString;
        rapidjson::StringBuffer buffer;
        buffer.Clear();
        rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
        param_value.Accept(writer);
        paramString = std::string(buffer.GetString());
        return "&" + param_name + "=" + paramString;
    }
    else{
        return "";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r14
cmpw $0x3, 0xe(%rdx)
jne 0xa856
movq %rsi, %r15
leaq -0x70(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
xorps %xmm0, %xmm0
leaq -0xb0(%rbp), %rax
movaps %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movaps %xmm0, (%rax)
movq $0x100, 0x28(%rax)      # imm = 0x100
leaq -0xe8(%rbp), %rbx
movq %rax, -0x8(%rbx)
movups %xmm0, (%rbx)
andq $0x0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movq $0x200, 0x28(%rbx)      # imm = 0x200
movl $0x144, 0x30(%rbx)      # imm = 0x144
movb %cl, 0x34(%rbx)
leaq -0xf0(%rbp), %rsi
movq %rdx, %rdi
callq 0x9c40
leaq -0xb0(%rbp), %rdi
callq 0x9620
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
movq %rax, %rsi
callq 0x9200
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %r12
movq %r12, %rsi
callq 0x97b0
movq %r12, %rdi
callq 0x9240
leaq 0x6a75(%rip), %rsi      # 0x1126a
leaq -0x60(%rbp), %rdi
movq %r15, %rdx
callq 0x94c0
leaq 0x6948(%rip), %rdx      # 0x11150
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x90b0
leaq -0x40(%rbp), %rsi
leaq -0x80(%rbp), %rdx
movq %r14, %rdi
callq 0x99d0
leaq -0x40(%rbp), %rdi
callq 0x9240
leaq -0x60(%rbp), %rdi
callq 0x9240
movq %rbx, %rdi
callq 0x9ca0
leaq -0xb0(%rbp), %rdi
callq 0x9ca0
leaq -0x80(%rbp), %rdi
callq 0x9240
jmp 0xa86c
leaq 0x69fa(%rip), %rsi      # 0x11257
leaq -0xf0(%rbp), %rdx
movq %r14, %rdi
callq 0x9200
movq %r14, %rax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x9240
jmp 0xa890
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x9240
jmp 0xa8a4
jmp 0xa8a1
jmp 0xa8a1
jmp 0xa8a1
movq %rax, %r14
movq %rbx, %rdi
callq 0x9ca0
leaq -0xb0(%rbp), %rdi
callq 0x9ca0
leaq -0x80(%rbp), %rdi
callq 0x9240
movq %r14, %rdi
callq 0x9be0
nop
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/docker.cpp
// Function: Docker::delete_container(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool)
JSON_DOCUMENT Docker::delete_container(const std::string& container_id, bool v, bool force){
    std::string path = "/containers/" + container_id + "?";
    path += param("v", v);
    path += param("force", force);
    return requestAndParse(DELETE,path,204);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x59f0(%rip), %rsi      # 0x110fa
leaq -0x50(%rbp), %r13
movq %r13, %rdi
callq 0x94c0
leaq 0x5a77(%rip), %rdx      # 0x11194
leaq -0x90(%rbp), %rdi
movq %r13, %rsi
callq 0x90b0
leaq -0x50(%rbp), %rdi
callq 0x9240
leaq 0x5a48(%rip), %rsi      # 0x11184
leaq -0x70(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x9200
movzbl %r12b, %edx
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x94d0
leaq -0x90(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x9cf0
leaq -0x50(%rbp), %rdi
callq 0x9240
leaq -0x70(%rbp), %rdi
callq 0x9240
leaq 0x5a03(%rip), %rsi      # 0x11186
leaq -0x70(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x9200
movzbl %r15b, %edx
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x94d0
leaq -0x90(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x9cf0
leaq -0x50(%rbp), %rdi
callq 0x9240
leaq -0x70(%rbp), %rdi
callq 0x9240
andl $0x0, (%rsp)
movq 0xd7a2(%rip), %r9       # 0x18f70
pushq $0x2
popq %rdx
leaq -0x90(%rbp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0xcc, %r8d
callq 0x9940
leaq -0x90(%rbp), %rdi
callq 0x9240
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb82b
jmp 0xb80f
jmp 0xb81d
jmp 0xb82b
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x9240
jmp 0xb820
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x9240
jmp 0xb82e
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x9240
movq %rbx, %rdi
callq 0x9be0
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0xb835
nop
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/docker.cpp
// Function: param(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
std::string param( const std::string& param_name, const char* param_value){
    if(param_value != nullptr){
        return "&" + param_name + "=" + param_value;
    }
    else{
        return "";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0xbcad
movq %rsi, %rdx
leaq 0x55ff(%rip), %rsi      # 0x1126a
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x94c0
leaq 0x54d2(%rip), %rdx      # 0x11150
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x90b0
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x90b0
leaq -0x38(%rbp), %rdi
callq 0x9240
leaq -0x58(%rbp), %rdi
callq 0x9240
jmp 0xbcc0
leaq 0x55a3(%rip), %rsi      # 0x11257
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x9200
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x9240
jmp 0xbcdf
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x9240
movq %rbx, %rdi
callq 0x9be0
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/docker.cpp
// Function: jsonToString[abi:cxx11](rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>&)
std::string jsonToString(JSON_VALUE & doc){
    rapidjson::StringBuffer buffer;
    buffer.Clear();
    rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
    doc.Accept(writer);
    return std::string(buffer.GetString());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rcx
movaps %xmm0, 0x10(%rcx)
andq $0x0, 0x20(%rcx)
movaps %xmm0, (%rcx)
movq $0x100, 0x28(%rcx)      # imm = 0x100
leaq -0x88(%rbp), %r14
movq %rcx, -0x8(%r14)
movups %xmm0, (%r14)
andq $0x0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movq $0x200, 0x28(%r14)      # imm = 0x200
movl $0x144, 0x30(%r14)      # imm = 0x144
movb $0x0, 0x34(%r14)
leaq -0x90(%rbp), %rsi
movq %rax, %rdi
callq 0x9c40
leaq -0x50(%rbp), %rdi
callq 0x9620
leaq -0x11(%rbp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9200
movq %r14, %rdi
callq 0x9ca0
leaq -0x50(%rbp), %rdi
callq 0x9ca0
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xbd96
movq %rax, %rbx
movq %r14, %rdi
callq 0x9ca0
leaq -0x50(%rbp), %rdi
callq 0x9ca0
movq %rbx, %rdi
callq 0x9be0
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/stringbuffer.h
// Function: rapidjson::GenericStringBuffer<rapidjson::UTF8<char>, rapidjson::CrtAllocator>::GetString() const
const Ch* GetString() const {
        // Push and pop a null terminator. This is safe.
        *stack_.template Push<Ch>() = '\0';
        stack_.template Pop<Ch>(1);

        return stack_.template Bottom<Ch>();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %r14
movq %r14, %rsi
callq 0x95d0
movb $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x96c0
movq 0x10(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/allocators.h
// Function: rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>::Clear()
void Clear() {
        while (chunkHead_ && chunkHead_ != userBuffer_) {
            ChunkHeader* next = chunkHead_->next;
            baseAllocator_->Free(chunkHead_);
            chunkHead_ = next;
        }
        if (chunkHead_ && chunkHead_ == userBuffer_)
            chunkHead_->size = 0; // Clear user buffer
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x10(%rbx), %rax
testq %rdi, %rdi
je 0xc5f0
cmpq %rax, %rdi
je 0xc5f0
movq 0x10(%rdi), %r14
callq 0x9790
movq %r14, (%rbx)
movq %r14, %rdi
jmp 0xc5d1
cmpq %rax, %rdi
sete %al
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xc608
andq $0x0, 0x8(%rdi)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/stack.h
// Function: rapidjson::internal::Stack<rapidjson::CrtAllocator>::Stack(rapidjson::internal::Stack<rapidjson::CrtAllocator>&&)
Stack(Stack&& rhs)
        : allocator_(rhs.allocator_),
          ownAllocator_(rhs.ownAllocator_),
          stack_(rhs.stack_),
          stackTop_(rhs.stackTop_),
          stackEnd_(rhs.stackEnd_),
          initialCapacity_(rhs.initialCapacity_)
    {
        rhs.allocator_ = 0;
        rhs.ownAllocator_ = 0;
        rhs.stack_ = 0;
        rhs.stackTop_ = 0;
        rhs.stackEnd_ = 0;
        rhs.initialCapacity_ = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x18(%rsi), %rax
movq %rax, 0x18(%rdi)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsi)
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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>::EndObject(unsigned int)
bool EndObject(SizeType memberCount = 0) {
        (void)memberCount;
        RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level)); // not inside an Object
        RAPIDJSON_ASSERT(!level_stack_.template Top<Level>()->inArray); // currently inside an Array, not Object
        RAPIDJSON_ASSERT(0 == level_stack_.template Top<Level>()->valueCount % 2); // Object has a Key without a Value
        level_stack_.template Pop<Level>(1);
        return EndValue(WriteEndObject());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
cmpq $0xf, %rax
jbe 0xc7ce
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x92b0
cmpb $0x1, 0x8(%rax)
je 0xc7ed
movq %r14, %rdi
callq 0x92b0
testb $0x1, (%rax)
jne 0xc80c
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x9860
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9890
leaq 0x51aa(%rip), %rdi      # 0x1197f
leaq 0x4be8(%rip), %rsi      # 0x113c4
leaq 0x51c4(%rip), %rcx      # 0x119a7
movl $0xe9, %edx
callq 0x9380
leaq 0x52d7(%rip), %rdi      # 0x11acb
leaq 0x4bc9(%rip), %rsi      # 0x113c4
leaq 0x51a5(%rip), %rcx      # 0x119a7
movl $0xea, %edx
callq 0x9380
leaq 0x52e5(%rip), %rdi      # 0x11af8
leaq 0x4baa(%rip), %rsi      # 0x113c4
leaq 0x5186(%rip), %rcx      # 0x119a7
movl $0xeb, %edx
callq 0x9380
nop
// File: /workspace/github_cpp_makefile_star2_O2/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>::EndArray(unsigned int)
bool EndArray(SizeType elementCount = 0) {
        (void)elementCount;
        RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
        RAPIDJSON_ASSERT(level_stack_.template Top<Level>()->inArray);
        level_stack_.template Pop<Level>(1);
        return EndValue(WriteEndArray());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
cmpq $0xf, %rax
jbe 0xc8a1
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x92b0
cmpb $0x0, 0x8(%rax)
je 0xc8c0
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x9860
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9b50
leaq 0x50d7(%rip), %rdi      # 0x1197f
leaq 0x4b15(%rip), %rsi      # 0x113c4
leaq 0x547a(%rip), %rcx      # 0x11d30
movl $0xf8, %edx
callq 0x9380
leaq 0x5205(%rip), %rdi      # 0x11acc
leaq 0x4af6(%rip), %rsi      # 0x113c4
leaq 0x545b(%rip), %rcx      # 0x11d30
movl $0xf9, %edx
callq 0x9380
nop
// File: /workspace/github_cpp_makefile_star2_O2/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>::String(char const*, unsigned int, bool)
bool String(const Ch* str, SizeType length, bool copy = false) {
        RAPIDJSON_ASSERT(str != 0);
        (void)copy;
        Prefix(kStringType);
        return EndValue(WriteString(str, length));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xc916
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x5
popq %rsi
callq 0x9330
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x98d0
leaq 0x5536(%rip), %rdi      # 0x11e53
leaq 0x4aa0(%rip), %rsi      # 0x113c4
leaq 0x5531(%rip), %rcx      # 0x11e5c
movl $0xcc, %edx
callq 0x9380
nop
// File: /workspace/github_cpp_makefile_star2_O2/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>::Prefix(rapidjson::Type)
void Prefix(Type type) {
        (void)type;
        if (RAPIDJSON_LIKELY(level_stack_.GetSize() != 0)) { // this value is not at root
            Level* level = level_stack_.template Top<Level>();
            if (level->valueCount > 0) {
                if (level->inArray) 
                    os_->Put(','); // add comma if it is not the first element in array
                else  // in object
                    os_->Put((level->valueCount % 2 == 0) ? ',' : ':');
            }
            if (!level->inArray && level->valueCount % 2 == 0)
                RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
            level->valueCount++;
        }
        else {
            RAPIDJSON_ASSERT(!hasRoot_);    // Should only has one and only one root.
            hasRoot_ = true;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x20(%rdi), %rax
cmpq 0x18(%rdi), %rax
je 0xca5c
movl %esi, %ebx
leaq 0x8(%r15), %rdi
callq 0x92b0
movq %rax, %r14
movq (%rax), %rax
testq %rax, %rax
je 0xca34
cmpb $0x0, 0x8(%r14)
pushq $0x2c
popq %rcx
pushq $0x3a
popq %rsi
cmovnel %ecx, %esi
movq (%r15), %rdi
testb $0x1, %al
cmovel %ecx, %esi
callq 0x9050
movq (%r14), %rax
cmpb $0x0, 0x8(%r14)
jne 0xca4b
cmpl $0x5, %ebx
sete %cl
orb %al, %cl
testb $0x1, %cl
je 0xca6a
incq %rax
movq %rax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x1, 0x3c(%r15)
je 0xca89
movb $0x1, 0x3c(%r15)
jmp 0xca51
leaq 0x493f(%rip), %rdi      # 0x113b0
leaq 0x494c(%rip), %rsi      # 0x113c4
leaq 0x496a(%rip), %rcx      # 0x113e9
movl $0x1e4, %edx            # imm = 0x1E4
callq 0x9380
leaq 0x4a76(%rip), %rdi      # 0x11506
leaq 0x492d(%rip), %rsi      # 0x113c4
leaq 0x494b(%rip), %rcx      # 0x113e9
movl $0x1e8, %edx            # imm = 0x1E8
callq 0x9380
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/stack.h
// Function: char* rapidjson::internal::Stack<rapidjson::CrtAllocator>::PushUnsafe<char>(unsigned long)
RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) {
        RAPIDJSON_ASSERT(stackTop_);
        RAPIDJSON_ASSERT(static_cast<std::ptrdiff_t>(sizeof(T) * count) <= (stackEnd_ - stackTop_));
        T* ret = reinterpret_cast<T*>(stackTop_);
        stackTop_ += sizeof(T) * count;
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0xcba6
movq 0x20(%rdi), %rcx
subq %rax, %rcx
cmpq %rsi, %rcx
jl 0xcbc5
addq %rax, %rsi
movq %rsi, 0x18(%rdi)
popq %rbp
retq
leaq 0x4a5c(%rip), %rdi      # 0x11609
leaq 0x4973(%rip), %rsi      # 0x11527
leaq 0x4a58(%rip), %rcx      # 0x11613
movl $0x82, %edx
callq 0x9380
leaq 0x4ac2(%rip), %rdi      # 0x1168e
leaq 0x4954(%rip), %rsi      # 0x11527
leaq 0x4a39(%rip), %rcx      # 0x11613
movl $0x83, %edx
callq 0x9380
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/stack.h
// Function: void rapidjson::internal::Stack<rapidjson::CrtAllocator>::Expand<rapidjson::Writer<rapidjson::GenericStringBuffer<rapidjson::UTF8<char>, rapidjson::CrtAllocator>, rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator, 0u>::Level>(unsigned long)
void Expand(size_t count) {
        // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.
        size_t newCapacity;
        if (stack_ == 0) {
            if (!allocator_)
                ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
            newCapacity = initialCapacity_;
        } else {
            newCapacity = GetCapacity();
            newCapacity += (newCapacity + 1) / 2;
        }
        size_t newSize = GetSize() + sizeof(T) * count;
        if (newCapacity < newSize)
            newCapacity = newSize;

        Resize(newCapacity);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xce27
movq 0x20(%r14), %rdx
subq %rax, %rdx
leaq 0x1(%rdx), %rcx
shrq %rcx
addq %rdx, %rcx
jmp 0xce42
cmpq $0x0, (%r14)
jne 0xce3c
pushq $0x1
popq %rdi
callq 0x9570
movq %rax, (%r14)
movq %rax, 0x8(%r14)
movq 0x28(%r14), %rcx
xorl %eax, %eax
shlq $0x4, %rbx
subq %rax, %rbx
addq 0x18(%r14), %rbx
cmpq %rbx, %rcx
cmovaq %rcx, %rbx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x9b90
nop
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/stack.h
// Function: rapidjson::internal::Stack<rapidjson::CrtAllocator>::Resize(unsigned long)
void Resize(size_t newCapacity) {
        const size_t size = GetSize();  // Backup the current size
        stack_ = static_cast<char*>(allocator_->Realloc(stack_, GetCapacity(), newCapacity));
        stackTop_ = stack_ + size;
        stackEnd_ = stack_ + newCapacity;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
movq (%rdi), %rdi
movq 0x10(%r14), %rsi
subq %rsi, %r15
movq 0x20(%r14), %rdx
subq %rsi, %rdx
movq %rbx, %rcx
callq 0x9590
movq %rax, 0x10(%r14)
addq %rax, %r15
movq %r15, 0x18(%r14)
addq %rbx, %rax
movq %rax, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/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) {
            std::free(originalPtr);
            return NULL;
        }
        return std::realloc(originalPtr, newSize);
    }

// Assembly:
movq %rsi, %rdi
testq %rcx, %rcx
je 0xcca0
movq %rcx, %rsi
jmp 0x9b10
pushq %rbp
movq %rsp, %rbp
callq 0x9790
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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>::WriteBool(bool)
bool WriteBool(bool b)  {
        if (b) {
            PutReserve(*os_, 4);
            PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'r'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'e');
        }
        else {
            PutReserve(*os_, 5);
            PutUnsafe(*os_, 'f'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 's'); PutUnsafe(*os_, 'e');
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testl %esi, %esi
je 0xccee
pushq $0x4
popq %rsi
callq 0x9990
movb $0x75, %r14b
movb $0x72, %r15b
movb $0x74, %al
jmp 0xcd09
pushq $0x5
popq %rsi
callq 0x9990
movq (%rbx), %rdi
pushq $0x66
popq %rsi
callq 0x9ba0
movb $0x73, %r14b
movb $0x6c, %r15b
movb $0x61, %al
movq (%rbx), %rdi
movzbl %al, %esi
callq 0x9ba0
movq (%rbx), %rdi
movzbl %r15b, %esi
callq 0x9ba0
movq (%rbx), %rdi
movzbl %r14b, %esi
callq 0x9ba0
movq (%rbx), %rdi
pushq $0x65
popq %rsi
callq 0x9ba0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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>::WriteDouble(double)
inline bool Writer<StringBuffer>::WriteDouble(double d) {
    if (internal::Double(d).IsNanOrInf()) {
        // Note: This code path can only be reached if (RAPIDJSON_WRITE_DEFAULT_FLAGS & kWriteNanAndInfFlag).
        if (!(kWriteDefaultFlags & kWriteNanAndInfFlag))
            return false;
        if (internal::Double(d).IsNan()) {
            PutReserve(*os_, 3);
            PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N');
            return true;
        }
        if (internal::Double(d).Sign()) {
            PutReserve(*os_, 9);
            PutUnsafe(*os_, '-');
        }
        else
            PutReserve(*os_, 8);
        PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f');
        PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y');
        return true;
    }
    
    char *buffer = os_->Push(25);
    char* end = internal::dtoa(d, buffer, maxDecimalPlaces_);
    os_->Pop(static_cast<size_t>(25 - (end - buffer)));
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %xmm0, %r15
btrq $0x3f, %r15
movabsq $0x7fefffffffffffff, %rax # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rax, %r15
jg 0xd0e7
movq %rdi, %rbx
movq (%rdi), %rdi
pushq $0x19
popq %rsi
movq %xmm0, -0x20(%rbp)
callq 0x95d0
movq %rax, %r14
movl 0x38(%rbx), %esi
movq -0x20(%rbp), %xmm0
movq %rax, %rdi
callq 0x92f0
movq (%rbx), %rdi
subq %rax, %r14
addq $0x19, %r14
movq %r14, %rsi
callq 0x96c0
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
cmpq %rax, %r15
setl %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/dtoa.h
// Function: rapidjson::internal::dtoa(double, char*, int)
inline char* dtoa(double value, char* buffer, int maxDecimalPlaces = 324) {
    RAPIDJSON_ASSERT(maxDecimalPlaces >= 1);
    Double d(value);
    if (d.IsZero()) {
        if (d.Sign())
            *buffer++ = '-';     // -0.0, Issue #289
        buffer[0] = '0';
        buffer[1] = '.';
        buffer[2] = '0';
        return &buffer[3];
    }
    else {
        if (value < 0) {
            *buffer++ = '-';
            value = -value;
        }
        int length, K;
        Grisu2(value, buffer, &length, &K);
        return Prettify(buffer, length, K, maxDecimalPlaces);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testl %esi, %esi
jle 0xd199
movq %rdi, %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xd147
jp 0xd147
movq %xmm0, %rax
testq %rax, %rax
jns 0xd138
movb $0x2d, (%rbx)
incq %rbx
movw $0x2e30, (%rbx)         # imm = 0x2E30
movb $0x30, 0x2(%rbx)
addq $0x3, %rbx
jmp 0xd189
movl %esi, %r14d
ucomisd %xmm0, %xmm1
jbe 0xd15e
movb $0x2d, (%rbx)
incq %rbx
xorpd 0x3ec2(%rip), %xmm0     # 0x11020
leaq -0x28(%rbp), %r15
leaq -0x24(%rbp), %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x9960
movl (%r15), %esi
movl (%r12), %edx
movq %rbx, %rdi
movl %r14d, %ecx
callq 0x95b0
movq %rax, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4def(%rip), %rdi      # 0x11f8f
leaq 0x4dfe(%rip), %rsi      # 0x11fa5
leaq 0x4e23(%rip), %rcx      # 0x11fd1
movl $0xd9, %edx
callq 0x9380
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/dtoa.h
// Function: rapidjson::internal::Grisu2(double, char*, int*, int*)
inline void Grisu2(double value, char* buffer, int* length, int* K) {
    const DiyFp v(value);
    DiyFp w_m, w_p;
    v.NormalizedBoundaries(&w_m, &w_p);

    const DiyFp c_mk = GetCachedPower(w_p.e, K);
    const DiyFp W = v.Normalize() * c_mk;
    DiyFp Wp = w_p * c_mk;
    DiyFp Wm = w_m * c_mk;
    Wm.f++;
    Wp.f--;
    DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rdx, -0x30(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %xmm0, %rax
movq %rax, %rcx
shrq $0x34, %rcx
andl $0x7ff, %ecx            # imm = 0x7FF
movabsq $0xfffffffffffff, %rdx  # imm = 0xFFFFFFFFFFFFF
andq %rdx, %rax
leal -0x433(%rcx), %esi
testl %ecx, %ecx
leaq 0x1(%rax,%rdx), %rcx
cmoveq %rax, %rcx
movl $0xfffffbce, %eax       # imm = 0xFFFFFBCE
cmovnel %esi, %eax
leaq -0xa0(%rbp), %r15
leaq -0x90(%rbp), %r12
andq $0x0, (%r12)
movq %rcx, (%r15)
andl $0x0, 0x8(%r12)
leaq -0x80(%rbp), %r13
andq $0x0, (%r13)
movl %eax, 0x8(%r15)
andl $0x0, 0x8(%r13)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x9a50
movl 0x8(%r13), %edi
movq %rbx, %rsi
callq 0x99b0
leaq -0x70(%rbp), %r14
movq %rax, (%r14)
movl %edx, 0x8(%r14)
movq (%r15), %rax
bsrq %rax, %rcx
xorq $0x3f, %rcx
shlq %cl, %rax
movl 0x8(%r15), %edx
subl %ecx, %edx
leaq -0x50(%rbp), %r15
movq %rax, (%r15)
movl %edx, 0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x9650
leaq -0x60(%rbp), %rbx
movq %rax, (%rbx)
movl %edx, 0x8(%rbx)
movq %r13, %rdi
movq %r14, %rsi
callq 0x9650
movq %rax, %r13
movl %edx, 0x8(%r15)
movq %r12, %rdi
movq %r14, %rsi
callq 0x9650
notq %rax
leaq -0x1(%r13), %rcx
movq %rcx, (%r15)
leaq (%rax,%r13), %rdx
decq %rdx
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x9bf0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/diyfp.h
// Function: rapidjson::internal::DiyFp::NormalizedBoundaries(rapidjson::internal::DiyFp*, rapidjson::internal::DiyFp*) const
void NormalizedBoundaries(DiyFp* minus, DiyFp* plus) const {
        DiyFp pl = DiyFp((f << 1) + 1, e - 1).NormalizeBoundary();
        DiyFp mi = (f == kDpHiddenBit) ? DiyFp((f << 2) - 1, e - 2) : DiyFp((f << 1) - 1, e - 1);
        mi.f <<= mi.e - pl.e;
        mi.e = pl.e;
        *plus = pl;
        *minus = mi;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rax
leaq 0x1(,%rax,2), %rax
movl 0x8(%rdi), %ecx
decl %ecx
leaq -0x28(%rbp), %rdi
movq %rax, (%rdi)
movl %ecx, 0x8(%rdi)
callq 0x9680
movq (%r15), %rsi
movabsq $0x10000000000000, %rdi # imm = 0x10000000000000
xorl %ecx, %ecx
cmpq %rdi, %rsi
sete %cl
leaq -0x1(%rsi,%rsi), %rsi
movabsq $0x3fffffffffffff, %rdi # imm = 0x3FFFFFFFFFFFFF
cmovneq %rsi, %rdi
notl %ecx
addl 0x8(%r15), %ecx
subl %edx, %ecx
shlq %cl, %rdi
movq %rax, (%r14)
movl %edx, 0x8(%r14)
movq %rdi, (%rbx)
movl %edx, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/diyfp.h
// Function: rapidjson::internal::GetCachedPower(int, int*)
inline DiyFp GetCachedPower(int e, int* K) {

    //int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
    double dk = (-61 - e) * 0.30102999566398114 + 347;  // dk must be positive, so can do ceiling in positive
    int k = static_cast<int>(dk);
    if (dk - k > 0.0)
        k++;

    unsigned index = static_cast<unsigned>((k >> 3) + 1);
    *K = -(-348 + static_cast<int>(index << 3));    // decimal exponent no need lookup table

    return GetCachedPowerByIndex(index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xffffffc3, %eax       # imm = 0xFFFFFFC3
subl %edi, %eax
cvtsi2sd %eax, %xmm0
mulsd 0x3b01(%rip), %xmm0     # 0x11050
addsd 0x3b01(%rip), %xmm0     # 0x11058
cvttsd2si %xmm0, %eax
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
xorl %edi, %edi
ucomisd %xmm1, %xmm0
seta %dil
addl %eax, %edi
sarl $0x3, %edi
leal 0x8(,%rdi,8), %eax
incl %edi
movl $0x15c, %ecx            # imm = 0x15C
subl %eax, %ecx
movl %ecx, (%rsi)
popq %rbp
jmp 0x9280
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/diyfp.h
// Function: rapidjson::internal::DiyFp::NormalizeBoundary() const
DiyFp NormalizeBoundary() const {
        DiyFp res = *this;
        while (!(res.f & (kDpHiddenBit << 1))) {
            res.f <<= 1;
            res.e--;
        }
        res.f <<= (kDiySignificandSize - kDpSignificandSize - 2);
        res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2);
        return res;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movl 0x8(%rdi), %edx
addl $-0xa, %edx
btq $0x35, %rax
jb 0xd7f7
addq %rax, %rax
decl %edx
jmp 0xd7e9
shlq $0xa, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpl $0xa, %edi
jae 0xd84d
movl $0x1, %eax
jmp 0xd8b2
cmpl $0x64, %edi
jae 0xd859
movl $0x2, %eax
jmp 0xd8b2
cmpl $0x3e8, %edi            # imm = 0x3E8
jae 0xd868
movl $0x3, %eax
jmp 0xd8b2
cmpl $0x2710, %edi           # imm = 0x2710
jae 0xd877
movl $0x4, %eax
jmp 0xd8b2
cmpl $0x186a0, %edi          # imm = 0x186A0
jae 0xd886
movl $0x5, %eax
jmp 0xd8b2
cmpl $0xf4240, %edi          # imm = 0xF4240
jae 0xd895
movl $0x6, %eax
jmp 0xd8b2
cmpl $0x989680, %edi         # imm = 0x989680
jae 0xd8a4
movl $0x7, %eax
jmp 0xd8b2
cmpl $0x5f5e100, %edi        # imm = 0x5F5E100
movl $0x9, %eax
sbbl $0x0, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movslq %esi, %rax
subq %rcx, %rdx
movq %r8, %rsi
subq %r9, %rsi
movq %r9, %r10
subq %rcx, %r10
cmpq %r9, %rcx
jae 0xd8f1
subq %r8, %rdx
jb 0xd8f1
leaq (%rcx,%r8), %r11
cmpq %r9, %r11
jb 0xd8e5
addq %rsi, %rcx
cmpq %rcx, %r10
jbe 0xd8f1
decb -0x1(%rdi,%rax)
subq %r8, %r10
movq %r11, %rcx
jmp 0xd8ca
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
testl %edi, %edi
jns 0xd903
movb $0x2d, (%rsi)
incq %rsi
negl %edi
cmpl $0x64, %edi
jb 0xd92c
movl $0x64, %ecx
movl %edi, %eax
xorl %edx, %edx
divl %ecx
addb $0x30, %al
movb %al, (%rsi)
movq 0xb64a(%rip), %rax      # 0x18f68
movzwl (%rax,%rdx,2), %eax
movw %ax, 0x1(%rsi)
addq $0x3, %rsi
jmp 0xd951
cmpl $0xa, %edi
jb 0xd947
movl %edi, %eax
movq 0xb62e(%rip), %rcx      # 0x18f68
movzwl (%rcx,%rax,2), %eax
movw %ax, (%rsi)
addq $0x2, %rsi
jmp 0xd951
orb $0x30, %dil
movb %dil, (%rsi)
incq %rsi
movq %rsi, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
pushq $0xb
popq %rsi
callq 0x95d0
movq %rax, %r15
movl %ebx, %edi
movq %rax, %rsi
callq 0x9950
movq (%r14), %rdi
subq %rax, %r15
addq $0xb, %r15
movq %r15, %rsi
callq 0x96c0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
testq %rsi, %rsi
je 0xd9f2
testl %edi, %edi
jns 0x9cb0
movb $0x2d, (%rsi)
incq %rsi
negl %edi
jmp 0x9cb0
pushq %rbp
movq %rsp, %rbp
leaq 0x46ee(%rip), %rdi      # 0x120eb
leaq 0x46f3(%rip), %rsi      # 0x120f7
leaq 0x4718(%rip), %rcx      # 0x12123
pushq $0x74
popq %rdx
callq 0x9380
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
pushq $0xa
popq %rsi
callq 0x95d0
movq %rax, %r15
movl %ebx, %edi
movq %rax, %rsi
callq 0x9cb0
movq (%r14), %rdi
subq %rax, %r15
addq $0xa, %r15
movq %r15, %rsi
callq 0x96c0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
pushq $0x15
popq %rsi
callq 0x95d0
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x91a0
movq (%r14), %rdi
subq %rax, %r15
addq $0x15, %r15
movq %r15, %rsi
callq 0x96c0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
testq %rsi, %rsi
je 0xdd1c
testq %rdi, %rdi
jns 0x91b0
movb $0x2d, (%rsi)
incq %rsi
negq %rdi
jmp 0x91b0
pushq %rbp
movq %rsp, %rbp
leaq 0x43c4(%rip), %rdi      # 0x120eb
leaq 0x43c9(%rip), %rsi      # 0x120f7
leaq 0x4455(%rip), %rcx      # 0x1218a
movl $0x127, %edx            # imm = 0x127
callq 0x9380
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
pushq $0x14
popq %rsi
callq 0x95d0
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x91b0
movq (%r14), %rdi
subq %rax, %r15
addq $0x14, %r15
movq %r15, %rsi
callq 0x96c0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpw $0x3, 0xe(%rdi)
jne 0xe3fa
movq %rsi, %r15
testb $0x4, 0xf(%rsi)
je 0xe419
movq %rdx, %r14
movq %rdi, %rbx
movl (%rdi), %eax
movl 0x4(%rdi), %edx
cmpl %edx, %eax
jb 0xe3b3
leal 0x1(%rdx), %eax
shrl %eax
addl %edx, %eax
testl %edx, %edx
pushq $0x10
popq %rsi
cmovnel %eax, %esi
movq %rbx, %rdi
movq %rcx, %rdx
callq 0x9260
movl (%rbx), %eax
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rbx), %rcx
movl %eax, %eax
shlq $0x5, %rax
movups (%r15), %xmm0
movups %xmm0, (%rcx,%rax)
andw $0x0, 0xe(%r15)
movl (%rbx), %eax
shlq $0x5, %rax
movups (%r14), %xmm0
movups %xmm0, 0x10(%rcx,%rax)
andw $0x0, 0xe(%r14)
incl (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3399(%rip), %rdi      # 0x1179a
leaq 0x2e82(%rip), %rsi      # 0x1128a
leaq 0x3f62(%rip), %rcx      # 0x12371
movl $0x526, %edx            # imm = 0x526
callq 0x9380
leaq 0x2e5a(%rip), %rdi      # 0x1127a
leaq 0x2e63(%rip), %rsi      # 0x1128a
leaq 0x3f43(%rip), %rcx      # 0x12371
movl $0x527, %edx            # imm = 0x527
callq 0x9380
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
cmpw $0x3, 0xe(%rdi)
jne 0xe492
movl %esi, %r14d
movq %rdi, %rbx
movl 0x4(%rdi), %eax
cmpl %esi, %eax
jae 0xe48a
movabsq $0xffffffffffff, %rsi   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rbx), %rsi
shlq $0x5, %rax
movl %r14d, %ecx
shlq $0x5, %rcx
movq %rdx, %rdi
movq %rax, %rdx
callq 0x9880
movzwl 0xe(%rbx), %ecx
shlq $0x30, %rcx
orq %rax, %rcx
movq %rcx, 0x8(%rbx)
movl %r14d, 0x4(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3301(%rip), %rdi      # 0x1179a
leaq 0x2dea(%rip), %rsi      # 0x1128a
leaq 0x3fc7(%rip), %rcx      # 0x1246e
movl $0x4b9, %edx            # imm = 0x4B9
callq 0x9380
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xe524
testq %rcx, %rcx
je 0xe530
movq %rdx, %r14
movq %rsi, %rbx
addq $0x7, %r14
andq $-0x8, %r14
addq $0x7, %rcx
andq $-0x8, %rcx
movq %rcx, %rsi
subq %r14, %rsi
jbe 0xe532
movq (%rdi), %rax
movq 0x8(%rax), %rdx
leaq (%rax,%rdx), %r8
subq %r14, %r8
addq $0x18, %r8
cmpq %rbx, %r8
jne 0xe500
addq %rsi, %rdx
cmpq (%rax), %rdx
jbe 0xe53f
movq %rcx, %rsi
callq 0x9140
testq %rax, %rax
je 0xe530
testq %r14, %r14
je 0xe53a
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x9430
movq %rcx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x9140
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
jmp 0xe532
movq %rdx, 0x8(%rax)
jmp 0xe532
nop