LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tdv[P]boss/boss/examples/multy_object/main.cpp
// Function: FuncForIFace1(MyNs::IFaces::IFace1*)
void FuncForIFace1(MyNs::IFaces::IFace1 *obj)
{
  if (!obj)
  {
    std::cerr << "No object." << std::endl;
    return;
  }
  if (obj->Method1() != Boss::Status::Ok)
    std::cout << "Failed to call IFace1::Method1" << std::endl;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x17240
leaq 0xe40bd(%rip), %rdi     # 0xfb2e0
leaq 0xa6e3e(%rip), %rsi     # 0xbe068
callq 0x840a0
movq %rax, %rdi
leaq 0x6c747(%rip), %rsi     # 0x83980
callq 0x82b90
jmp 0x17271
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x0, %eax
je 0x17271
leaq 0xe41aa(%rip), %rdi     # 0xfb400
leaq 0xa6e16(%rip), %rsi     # 0xbe073
callq 0x840a0
movq %rax, %rdi
leaq 0x6c714(%rip), %rsi     # 0x83980
callq 0x82b90
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: tdv[P]boss/boss/examples/multy_object/main.cpp
// Function: FuncForIFace2(MyNs::IFaces::IFace2*)
void FuncForIFace2(MyNs::IFaces::IFace2 *obj)
{
  if (!obj)
  {
    std::cerr << "No object." << std::endl;
    return;
  }
  if (obj->Method2() != Boss::Status::Ok)
    std::cout << "Failed to call IFace2::Method2" << std::endl;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x172b0
leaq 0xe404d(%rip), %rdi     # 0xfb2e0
leaq 0xa6dce(%rip), %rsi     # 0xbe068
callq 0x840a0
movq %rax, %rdi
leaq 0x6c6d7(%rip), %rsi     # 0x83980
callq 0x82b90
jmp 0x172e1
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x0, %eax
je 0x172e1
leaq 0xe413a(%rip), %rdi     # 0xfb400
leaq 0xa6dc5(%rip), %rsi     # 0xbe092
callq 0x840a0
movq %rax, %rdi
leaq 0x6c6a4(%rip), %rsi     # 0x83980
callq 0x82b90
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: tdv[P]boss/boss/examples/multy_object/main.cpp
// Function: FuncForIFace3(MyNs::IFaces::IFace3*)
void FuncForIFace3(MyNs::IFaces::IFace3 *obj)
{
  if (!obj)
  {
    std::cerr << "No object." << std::endl;
    return;
  }
  if (obj->Method3() != Boss::Status::Ok)
    std::cout << "Failed to call IFace3::Method3" << std::endl;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x17320
leaq 0xe3fdd(%rip), %rdi     # 0xfb2e0
leaq 0xa6d5e(%rip), %rsi     # 0xbe068
callq 0x840a0
movq %rax, %rdi
leaq 0x6c667(%rip), %rsi     # 0x83980
callq 0x82b90
jmp 0x17351
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
cmpl $0x0, %eax
je 0x17351
leaq 0xe40ca(%rip), %rdi     # 0xfb400
leaq 0xa6d74(%rip), %rsi     # 0xbe0b1
callq 0x840a0
movq %rax, %rdi
leaq 0x6c634(%rip), %rsi     # 0x83980
callq 0x82b90
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: tdv[P]boss/boss/examples/multy_object/main.cpp
// Function: FuncForIFace4(MyNs::IFaces::IFace4*)
void FuncForIFace4(MyNs::IFaces::IFace4 *obj)
{
  if (!obj)
  {
    std::cerr << "No object." << std::endl;
    return;
  }
  if (obj->Method4() != Boss::Status::Ok)
    std::cout << "Failed to call IFace4::Method4" << std::endl;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x17390
leaq 0xe3f6d(%rip), %rdi     # 0xfb2e0
leaq 0xa6cee(%rip), %rsi     # 0xbe068
callq 0x840a0
movq %rax, %rdi
leaq 0x6c5f7(%rip), %rsi     # 0x83980
callq 0x82b90
jmp 0x173c1
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x0, %eax
je 0x173c1
leaq 0xe405a(%rip), %rdi     # 0xfb400
leaq 0xa6d23(%rip), %rsi     # 0xbe0d0
callq 0x840a0
movq %rax, %rdi
leaq 0x6c5c4(%rip), %rsi     # 0x83980
callq 0x82b90
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: tdv[P]boss/boss/examples/multy_object/main.cpp
// Function: main
int main()
{
  try
  {
    auto Obj = Boss::Base<MyNs::Impl::Face_1_2_3_4>::Create();
    FuncForIFace1(Boss::RefObjQIPtr<MyNs::IFaces::IFace1>(Obj).Get());
    FuncForIFace2(Boss::RefObjQIPtr<MyNs::IFaces::IFace2>(Obj).Get());
    FuncForIFace3(Boss::RefObjQIPtr<MyNs::IFaces::IFace3>(Obj).Get());
    FuncForIFace4(Boss::RefObjQIPtr<MyNs::IFaces::IFace4>(Obj).Get());
  }
  catch (std::exception const &e)
  {
    std::cerr << "Error: " << e.what() << std::endl;
  }
  return 0;
}

// Assembly:
subq $0x78, %rsp
movl $0x0, 0x74(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x176b0
jmp 0x173e8
leaq 0x50(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x177a0
jmp 0x173f9
leaq 0x50(%rsp), %rdi
callq 0x177f0
movq %rax, 0x28(%rsp)
jmp 0x1740a
movq 0x28(%rsp), %rdi
callq 0x17210
jmp 0x17416
leaq 0x50(%rsp), %rdi
callq 0x17800
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x17820
jmp 0x17431
leaq 0x48(%rsp), %rdi
callq 0x17870
movq %rax, 0x20(%rsp)
jmp 0x17442
movq 0x20(%rsp), %rdi
callq 0x17280
jmp 0x1744e
leaq 0x48(%rsp), %rdi
callq 0x17880
leaq 0x40(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x178a0
jmp 0x17469
leaq 0x40(%rsp), %rdi
callq 0x178f0
movq %rax, 0x18(%rsp)
jmp 0x1747a
movq 0x18(%rsp), %rdi
callq 0x172f0
jmp 0x17486
leaq 0x40(%rsp), %rdi
callq 0x17900
leaq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x17920
jmp 0x174a1
leaq 0x38(%rsp), %rdi
callq 0x17970
movq %rax, 0x10(%rsp)
jmp 0x174b2
movq 0x10(%rsp), %rdi
callq 0x17360
jmp 0x174be
leaq 0x38(%rsp), %rdi
callq 0x17980
leaq 0x68(%rsp), %rdi
callq 0x179a0
jmp 0x175d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x1756a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x17560
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x17800
jmp 0x17560
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x17880
jmp 0x17560
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x17900
jmp 0x17560
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x17980
leaq 0x68(%rsp), %rdi
callq 0x179a0
movl 0x5c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x175f6
movq 0x60(%rsp), %rdi
callq 0x1a0d0
movq %rax, 0x30(%rsp)
leaq 0xe3d53(%rip), %rdi     # 0xfb2e0
leaq 0xa6b5b(%rip), %rsi     # 0xbe0ef
callq 0x840a0
movq %rax, 0x8(%rsp)
jmp 0x175a0
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x840a0
movq %rax, (%rsp)
jmp 0x175c1
movq (%rsp), %rdi
leaq 0x6c3b4(%rip), %rsi     # 0x83980
callq 0x82b90
jmp 0x175d3
callq 0x1a140
xorl %eax, %eax
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x1a140
jmp 0x175f4
jmp 0x175f6
movq 0x60(%rsp), %rdi
callq 0xbaa50
movq %rax, %rdi
callq 0x179c0
nopl (%rax,%rax)
// File: cqbqdd11519[P]DockerClient/docker.cpp
// Function: param(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
std::string param( const std::string& param_name, bool param_value){
    std::string ret;
    ret = "&" + param_name + "=";
    if(param_value){
        return ret + "true";
    }
    else{
        return ret + "false";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xeeb0
movq -0x10(%rbp), %rdx
leaq 0xde8f(%rip), %rsi      # 0x1e25e
leaq -0x78(%rbp), %rdi
callq 0xe860
jmp 0x103da
leaq 0xdd63(%rip), %rdx      # 0x1e144
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xe150
jmp 0x103f0
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xeca0
leaq -0x58(%rbp), %rdi
callq 0xe5d0
leaq -0x78(%rbp), %rdi
callq 0xe5d0
testb $0x1, -0x11(%rbp)
je 0x10465
movq -0x98(%rbp), %rdi
leaq 0xde3d(%rip), %rdx      # 0x1e260
leaq -0x38(%rbp), %rsi
callq 0xed40
jmp 0x1042e
movl $0x1, -0x88(%rbp)
jmp 0x10488
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x104a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xe5d0
jmp 0x104a1
movq -0x98(%rbp), %rdi
leaq 0xddf2(%rip), %rdx      # 0x1e265
leaq -0x38(%rbp), %rsi
callq 0xed40
jmp 0x1047e
movl $0x1, -0x88(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xe5d0
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0xe5d0
movq -0x80(%rbp), %rdi
callq 0xf2f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x218(%rbp)
movq %rdi, %rax
movq %rax, -0x210(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x10630
leaq -0x190(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0xee00
movq -0x220(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xf2b0
jmp 0x10515
movq -0x10(%rbp), %rdx
leaq 0xdd3e(%rip), %rsi      # 0x1e25e
leaq -0x1e0(%rbp), %rdi
callq 0xe860
jmp 0x1052e
leaq 0xdc0f(%rip), %rdx      # 0x1e144
leaq -0x1c0(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0xe150
jmp 0x1054a
leaq -0x200(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0xea20
jmp 0x1055f
movq -0x218(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
leaq -0x200(%rbp), %rdx
callq 0xe7e0
jmp 0x1057b
leaq -0x200(%rbp), %rdi
callq 0xe5d0
leaq -0x1c0(%rbp), %rdi
callq 0xe5d0
leaq -0x1e0(%rbp), %rdi
callq 0xe5d0
leaq -0x190(%rbp), %rdi
callq 0xe1a0
jmp 0x1068d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x10622
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x10616
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x1060a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x200(%rbp), %rdi
callq 0xe5d0
leaq -0x1c0(%rbp), %rdi
callq 0xe5d0
leaq -0x1e0(%rbp), %rdi
callq 0xe5d0
leaq -0x190(%rbp), %rdi
callq 0xe1a0
jmp 0x1069d
leaq -0x201(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0xf300
movq -0x218(%rbp), %rdi
movq -0x228(%rbp), %rdx
leaq 0xdbf3(%rip), %rsi      # 0x1e24b
callq 0xee50
jmp 0x1065f
leaq -0x201(%rbp), %rdi
callq 0xeac0
jmp 0x1068d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x201(%rbp), %rdi
callq 0xeac0
jmp 0x1069d
movq -0x210(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0xf2f0
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf1c0
testb $0x1, %al
jne 0x10766
movq -0x10(%rbp), %rdx
leaq 0xdb70(%rip), %rsi      # 0x1e25e
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xe860
movq -0x80(%rbp), %rsi
leaq 0xda3e(%rip), %rdx      # 0x1e144
leaq -0x38(%rbp), %rdi
callq 0xe150
jmp 0x10711
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0xefc0
jmp 0x10724
leaq -0x38(%rbp), %rdi
callq 0xe5d0
leaq -0x58(%rbp), %rdi
callq 0xe5d0
jmp 0x107b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x1075b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xe5d0
leaq -0x58(%rbp), %rdi
callq 0xe5d0
jmp 0x107be
leaq -0x65(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xf300
movq -0x78(%rbp), %rdi
movq -0x88(%rbp), %rdx
leaq 0xdac3(%rip), %rsi      # 0x1e24b
callq 0xee50
jmp 0x1078f
leaq -0x65(%rbp), %rdi
callq 0xeac0
jmp 0x107b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x65(%rbp), %rdi
callq 0xeac0
jmp 0x107be
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xf2f0
nopw (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12e60
movq -0x10(%rbp), %rdx
leaq 0xb476(%rip), %rsi      # 0x1e25e
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xe860
movq -0x80(%rbp), %rsi
leaq 0xb344(%rip), %rdx      # 0x1e144
leaq -0x38(%rbp), %rdi
callq 0xe150
jmp 0x12e0b
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0xe150
jmp 0x12e1e
leaq -0x38(%rbp), %rdi
callq 0xe5d0
leaq -0x58(%rbp), %rdi
callq 0xe5d0
jmp 0x12eab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x12e55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xe5d0
leaq -0x58(%rbp), %rdi
callq 0xe5d0
jmp 0x12eb8
leaq -0x65(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xf300
movq -0x78(%rbp), %rdi
movq -0x88(%rbp), %rdx
leaq 0xb3c9(%rip), %rsi      # 0x1e24b
callq 0xee50
jmp 0x12e89
leaq -0x65(%rbp), %rdi
callq 0xeac0
jmp 0x12eab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x65(%rbp), %rdi
callq 0xeac0
jmp 0x12eb8
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xf2f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movl $0x100, %edx            # imm = 0x100
callq 0xf340
movq -0xa0(%rbp), %rdi
callq 0xe4c0
jmp 0x12f1b
xorl %eax, %eax
movl %eax, %edx
leaq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x20, %ecx
callq 0xf250
jmp 0x12f36
movq -0x10(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xf400
jmp 0x12f48
leaq -0x40(%rbp), %rdi
callq 0xeab0
movq %rax, -0xb8(%rbp)
jmp 0x12f5a
leaq -0x91(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xf300
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
callq 0xee50
jmp 0x12f89
leaq -0x91(%rbp), %rdi
callq 0xeac0
leaq -0x90(%rbp), %rdi
callq 0xe970
leaq -0x40(%rbp), %rdi
callq 0xe220
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x12ffa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x12fee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x91(%rbp), %rdi
callq 0xeac0
leaq -0x90(%rbp), %rdi
callq 0xe970
leaq -0x40(%rbp), %rdi
callq 0xe220
movq -0x48(%rbp), %rdi
callq 0xf2f0
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x1, %esi
callq 0xea30
movq -0x10(%rbp), %rdi
movb $0x0, (%rax)
movl $0x1, %esi
callq 0xeb80
movq -0x10(%rbp), %rdi
callq 0xf3a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x14284
movq -0x18(%rbp), %rcx
movq (%rcx), %rax
cmpq 0x10(%rcx), %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1428d
jmp 0x142b1
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rdi
callq 0xe680
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x14264
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x142d7
movq -0x18(%rbp), %rcx
movq (%rcx), %rax
cmpq 0x10(%rcx), %rax
jne 0x142d7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
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>::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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0xeee0
cmpq $0x10, %rax
jb 0x14798
jmp 0x147b7
leaq 0xa1d4(%rip), %rdi      # 0x1e973
leaq 0x9c12(%rip), %rsi      # 0x1e3b8
movl $0xe9, %edx
leaq 0xa1e9(%rip), %rcx      # 0x1e99b
callq 0xe600
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0xe4a0
movb 0x8(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x147cf
jmp 0x147d1
jmp 0x147f0
leaq 0xa2e7(%rip), %rdi      # 0x1eabf
leaq 0x9bd9(%rip), %rsi      # 0x1e3b8
movl $0xea, %edx
leaq 0xa1b0(%rip), %rcx      # 0x1e99b
callq 0xe600
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0xe4a0
movq (%rax), %rcx
andq $0x1, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x1480d
jmp 0x1482c
leaq 0xa2d8(%rip), %rdi      # 0x1eaec
leaq 0x9b9d(%rip), %rsi      # 0x1e3b8
movl $0xeb, %edx
leaq 0xa174(%rip), %rcx      # 0x1e99b
callq 0xe600
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xed60
movq -0x18(%rbp), %rdi
callq 0xeda0
movq -0x18(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0xefe0
andb $0x1, %al
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>::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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0xeee0
cmpq $0x10, %rax
jb 0x14918
jmp 0x14937
leaq 0xa054(%rip), %rdi      # 0x1e973
leaq 0x9a92(%rip), %rsi      # 0x1e3b8
movl $0xf8, %edx
leaq 0xa3f2(%rip), %rcx      # 0x1ed24
callq 0xe600
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0xe4a0
testb $0x1, 0x8(%rax)
je 0x1494c
jmp 0x1496b
leaq 0xa16d(%rip), %rdi      # 0x1eac0
leaq 0x9a5e(%rip), %rsi      # 0x1e3b8
movl $0xf9, %edx
leaq 0xa3be(%rip), %rcx      # 0x1ed24
callq 0xe600
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xed60
movq -0x18(%rbp), %rdi
callq 0xf1b0
movq -0x18(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0xefe0
andb $0x1, %al
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>::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
subq $0x20, %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)
cmpq $0x0, -0x10(%rbp)
je 0x149cb
jmp 0x149ea
leaq 0xa475(%rip), %rdi      # 0x1ee47
leaq 0x99df(%rip), %rsi      # 0x1e3b8
movl $0xcc, %edx
leaq 0xa46b(%rip), %rcx      # 0x1ee50
callq 0xe600
movq -0x20(%rbp), %rdi
movl $0x5, %esi
callq 0xe5a0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0xedf0
movq -0x20(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0xefe0
andb $0x1, %al
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>::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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
callq 0xeee0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x14c64
jmp 0x14d2d
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0xe4a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jbe 0x14cd9
movq -0x18(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x14c9c
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl $0x2c, %esi
callq 0xe090
jmp 0x14cd7
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
andq $0x1, %rcx
movb $0x2c, %al
movb $0x3a, %dl
movb %dl, -0x22(%rbp)
cmpq $0x0, %rcx
movb %al, -0x21(%rbp)
je 0x14cc8
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movq -0x30(%rbp), %rdi
movb -0x21(%rbp), %al
movsbl %al, %esi
callq 0xe090
jmp 0x14cd9
movq -0x18(%rbp), %rax
testb $0x1, 0x8(%rax)
jne 0x14d1d
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x14d1d
cmpl $0x5, -0xc(%rbp)
jne 0x14cfc
jmp 0x14d1b
leaq 0x96a1(%rip), %rdi      # 0x1e3a4
leaq 0x96ae(%rip), %rsi      # 0x1e3b8
movl $0x1e4, %edx            # imm = 0x1E4
leaq 0x96c7(%rip), %rcx      # 0x1e3dd
callq 0xe600
jmp 0x14d1d
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x14d65
movq -0x20(%rbp), %rax
movb 0x3c(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x14d3c
jmp 0x14d3e
jmp 0x14d5d
leaq 0x97b5(%rip), %rdi      # 0x1e4fa
leaq 0x966c(%rip), %rsi      # 0x1e3b8
movl $0x1e8, %edx            # imm = 0x1E8
leaq 0x9685(%rip), %rcx      # 0x1e3dd
callq 0xe600
movq -0x20(%rbp), %rax
movb $0x1, 0x3c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x14fa1
jmp 0x14fc0
leaq 0x9655(%rip), %rdi      # 0x1e5fd
leaq 0x956c(%rip), %rsi      # 0x1e51b
movl $0x82, %edx
leaq 0x964c(%rip), %rcx      # 0x1e607
callq 0xe600
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
shlq $0x0, %rax
movq 0x20(%rdx), %rcx
movq 0x18(%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jg 0x14fde
jmp 0x14ffd
leaq 0x969d(%rip), %rdi      # 0x1e682
leaq 0x952f(%rip), %rsi      # 0x1e51b
movl $0x83, %edx
leaq 0x960f(%rip), %rcx      # 0x1e607
callq 0xe600
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
shlq $0x0, %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/stack.h
// Function: void rapidjson::internal::Stack<rapidjson::CrtAllocator>::Expand<char>(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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x1507f
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x15071
movl $0x1, %edi
callq 0xe9a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1509f
movq -0x28(%rbp), %rdi
callq 0xe770
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
shrq %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
callq 0xeee0
movq -0x10(%rbp), %rcx
shlq $0x0, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x150c9
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf230
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xeee0
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq (%rdi), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rdi), %rax
movq %rax, -0x28(%rbp)
callq 0xe770
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
callq 0xe9d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rcx
addq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rax), %rcx
addq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x151b2
movq -0x18(%rbp), %rdi
callq 0xec70
movq $0x0, -0x8(%rbp)
jmp 0x151c3
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xf150
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %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>::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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x15369
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x4, %esi
callq 0xe0e0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x74, %esi
callq 0xf550
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x72, %esi
callq 0xf550
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x75, %esi
callq 0xf550
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x65, %esi
callq 0xf550
jmp 0x153cf
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x5, %esi
callq 0xe0e0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x66, %esi
callq 0xf550
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x61, %esi
callq 0xf550
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x6c, %esi
callq 0xf550
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x73, %esi
callq 0xf550
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x65, %esi
callq 0xf550
movb $0x1, %al
andb $0x1, %al
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>::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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
leaq -0x20(%rbp), %rdi
callq 0xed10
leaq -0x20(%rbp), %rdi
callq 0xe960
testb $0x1, %al
jne 0x15b56
jmp 0x15b5c
movb $0x0, -0x1(%rbp)
jmp 0x15bb3
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movl $0x19, %esi
callq 0xe060
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x28(%rbp), %rdi
movl 0x38(%rax), %esi
callq 0xe530
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl $0x19, %esi
subq %rax, %rsi
callq 0xea50
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movsd %xmm0, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jl 0x15c5c
jmp 0x15c7b
leaq 0x9320(%rip), %rdi      # 0x1ef83
leaq 0x932f(%rip), %rsi      # 0x1ef99
movl $0xd9, %edx
leaq 0x934f(%rip), %rcx      # 0x1efc5
callq 0xe600
movsd -0x10(%rbp), %xmm0
leaq -0x28(%rbp), %rdi
callq 0xed10
leaq -0x28(%rbp), %rdi
callq 0xe070
testb $0x1, %al
jne 0x15c98
jmp 0x15cde
leaq -0x28(%rbp), %rdi
callq 0xea00
testb $0x1, %al
jne 0x15ca7
jmp 0x15cb9
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x2d, (%rax)
movq -0x18(%rbp), %rax
movb $0x30, (%rax)
movq -0x18(%rbp), %rax
movb $0x2e, 0x1(%rax)
movq -0x18(%rbp), %rax
movb $0x30, 0x2(%rax)
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x8(%rbp)
jmp 0x15d47
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x15d1b
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x2d, (%rax)
movsd -0x10(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xef00
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0xe9f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x110, %rsp            # imm = 0x110
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0xf510
leaq -0x40(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0xe230
leaq -0x50(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0xe230
movq -0x110(%rbp), %rdi
movq -0x108(%rbp), %rdx
movq -0x100(%rbp), %rsi
callq 0xf070
movl -0x48(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xef80
movq -0x110(%rbp), %rdi
movl %edx, -0x68(%rbp)
movq %rax, -0x70(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0xe930
movl %edx, -0x98(%rbp)
movq %rax, -0xa0(%rbp)
movl -0x98(%rbp), %eax
movl %eax, -0x88(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movq %rsi, -0xf8(%rbp)
callq 0xeaf0
movq -0x108(%rbp), %rdi
movq -0xf8(%rbp), %rsi
movl %edx, -0xa8(%rbp)
movq %rax, -0xb0(%rbp)
movl -0xa8(%rbp), %eax
movl %eax, -0x78(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0xeaf0
movq -0x100(%rbp), %rdi
movq -0xf8(%rbp), %rsi
movl %edx, -0xc8(%rbp)
movq %rax, -0xd0(%rbp)
movl -0xc8(%rbp), %eax
movl %eax, -0xb8(%rbp)
movq -0xd0(%rbp), %rax
movq %rax, -0xc0(%rbp)
callq 0xeaf0
movl %edx, -0xe8(%rbp)
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl -0xe8(%rbp), %eax
movl %eax, -0xd8(%rbp)
movq -0xe0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xe0(%rbp)
movq -0xc0(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rdx
subq -0xe0(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq -0x80(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0xf310
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/diyfp.h
// Function: rapidjson::internal::DiyFp::DiyFp(double)
explicit DiyFp(double d) {
        union {
            double d;
            uint64_t u64;
        } u = { d };

        int biased_e = static_cast<int>((u.u64 & kDpExponentMask) >> kDpSignificandSize);
        uint64_t significand = (u.u64 & kDpSignificandMask);
        if (biased_e != 0) {
            f = significand + kDpHiddenBit;
            e = biased_e - kDpExponentBias;
        }
        else {
            f = significand;
            e = kDpMinExponent + 1;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
andq -0x18(%rbp), %rax
shrq $0x34, %rax
movl %eax, -0x1c(%rbp)
movabsq $0xfffffffffffff, %rax  # imm = 0xFFFFFFFFFFFFF
andq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1632f
movq -0x30(%rbp), %rax
movabsq $0x10000000000000, %rcx # imm = 0x10000000000000
addq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
subl $0x433, %ecx            # imm = 0x433
movl %ecx, 0x8(%rax)
jmp 0x16341
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movl $0xfffffbce, 0x8(%rax)  # imm = 0xFFFFFBCE
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq (%rax), %rcx
leaq 0x1(%rcx,%rcx), %rsi
movl 0x8(%rax), %edx
decl %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xf260
movq -0x68(%rbp), %rdi
callq 0xeb40
movq %rax, %rcx
movq -0x60(%rbp), %rax
movl %edx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl -0x40(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movabsq $0x10000000000000, %rcx # imm = 0x10000000000000
cmpq %rcx, (%rax)
jne 0x163fa
movq -0x60(%rbp), %rax
movq (%rax), %rsi
shlq $0x2, %rsi
subq $0x1, %rsi
movl 0x8(%rax), %edx
subl $0x2, %edx
leaq -0x58(%rbp), %rdi
callq 0xf260
jmp 0x16417
movq -0x60(%rbp), %rax
movq (%rax), %rsi
shlq %rsi
subq $0x1, %rsi
movl 0x8(%rax), %edx
subl $0x1, %edx
leaq -0x58(%rbp), %rdi
callq 0xf260
movl -0x50(%rbp), %ecx
subl -0x20(%rbp), %ecx
movq -0x58(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x58(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movl -0x50(%rbp), %ecx
movl %ecx, 0x8(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movl $0xffffffc3, %eax       # imm = 0xFFFFFFC3
subl -0x14(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd 0x7ba5(%rip), %xmm1     # 0x1e028
mulsd %xmm1, %xmm0
movsd 0x7ba1(%rip), %xmm1     # 0x1e030
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
cvttsd2si -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
subsd %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x164c0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
sarl $0x3, %eax
incl %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
shll $0x3, %eax
movl $0x15c, %ecx            # imm = 0x15C
subl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x30(%rbp), %eax
movl %eax, %edi
callq 0xe420
movl %edx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/diyfp.h
// Function: rapidjson::internal::DiyFp::operator*(rapidjson::internal::DiyFp const&) const
DiyFp operator*(const DiyFp& rhs) const {
#if defined(_MSC_VER) && defined(_M_AMD64)
        uint64_t h;
        uint64_t l = _umul128(f, rhs.f, &h);
        if (l & (uint64_t(1) << 63)) // rounding
            h++;
        return DiyFp(h, e + rhs.e + 64);
#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
        __extension__ typedef unsigned __int128 uint128;
        uint128 p = static_cast<uint128>(f) * static_cast<uint128>(rhs.f);
        uint64_t h = static_cast<uint64_t>(p >> 64);
        uint64_t l = static_cast<uint64_t>(p);
        if (l & (uint64_t(1) << 63)) // rounding
            h++;
        return DiyFp(h, e + rhs.e + 64);
#else
        const uint64_t M32 = 0xFFFFFFFF;
        const uint64_t a = f >> 32;
        const uint64_t b = f & M32;
        const uint64_t c = rhs.f >> 32;
        const uint64_t d = rhs.f & M32;
        const uint64_t ac = a * c;
        const uint64_t bc = b * c;
        const uint64_t ad = a * d;
        const uint64_t bd = b * d;
        uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32);
        tmp += 1U << 31;  /// mult_round
        return DiyFp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), e + rhs.e + 64);
#endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, -0x28(%rbp)
movl 0x4(%rax), %ecx
movq %rcx, -0x30(%rbp)
movl (%rax), %ecx
movq %rcx, -0x38(%rbp)
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq %rcx, -0x40(%rbp)
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movq %rcx, -0x48(%rbp)
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rdx
imulq %rdx, %rcx
movq %rcx, -0x50(%rbp)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rdx
imulq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq -0x30(%rbp), %rcx
movq -0x48(%rbp), %rdx
imulq %rdx, %rcx
movq %rcx, -0x60(%rbp)
movq -0x38(%rbp), %rcx
movq -0x48(%rbp), %rdx
imulq %rdx, %rcx
movq %rcx, -0x68(%rbp)
movl -0x64(%rbp), %ecx
movl -0x60(%rbp), %edx
addq %rdx, %rcx
movl -0x58(%rbp), %edx
addq %rdx, %rcx
movq %rcx, -0x70(%rbp)
movq -0x70(%rbp), %rcx
subq $-0x80000000, %rcx      # imm = 0x80000000
movq %rcx, -0x70(%rbp)
movq -0x50(%rbp), %rsi
movl -0x5c(%rbp), %ecx
addq %rcx, %rsi
movl -0x54(%rbp), %ecx
addq %rcx, %rsi
movl -0x6c(%rbp), %ecx
addq %rcx, %rsi
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
movl %ecx, %eax
movl %edx, %ecx
leal 0x40(%rax,%rcx), %edx
leaq -0x10(%rbp), %rdi
callq 0xf260
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x70, %rsp
popq %rbp
retq
nop
// File: 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, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movabsq $0x20000000000000, %rax # imm = 0x20000000000000
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x16ab8
jmp 0x16ace
movq -0x10(%rbp), %rax
shlq %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x16a9b
movq -0x10(%rbp), %rax
shlq $0xa, %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $-0xa, %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
popq %rbp
retq
nopl (%rax)