LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/allocators.h
// Function: rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>::Malloc(unsigned long)
void* Malloc(size_t size) {
        if (!size)
            return NULL;

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

        void *buffer = reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size;
        chunkHead_->size += size;
        return buffer;
    }

// Assembly:
testq %rsi, %rsi
je 0xe5a6
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x7, %rbx
andq $-0x8, %rbx
movq (%rdi), %rcx
testq %rcx, %rcx
je 0xe575
movq 0x8(%rcx), %rax
leaq (%rax,%rbx), %rdx
cmpq (%rcx), %rdx
jbe 0xe599
movq 0x8(%r14), %rsi
cmpq %rbx, %rsi
cmovbeq %rbx, %rsi
movq %r14, %rdi
callq 0x9820
testb %al, %al
je 0xe5a9
movq (%r14), %rcx
movq 0x8(%rcx), %rax
addq %rax, %rbx
movq %rbx, %rdx
addq %rcx, %rax
addq $0x18, %rax
movq %rdx, 0x8(%rcx)
jmp 0xe5ab
xorl %eax, %eax
retq
xorl %eax, %eax
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>::AddChunk(unsigned long)
bool AddChunk(size_t capacity) {
        if (!baseAllocator_)
            ownBaseAllocator_ = baseAllocator_ = RAPIDJSON_NEW(BaseAllocator)();
        if (ChunkHeader* chunk = reinterpret_cast<ChunkHeader*>(baseAllocator_->Malloc(RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + capacity))) {
            chunk->capacity = capacity;
            chunk->size = 0;
            chunk->next = chunkHead_;
            chunkHead_ =  chunk;
            return true;
        }
        else
            return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
jne 0xe5d9
pushq $0x1
popq %rdi
callq 0x9570
movq %rax, %rdi
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq 0x18(%r14), %rsi
callq 0x9190
testq %rax, %rax
je 0xe5f9
movq %r14, (%rax)
andq $0x0, 0x8(%rax)
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, (%rbx)
testq %rax, %rax
setne %al
popq %rbx
popq %r14
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>>::SetStringRaw(rapidjson::GenericStringRef<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
void SetStringRaw(StringRefType s, Allocator& allocator) {
        Ch* str = 0;
        if (ShortString::Usable(s.length)) {
            data_.f.flags = kShortStringFlag;
            data_.ss.SetLength(s.length);
            str = data_.ss.str;
        } else {
            data_.f.flags = kCopyStringFlag;
            data_.s.length = s.length;
            str = static_cast<Ch *>(allocator.Malloc((s.length + 1) * sizeof(Ch)));
            SetStringPointer(str);
        }
        std::memcpy(str, s, s.length * sizeof(Ch));
        str[s.length] = '\0';
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0xd, 0x8(%rsi)
ja 0xe66d
movw $0x1c05, 0xe(%r14)      # imm = 0x1C05
movb $0xd, %al
subb 0x8(%rbx), %al
movb %al, 0xd(%r14)
jmp 0xe697
movw $0xc05, 0xe(%r14)       # imm = 0xC05
movl 0x8(%rbx), %esi
movl %esi, (%r14)
incl %esi
movq %rdx, %rdi
callq 0x9140
movzwl 0xe(%r14), %ecx
shlq $0x30, %rcx
orq %rax, %rcx
movq %rcx, 0x8(%r14)
movq %rax, %r14
movq (%rbx), %rsi
movl 0x8(%rbx), %edx
movq %r14, %rdi
callq 0x9430
movl 0x8(%rbx), %eax
movb $0x0, (%r14,%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>& rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>::ParseStream<0u, rapidjson::UTF8<char>, rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&)
GenericDocument& ParseStream(InputStream& is) {
        GenericReader<SourceEncoding, Encoding, StackAllocator> reader(
            stack_.HasAllocator() ? &stack_.GetAllocator() : 0);
        ClearStackOnExit scope(*this);
        parseResult_ = reader.template Parse<parseFlags>(is, *this);
        if (parseResult_) {
            RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object
            ValueType::operator=(*stack_.template Pop<ValueType>(1));// Move value from stack to document
        }
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
cmpq $0x0, 0x20(%rdi)
je 0xe748
movq %r14, %rdi
callq 0x94f0
jmp 0xe74a
xorl %eax, %eax
leaq -0x68(%rbp), %rdi
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movq $0x100, 0x28(%rdi)      # imm = 0x100
andl $0x0, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
movl $0x2, 0x40(%rdi)
movq %rbx, -0x20(%rbp)
movq %r15, %rsi
movq %rbx, %rdx
callq 0x9910
movl %eax, 0x50(%rbx)
movq %rdx, 0x58(%rbx)
testl %eax, %eax
jne 0xe7b7
movq 0x38(%rbx), %rax
subq 0x30(%rbx), %rax
cmpq $0x10, %rax
jne 0xe7d7
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x9740
cmpq %rbx, %rax
je 0xe7b7
movups (%rax), %xmm0
movups %xmm0, (%rbx)
andw $0x0, 0xe(%rax)
leaq -0x20(%rbp), %rdi
callq 0x91d0
leaq -0x68(%rbp), %rdi
callq 0x9ca0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3daf(%rip), %rdi      # 0x1258d
leaq 0x2aa5(%rip), %rsi      # 0x1128a
leaq 0x3dc7(%rip), %rcx      # 0x125b3
movl $0x8f7, %edx            # imm = 0x8F7
callq 0x9380
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x91d0
leaq -0x68(%rbp), %rdi
callq 0x9ca0
movq %rbx, %rdi
callq 0x9be0
nop
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/reader.h
// Function: rapidjson::ParseResult rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::Parse<0u, rapidjson::GenericStringStream<rapidjson::UTF8<char>>, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>&)
ParseResult Parse(InputStream& is, Handler& handler) {
        if (parseFlags & kParseIterativeFlag)
            return IterativeParse<parseFlags>(is, handler);

        parseResult_.Clear();

        ClearStackOnExit scope(*this);

        SkipWhitespaceAndComments<parseFlags>(is);
        RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);

        if (RAPIDJSON_UNLIKELY(is.Peek() == '\0')) {
            RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentEmpty, is.Tell());
            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
        }
        else {
            ParseValue<parseFlags>(is, handler);
            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);

            if (!(parseFlags & kParseStopWhenDoneFlag)) {
                SkipWhitespaceAndComments<parseFlags>(is);
                RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);

                if (RAPIDJSON_UNLIKELY(is.Peek() != '\0')) {
                    RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentRootNotSingular, is.Tell());
                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
                }
            }
        }

        return parseResult_;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
andl $0x0, 0x30(%rdi)
movq %rsi, %r14
andq $0x0, 0x38(%rdi)
movq %rsi, %rdi
callq 0x9400
movl 0x30(%rbx), %eax
testl %eax, %eax
jne 0xe8a1
movq (%r14), %rcx
cmpb $0x0, (%rcx)
je 0xe8b8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x90c0
movl 0x30(%rbx), %eax
testl %eax, %eax
jne 0xe8a1
movq %r14, %rdi
callq 0x9400
movl 0x30(%rbx), %eax
testl %eax, %eax
jne 0xe8a1
movq (%r14), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
jne 0xe8bc
movq 0x10(%rbx), %rcx
movq 0x38(%rbx), %rdx
movq %rcx, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
jmp 0xe8be
pushq $0x2
popq %rax
subq 0x8(%r14), %rcx
movl %eax, 0x30(%rbx)
movq %rcx, 0x38(%rbx)
jmp 0xe8a1
movq 0x10(%rbx), %rcx
movq %rcx, 0x18(%rbx)
movq %rax, %rdi
callq 0x9be0
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/reader.h
// Function: void rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseValue<0u, rapidjson::GenericStringStream<rapidjson::UTF8<char>>, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>&)
void ParseValue(InputStream& is, Handler& handler) {
        switch (is.Peek()) {
            case 'n': ParseNull  <parseFlags>(is, handler); break;
            case 't': ParseTrue  <parseFlags>(is, handler); break;
            case 'f': ParseFalse <parseFlags>(is, handler); break;
            case '"': ParseString<parseFlags>(is, handler); break;
            case '{': ParseObject<parseFlags>(is, handler); break;
            case '[': ParseArray <parseFlags>(is, handler); break;
            default :
                      ParseNumber<parseFlags>(is, handler);
                      break;

        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
je 0xe97e
cmpl $0x5b, %eax
je 0xe978
cmpl $0x66, %eax
je 0xe960
cmpl $0x7b, %eax
je 0xe96c
cmpl $0x74, %eax
je 0xe966
cmpl $0x6e, %eax
jne 0xe972
popq %rbp
jmp 0x92c0
popq %rbp
jmp 0x9a90
popq %rbp
jmp 0x9b60
popq %rbp
jmp 0x99f0
popq %rbp
jmp 0x9440
popq %rbp
jmp 0x9c20
xorl %ecx, %ecx
popq %rbp
jmp 0x9900
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/reader.h
// Function: void rapidjson::SkipWhitespace<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&)
void SkipWhitespace(InputStream& is) {
    internal::StreamLocalCopy<InputStream> copy(is);
    InputStream& s(copy.s);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movabsq $0x100002600, %rcx      # imm = 0x100002600
movzbl (%rax), %edx
cmpq $0x20, %rdx
ja 0xe9ab
btq %rdx, %rcx
jae 0xe9ab
incq %rax
jmp 0xe997
movq %rax, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/reader.h
// Function: void rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseNull<0u, rapidjson::GenericStringStream<rapidjson::UTF8<char>>, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>&)
void ParseNull(InputStream& is, Handler& handler) {
        RAPIDJSON_ASSERT(is.Peek() == 'n');
        is.Take();

        if (RAPIDJSON_LIKELY(Consume(is, 'u') && Consume(is, 'l') && Consume(is, 'l'))) {
            if (RAPIDJSON_UNLIKELY(!handler.Null()))
                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
        }
        else
            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rsi), %rcx
cmpb $0x6e, (%rcx)
jne 0xea31
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1(%rcx), %rax
movq %rax, (%rsi)
cmpb $0x75, 0x1(%rcx)
jne 0xea04
leaq 0x2(%rcx), %rax
movq %rax, (%r14)
cmpb $0x6c, 0x2(%rcx)
jne 0xea04
leaq 0x3(%rcx), %rax
movq %rax, (%r14)
cmpb $0x6c, 0x3(%rcx)
jne 0xea04
addq $0x4, %rcx
movq %rcx, (%r14)
movq %rdx, %rdi
callq 0x9a20
testb %al, %al
je 0xea17
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x0, 0x30(%rbx)
jne 0xea50
subq 0x8(%r14), %rax
movl $0x3, 0x30(%rbx)
jmp 0xea2b
cmpl $0x0, 0x30(%rbx)
jne 0xea6f
movq (%r14), %rax
subq 0x8(%r14), %rax
movl $0x10, 0x30(%rbx)
movq %rax, 0x38(%rbx)
jmp 0xe9ff
leaq 0x3d93(%rip), %rdi      # 0x127cb
leaq 0x3d67(%rip), %rsi      # 0x127a6
leaq 0x3d96(%rip), %rcx      # 0x127dc
movl $0x358, %edx            # imm = 0x358
callq 0x9380
leaq 0x3d3e(%rip), %rdi      # 0x12795
leaq 0x3d48(%rip), %rsi      # 0x127a6
leaq 0x3d77(%rip), %rcx      # 0x127dc
movl $0x360, %edx            # imm = 0x360
callq 0x9380
leaq 0x3d1f(%rip), %rdi      # 0x12795
leaq 0x3d29(%rip), %rsi      # 0x127a6
leaq 0x3d58(%rip), %rcx      # 0x127dc
movl $0x35d, %edx            # imm = 0x35D
callq 0x9380
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/reader.h
// Function: void rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseTrue<0u, rapidjson::GenericStringStream<rapidjson::UTF8<char>>, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>&)
void ParseTrue(InputStream& is, Handler& handler) {
        RAPIDJSON_ASSERT(is.Peek() == 't');
        is.Take();

        if (RAPIDJSON_LIKELY(Consume(is, 'r') && Consume(is, 'u') && Consume(is, 'e'))) {
            if (RAPIDJSON_UNLIKELY(!handler.Bool(true)))
                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
        }
        else
            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rsi), %rcx
cmpb $0x74, (%rcx)
jne 0xeb12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1(%rcx), %rax
movq %rax, (%rsi)
cmpb $0x72, 0x1(%rcx)
jne 0xeae5
leaq 0x2(%rcx), %rax
movq %rax, (%r14)
cmpb $0x75, 0x2(%rcx)
jne 0xeae5
leaq 0x3(%rcx), %rax
movq %rax, (%r14)
cmpb $0x65, 0x3(%rcx)
jne 0xeae5
addq $0x4, %rcx
movq %rcx, (%r14)
pushq $0x1
popq %rsi
movq %rdx, %rdi
callq 0x93f0
testb %al, %al
je 0xeaf8
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x0, 0x30(%rbx)
jne 0xeb31
subq 0x8(%r14), %rax
movl $0x3, 0x30(%rbx)
jmp 0xeb0c
cmpl $0x0, 0x30(%rbx)
jne 0xeb50
movq (%r14), %rax
subq 0x8(%r14), %rax
movl $0x10, 0x30(%rbx)
movq %rax, 0x38(%rbx)
jmp 0xeae0
leaq 0x3ecb(%rip), %rdi      # 0x129e4
leaq 0x3c86(%rip), %rsi      # 0x127a6
leaq 0x3ece(%rip), %rcx      # 0x129f5
movl $0x365, %edx            # imm = 0x365
callq 0x9380
leaq 0x3c5d(%rip), %rdi      # 0x12795
leaq 0x3c67(%rip), %rsi      # 0x127a6
leaq 0x3eaf(%rip), %rcx      # 0x129f5
movl $0x36d, %edx            # imm = 0x36D
callq 0x9380
leaq 0x3c3e(%rip), %rdi      # 0x12795
leaq 0x3c48(%rip), %rsi      # 0x127a6
leaq 0x3e90(%rip), %rcx      # 0x129f5
movl $0x36a, %edx            # imm = 0x36A
callq 0x9380
nop
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/reader.h
// Function: void rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseFalse<0u, rapidjson::GenericStringStream<rapidjson::UTF8<char>>, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>&)
void ParseFalse(InputStream& is, Handler& handler) {
        RAPIDJSON_ASSERT(is.Peek() == 'f');
        is.Take();

        if (RAPIDJSON_LIKELY(Consume(is, 'a') && Consume(is, 'l') && Consume(is, 's') && Consume(is, 'e'))) {
            if (RAPIDJSON_UNLIKELY(!handler.Bool(false)))
                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
        }
        else
            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rsi), %rcx
cmpb $0x66, (%rcx)
jne 0xec04
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1(%rcx), %rax
movq %rax, (%rsi)
cmpb $0x61, 0x1(%rcx)
jne 0xebd7
leaq 0x2(%rcx), %rax
movq %rax, (%r14)
cmpb $0x6c, 0x2(%rcx)
jne 0xebd7
leaq 0x3(%rcx), %rax
movq %rax, (%r14)
cmpb $0x73, 0x3(%rcx)
jne 0xebd7
leaq 0x4(%rcx), %rax
movq %rax, (%r14)
cmpb $0x65, 0x4(%rcx)
jne 0xebd7
addq $0x5, %rcx
movq %rcx, (%r14)
movq %rdx, %rdi
xorl %esi, %esi
callq 0x93f0
testb %al, %al
je 0xebee
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x0, 0x30(%rbx)
jne 0xec23
subq 0x8(%r14), %rax
movl $0x3, 0x30(%rbx)
movq %rax, 0x38(%rbx)
jmp 0xebd2
cmpl $0x0, 0x30(%rbx)
jne 0xec42
movq (%r14), %rax
subq 0x8(%r14), %rax
movl $0x10, 0x30(%rbx)
jmp 0xebe8
leaq 0x3f51(%rip), %rdi      # 0x12b5c
leaq 0x3b94(%rip), %rsi      # 0x127a6
leaq 0x3f54(%rip), %rcx      # 0x12b6d
movl $0x372, %edx            # imm = 0x372
callq 0x9380
leaq 0x3b6b(%rip), %rdi      # 0x12795
leaq 0x3b75(%rip), %rsi      # 0x127a6
leaq 0x3f35(%rip), %rcx      # 0x12b6d
movl $0x37a, %edx            # imm = 0x37A
callq 0x9380
leaq 0x3b4c(%rip), %rdi      # 0x12795
leaq 0x3b56(%rip), %rsi      # 0x127a6
leaq 0x3f16(%rip), %rcx      # 0x12b6d
movl $0x377, %edx            # imm = 0x377
callq 0x9380
nop
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>::String(char const*, unsigned int, bool)
bool String(const Ch* str, SizeType length, bool copy) { 
        if (copy) 
            new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
        else
            new (stack_.template Push<ValueType>()) ValueType(str, length);
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r13d
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
addq $0x20, %rdi
pushq $0x1
popq %rsi
callq 0x9270
movq %rax, %r12
testl %r13d, %r13d
je 0xfb1b
movq %r15, %rdi
callq 0x9350
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %rax, %rcx
callq 0x9340
jmp 0xfb28
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x9630
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/reader.h
// Function: unsigned int rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseHex4<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&, unsigned long)
unsigned ParseHex4(InputStream& is, size_t escapeOffset) {
        unsigned codepoint = 0;
        for (int i = 0; i < 4; i++) {
            Ch c = is.Peek();
            codepoint <<= 4;
            codepoint += static_cast<unsigned>(c);
            if (c >= '0' && c <= '9')
                codepoint -= '0';
            else if (c >= 'A' && c <= 'F')
                codepoint -= 'A' - 10;
            else if (c >= 'a' && c <= 'f')
                codepoint -= 'a' - 10;
            else {
                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorStringUnicodeEscapeInvalidHex, escapeOffset);
                RAPIDJSON_PARSE_ERROR_EARLY_RETURN(0);
            }
            is.Take();
        }
        return codepoint;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rsi), %rcx
incq %rcx
xorl %eax, %eax
pushq $0x4
popq %r8
pushq $-0x30
popq %r9
pushq $-0x37
popq %r10
pushq $-0x57
popq %r11
subl $0x1, %r8d
jb 0xfbd2
movsbl -0x1(%rcx), %ebx
leal -0x30(%rbx), %r15d
movl %r9d, %r14d
cmpb $0xa, %r15b
jb 0xfbaf
leal -0x41(%rbx), %r15d
movl %r10d, %r14d
cmpb $0x6, %r15b
jb 0xfbaf
leal -0x61(%rbx), %r15d
movl %r11d, %r14d
cmpb $0x6, %r15b
jae 0xfbbf
shll $0x4, %eax
addl %ebx, %eax
addl %r14d, %eax
movq %rcx, (%rsi)
incq %rcx
jmp 0xfb7e
cmpl $0x0, 0x30(%rdi)
jne 0xfbdd
movl $0x8, 0x30(%rdi)
movq %rdx, 0x38(%rdi)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2bb1(%rip), %rdi      # 0x12795
leaq 0x2bbb(%rip), %rsi      # 0x127a6
leaq 0x3440(%rip), %rcx      # 0x13032
movl $0x396, %edx            # imm = 0x396
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>>::GenericValue(rapidjson::Type)
explicit GenericValue(Type type) RAPIDJSON_NOEXCEPT : data_() {
        static const uint16_t defaultFlags[] = {
            kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag,
            kNumberAnyFlag
        };
        RAPIDJSON_NOEXCEPT_ASSERT(type >= kNullType && type <= kNumberType);
        data_.f.flags = defaultFlags[type];

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

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpl $0x7, %esi
jae 0xfe2c
movl %esi, %eax
movq 0x9176(%rip), %rcx      # 0x18f90
movzwl (%rcx,%rax,2), %eax
movw %ax, 0xe(%rdi)
cmpl $0x5, %esi
jne 0xfe2b
movb $0xd, 0xd(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x23ba(%rip), %rdi      # 0x121f1
leaq 0x144c(%rip), %rsi      # 0x1128a
leaq 0x23d5(%rip), %rcx      # 0x1221a
movl $0x299, %edx            # imm = 0x299
callq 0x9380
nop
// 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>>::SetObjectRaw(rapidjson::GenericMember<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*, unsigned int, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
void SetObjectRaw(Member* members, SizeType count, Allocator& allocator) {
        data_.f.flags = kObjectFlag;
        if (count) {
            Member* m = static_cast<Member*>(allocator.Malloc(count * sizeof(Member)));
            SetMembersPointer(m);
            std::memcpy(static_cast<void*>(m), members, count * sizeof(Member));
        }
        else
            SetMembersPointer(0);
        data_.o.size = data_.o.capacity = count;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movabsq $-0x1000000000000, %r13 # imm = 0xFFFF000000000000
movw $0x3, 0xe(%rdi)
testl %edx, %edx
je 0xff21
movq %rsi, %r15
movl %ebx, %r12d
shlq $0x5, %r12
movq %rcx, %rdi
movq %r12, %rsi
callq 0x9140
andq 0x8(%r14), %r13
orq %rax, %r13
movq %r13, 0x8(%r14)
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x9430
jmp 0xff25
andq %r13, 0x8(%r14)
movl %ebx, 0x4(%r14)
movl %ebx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// 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>>::SetArrayRaw(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*, unsigned int, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
void SetArrayRaw(GenericValue* values, SizeType count, Allocator& allocator) {
        data_.f.flags = kArrayFlag;
        if (count) {
            GenericValue* e = static_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));
            SetElementsPointer(e);
            std::memcpy(static_cast<void*>(e), values, count * sizeof(GenericValue));
        }
        else
            SetElementsPointer(0);
        data_.a.size = data_.a.capacity = count;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movabsq $-0x1000000000000, %r13 # imm = 0xFFFF000000000000
movw $0x4, 0xe(%rdi)
testl %edx, %edx
je 0x10003
movq %rsi, %r15
movl %ebx, %r12d
shlq $0x4, %r12
movq %rcx, %rdi
movq %r12, %rsi
callq 0x9140
andq 0x8(%r14), %r13
orq %rax, %r13
movq %r13, 0x8(%r14)
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x9430
jmp 0x10007
andq %r13, 0x8(%r14)
movl %ebx, 0x4(%r14)
movl %ebx, (%r14)
addq $0x8, %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/strtod.h
// Function: rapidjson::internal::StrtodNormalPrecision(double, int)
inline double StrtodNormalPrecision(double d, int p) {
    if (p < -308) {
        // Prevent expSum < -308, making Pow10(p) = 0
        d = FastPath(d, -308);
        d = FastPath(d, p + 308);
    }
    else
        d = FastPath(d, p);
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0xfffffecb, %edi       # imm = 0xFFFFFECB
jg 0x10037
divsd 0x103f(%rip), %xmm0     # 0x11070
addl $0x134, %edi            # imm = 0x134
popq %rbp
jmp 0x98f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/strtod.h
// Function: rapidjson::internal::FastPath(double, int)
inline double FastPath(double significand, int exp) {
    if (exp < -308)
        return 0.0;
    else if (exp >= 0)
        return significand * internal::Pow10(exp);
    else
        return significand / internal::Pow10(-exp);
}

// Assembly:
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
cmpl $0xfffffecc, %edi       # imm = 0xFFFFFECC
jl 0x10187
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm1, -0x8(%rbp)
testl %edi, %edi
js 0x1016e
callq 0x96f0
mulsd -0x8(%rbp), %xmm0
jmp 0x10182
negl %edi
callq 0x96f0
movsd -0x8(%rbp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
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>>::GenericValue(long)
explicit GenericValue(int64_t i64) RAPIDJSON_NOEXCEPT : data_() {
        data_.n.i64 = i64;
        data_.f.flags = kNumberInt64Flag;
        if (i64 >= 0) {
            data_.f.flags |= kNumberUint64Flag;
            if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
                data_.f.flags |= kUintFlag;
            if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
                data_.f.flags |= kIntFlag;
        }
        else if (i64 >= static_cast<int64_t>(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
            data_.f.flags |= kIntFlag;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $0x0, 0x8(%rdi)
movq %rsi, (%rdi)
movw $0x96, 0xe(%rdi)
testq %rsi, %rsi
js 0x101fd
xorl %ecx, %ecx
movq %rsi, %rax
shrq $0x20, %rax
sete %cl
shll $0x6, %ecx
orl $0x196, %ecx            # imm = 0x196
testq $-0x80000000, %rsi      # imm = 0x80000000
movl $0x1f6, %eax            # imm = 0x1F6
cmovnel %ecx, %eax
jmp 0x1020a
movw $0xb6, %ax
cmpq $-0x80000000, %rsi      # imm = 0x80000000
jb 0x1020e
movw %ax, 0xe(%rdi)
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>>::GenericValue(unsigned long)
explicit GenericValue(uint64_t u64) RAPIDJSON_NOEXCEPT : data_() {
        data_.n.u64 = u64;
        data_.f.flags = kNumberUint64Flag;
        if (!(u64 & RAPIDJSON_UINT64_C2(0x80000000, 0x00000000)))
            data_.f.flags |= kInt64Flag;
        if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
            data_.f.flags |= kUintFlag;
        if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
            data_.f.flags |= kIntFlag;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $0x0, 0x8(%rdi)
movq %rsi, (%rdi)
xorl %eax, %eax
testq %rsi, %rsi
setns %al
shll $0x7, %eax
orl $0x116, %eax            # imm = 0x116
movq %rsi, %rcx
shrq $0x20, %rcx
xorl %edx, %edx
testq $-0x80000000, %rsi      # imm = 0x80000000
sete %dl
shll $0x5, %edx
orl $0x1d6, %edx            # imm = 0x1D6
testq %rcx, %rcx
cmovnel %eax, %edx
movw %dx, 0xe(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>::ClearStack()
void ClearStack() {
        if (Allocator::kNeedFree)
            while (stack_.GetSize() > 0)    // Here assumes all elements in stack array are GenericValue (Member is actually 2 GenericValue objects)
                (stack_.template Pop<ValueType>(1))->~ValueType();
        else
            stack_.Clear();
        stack_.ShrinkToFit();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x20(%rdi), %rax
movq 0x30(%rdi), %rcx
movq %rcx, 0x38(%rdi)
movq %rax, %rdi
popq %rbp
jmp 0x92a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/stack.h
// Function: rapidjson::internal::Stack<rapidjson::CrtAllocator>::ShrinkToFit()
void ShrinkToFit() { 
        if (Empty()) {
            // If the stack is empty, completely deallocate the memory.
            Allocator::Free(stack_); // NOLINT (+clang-analyzer-unix.Malloc)
            stack_ = 0;
            stackTop_ = 0;
            stackEnd_ = 0;
        }
        else
            Resize(GetSize());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
je 0x10292
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9b90
addq $0x10, %rbx
callq 0x9790
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericMemberIterator<false, rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::FindMember<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&)
MemberIterator FindMember(const GenericValue<Encoding, SourceAllocator>& name) {
        RAPIDJSON_ASSERT(IsObject());
        RAPIDJSON_ASSERT(name.IsString());
        MemberIterator member = MemberBegin();
        for ( ; member != MemberEnd(); ++member)
            if (name.StringEqual(member->name))
                break;
        return member;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpw $0x3, 0xe(%rsi)
jne 0x103ce
movq %rdx, %rbx
testb $0x4, 0xf(%rdx)
je 0x103ed
movq %rsi, %r15
movq %rdi, %r14
callq 0x93c0
leaq -0x28(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x9420
movq (%r14), %rsi
cmpq -0x28(%rbp), %rsi
je 0x103be
movq %rbx, %rdi
callq 0x9c00
testb %al, %al
jne 0x103be
addq $0x20, (%r14)
jmp 0x10398
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13c5(%rip), %rdi      # 0x1179a
leaq 0xeae(%rip), %rsi       # 0x1128a
leaq 0x359a(%rip), %rcx      # 0x1397d
movl $0x505, %edx            # imm = 0x505
callq 0x9380
leaq 0xe86(%rip), %rdi       # 0x1127a
leaq 0xe8f(%rip), %rsi       # 0x1128a
leaq 0x357b(%rip), %rcx      # 0x1397d
movl $0x506, %edx            # imm = 0x506
callq 0x9380
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: bool rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::StringEqual<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&) const
bool StringEqual(const GenericValue<Encoding, SourceAllocator>& rhs) const {
        RAPIDJSON_ASSERT(IsString());
        RAPIDJSON_ASSERT(rhs.IsString());

        const SizeType len1 = GetStringLength();
        const SizeType len2 = rhs.GetStringLength();
        if(len1 != len2) { return false; }

        const Ch* const str1 = GetString();
        const Ch* const str2 = rhs.GetString();
        if(str1 == str2) { return true; } // fast path for constant string

        return (std::memcmp(str1, str2, sizeof(Ch) * len1) == 0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testb $0x4, 0xf(%rdi)
je 0x10503
movq %rsi, %rbx
testb $0x4, 0xf(%rsi)
je 0x10522
movq %rdi, %r15
callq 0x9610
movl %eax, %r14d
movq %rbx, %rdi
callq 0x9610
cmpl %eax, %r14d
jne 0x104f2
movq %r15, %rdi
callq 0x90d0
movq %rax, %r15
movq %rbx, %rdi
callq 0x90d0
cmpq %rax, %r15
je 0x104f6
movl %r14d, %edx
movq %r15, %rdi
movq %rax, %rsi
callq 0x95e0
testl %eax, %eax
sete %al
jmp 0x104f8
xorl %eax, %eax
jmp 0x104f8
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd75(%rip), %rdi       # 0x1127f
leaq 0xd79(%rip), %rsi       # 0x1128a
leaq 0x3687(%rip), %rcx      # 0x13b9f
movl $0x84a, %edx            # imm = 0x84A
callq 0x9380
leaq 0x376b(%rip), %rdi      # 0x13c94
leaq 0xd5a(%rip), %rsi       # 0x1128a
leaq 0x3668(%rip), %rcx      # 0x13b9f
movl $0x84b, %edx            # imm = 0x84B
callq 0x9380
nop
// 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>>& rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::operator[]<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&)
GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) {
        MemberIterator member = FindMember(name);
        if (member != MemberEnd())
            return member->value;
        else {
            RAPIDJSON_ASSERT(false);    // see above note

            // This will generate -Wexit-time-destructors in clang
            // static GenericValue NullValue;
            // return NullValue;

            // Use static buffer and placement-new to prevent destruction
            static char buffer[sizeof(GenericValue)];
            return *new (buffer) GenericValue();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq -0x28(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x93b0
leaq -0x20(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9420
movq (%r14), %rax
cmpq (%r15), %rax
je 0x1058a
addq $0x10, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xce0(%rip), %rdi       # 0x11271
leaq 0xcf2(%rip), %rsi       # 0x1128a
leaq 0x3704(%rip), %rcx      # 0x13ca3
movl $0x491, %edx            # imm = 0x491
callq 0x9380
// File: /workspace/github_cpp_makefile_star2_O2/willprice[P]parallel-cpp-workshop/parallel_reduce.cpp
// Function: main
int main(int argc, char **argv)
{
  auto total = tbb::parallel_reduce(
      tbb::blocked_range<int>(0, 10000),
      0.0,
      [&](tbb::blocked_range<int> r, double running_total) {
        for (int i = r.begin(); i < r.end(); i++) {
          running_total += std::sin(i * 0.001);
        }
        return running_total;
      }, std::plus<double>());
  std::cout << total << std::endl;
}

// Assembly:
pushq %rbx
subq $0xe0, %rsp
leaq 0x58(%rsp), %rax
andq $0x0, (%rax)
movq %rax, 0x18(%rsp)
leaq 0xe(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xd(%rsp), %rax
movq %rax, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
leaq 0x60(%rsp), %rdi
pushq $0x4
popq %rsi
callq 0x28e4
andq $0x0, 0x38(%rsp)
movl $0x1, 0x40(%rsp)
pushq $0x1
popq %rax
movq %rax, 0x48(%rsp)
movq %rax, 0x50(%rsp)
leaq 0x10(%rsp), %rdi
andq $0x0, (%rdi)
movl $0x80, %esi
callq 0x2040
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
andq $0x0, 0x38(%rax)
leaq 0x2a13(%rip), %rax      # 0x4d38
movq %rax, (%rbx)
movq $0x2710, 0x40(%rbx)     # imm = 0x2710
movq $0x1, 0x48(%rbx)
leaq 0x18(%rsp), %rax
movq %rax, 0x50(%rbx)
movq %rbx, %rdi
addq $0x60, %rdi
leaq 0xf(%rsp), %rsi
callq 0x2918
leaq 0x48(%rsp), %rdx
movq 0x10(%rsp), %rax
movq %rax, 0x70(%rbx)
movb $0x0, 0x78(%rbx)
leaq 0x38(%rsp), %rax
movq %rax, 0x58(%rbx)
leaq 0x60(%rsp), %rcx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x20e0
leaq 0x60(%rsp), %rdi
callq 0x28f0
movsd 0x30(%rsp), %xmm0
movq 0x2c44(%rip), %rdi      # 0x4fd8
callq 0x2110
movq %rax, %rdi
callq 0x2080
xorl %eax, %eax
addq $0xe0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x28f0
movq %rbx, %rdi
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH07_Classes/examples/useAccount.cc
// Function: main
int main()
{
	Account a1("bem", 42);
	cout << a1.balance() << endl;
	a1.calculate();
	cout << a1.balance() << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
leaq 0xdd5(%rip), %rsi       # 0x2014
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x1030
leaq -0x148(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1060
movabsq $0x4045000000000000, %rax # imm = 0x4045000000000000
movq %rax, -0x128(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10a8
movsd -0x128(%rbp), %xmm0
movq 0x2d53(%rip), %rdi      # 0x3fd8
callq 0x1080
movq %rax, %rdi
callq 0x1040
movsd -0x128(%rbp), %xmm1
leaq 0x2def(%rip), %rax      # 0x4090
movsd (%rax), %xmm0
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x128(%rbp)
movq 0x2d1c(%rip), %rdi      # 0x3fd8
callq 0x1080
movq %rax, %rdi
callq 0x1040
leaq -0x148(%rbp), %rdi
callq 0x10a8
xorl %eax, %eax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x12f9
movq %rax, %rbx
jmp 0x12fe
movq %rax, %rbx
leaq -0x148(%rbp), %rdi
callq 0x10a8
movq %rbx, %rdi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Matrix/Mat.cpp
// Function: Matrix::Matrix(int, int)
Matrix::Matrix (int height, int width) {
    this->width = width;
    this->height = height;
    array = new Vector[height];
    for (int i = 0; i < height; i++) {
        array[i] = Vector(width);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %r15
movl %edx, -0x2c(%rbp)
movl %edx, 0xc(%rdi)
movl %esi, 0x8(%rdi)
movslq %esi, %rbx
movq %rbx, %r13
shlq $0x4, %r13
testl %ebx, %ebx
pushq $-0x1
popq %rdi
cmovnsq %r13, %rdi
callq 0x2030
movq %rax, %r12
testl %ebx, %ebx
je 0x28af
xorl %ebx, %ebx
leaq (%r12,%rbx), %rdi
callq 0x7316
addq $0x10, %rbx
cmpq %rbx, %r13
jne 0x289d
movq %r12, (%r15)
xorl %r13d, %r13d
testl %r14d, %r14d
cmovlel %r13d, %r14d
shlq $0x4, %r14
leaq -0x40(%rbp), %r12
movl -0x2c(%rbp), %ebx
cmpq %r13, %r14
je 0x28ef
movq %r12, %rdi
movl %ebx, %esi
callq 0x7294
movq (%r15), %rax
movl -0x38(%rbp), %ecx
movl %ecx, 0x8(%rax,%r13)
movq -0x40(%rbp), %rcx
movq %rcx, (%rax,%r13)
addq $0x10, %r13
jmp 0x28c7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Matrix/Mat.cpp
// Function: Matrix::print()
void Matrix::print () {
    cout<<endl;
    for (int i = 0; i < this->height; i++) {
        for (int x = 0; x < this->width; x++) {
            cout<<this->array[i].array[x].value<<" ";
        }
        cout<<endl;
    }
    cout<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc69e(%rip), %rdi      # 0xefc8
callq 0x20b0
xorl %r13d, %r13d
leaq 0x794b(%rip), %r15      # 0xa284
movslq 0x8(%rbx), %rax
cmpq %rax, %r13
jge 0x299b
movq %r13, -0x30(%rbp)
shlq $0x4, %r13
xorl %r12d, %r12d
xorl %r14d, %r14d
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jge 0x2986
movq (%rbx), %rax
movq (%rax,%r13), %rax
movsd (%rax,%r12), %xmm0
movq 0xc65b(%rip), %rdi      # 0xefc8
callq 0x21d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
incq %r14
addq $0x30, %r12
jmp 0x2950
movq 0xc63b(%rip), %rdi      # 0xefc8
callq 0x20b0
movq -0x30(%rbp), %r13
incq %r13
jmp 0x2939
movq 0xc626(%rip), %rdi      # 0xefc8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Matrix/operations.cpp
// Function: Matrix::operator=(std::initializer_list<std::initializer_list<Variable>>)
void Matrix::operator= (initializer_list<initializer_list<Variable>> ar) {
    // find height / width
    int ar_height = ar.size();
    int ar_width = ar.begin()->size();
    for (int i = 1; i < ar_height; i++) {
        if (ar_width != (ar.begin()+i)->size()) {
            throw invalid_argument("array invalid");
        }
    }
    // check height / width
    if (this->height != ar_height) throw invalid_argument("height invalid");
    if (this->width != ar_width) throw invalid_argument("width invalid");
    // assign
    for (int i = 0; i < ar_height; i++) {
        this->array[i] = *(ar.begin() + i);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rsi), %rax
movslq %eax, %rcx
movslq %ebx, %rdx
leaq 0x18(%rsi), %rdi
xorl %esi, %esi
incq %rsi
cmpq %rdx, %rsi
jge 0x2d12
leaq 0x10(%rdi), %r8
cmpq (%rdi), %rcx
movq %r8, %rdi
je 0x2cce
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x7310(%rip), %rsi      # 0xa004
movq %rax, %rdi
callq 0x2260
movq 0xc2dd(%rip), %rsi      # 0xefe0
movq 0xc2c6(%rip), %rdx      # 0xefd0
movq %rbx, %rdi
callq 0x21f0
cmpl %ebx, 0x8(%r15)
jne 0x2d53
cmpl %eax, 0xc(%r15)
jne 0x2d6f
xorl %r12d, %r12d
testl %ebx, %ebx
cmovlel %r12d, %ebx
shlq $0x4, %rbx
cmpq %r12, %rbx
je 0x2d4a
movq (%r14,%r12), %rsi
movq 0x8(%r14,%r12), %rdx
movq (%r15), %rdi
addq %r12, %rdi
callq 0x845a
addq $0x10, %r12
jmp 0x2d2b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x72e7(%rip), %rsi      # 0xa04c
movq %rax, %rdi
callq 0x2260
jmp 0x2cfc
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x72da(%rip), %rsi      # 0xa05b
movq %rax, %rdi
callq 0x2260
jmp 0x2cfc
jmp 0x2d92
jmp 0x2d92
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Matrix/operations.cpp
// Function: operator+(Matrix const&, Matrix const&)
Matrix operator+ (const Matrix &a, const Matrix &b) {
    // see if width / height is feasible
    if (a.width != b.width) throw invalid_argument("Width invalid");
    if (a.height != b.height) throw invalid_argument("Height invalid");
    // create matrix 
    Matrix return_mat = Matrix(a.height, a.width);
    // operations
    for (int i = 0; i < a.height; i++) {
        for (int x = 0; x < a.width; x++) {
            return_mat.array[i].array[x] = a.array[i].array[x] + b.array[i].array[x];
        }
    }
    // return
    return return_mat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0xc(%rdi), %edx
cmpl 0xc(%rsi), %edx
jne 0x2e6b
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %esi
cmpl 0x8(%rbx), %esi
jne 0x2e87
leaq -0x40(%rbp), %rdi
callq 0x285c
xorl %r13d, %r13d
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jge 0x2e54
movq %r13, -0x30(%rbp)
shlq $0x4, %r13
xorl %r12d, %r12d
xorl %r15d, %r15d
movslq 0xc(%r14), %rax
cmpq %rax, %r15
jge 0x2e4b
movq (%r14), %rax
movq (%rax,%r13), %rsi
addq %r12, %rsi
movq (%rbx), %rax
movq (%rax,%r13), %rdx
addq %r12, %rdx
leaq -0x70(%rbp), %rdi
callq 0x4e7c
movq -0x40(%rbp), %rax
movq (%rax,%r13), %rax
movups -0x70(%rbp), %xmm0
movups -0x60(%rbp), %xmm1
movups -0x50(%rbp), %xmm2
movups %xmm2, 0x20(%rax,%r12)
movups %xmm1, 0x10(%rax,%r12)
movups %xmm0, (%rax,%r12)
incq %r15
addq $0x30, %r12
jmp 0x2df7
movq -0x30(%rbp), %r13
incq %r13
jmp 0x2de0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x71ec(%rip), %rsi      # 0xa069
movq %rax, %rdi
callq 0x2260
jmp 0x2ea1
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x71de(%rip), %rsi      # 0xa077
movq %rax, %rdi
callq 0x2260
movq 0xc138(%rip), %rsi      # 0xefe0
movq 0xc121(%rip), %rdx      # 0xefd0
movq %rbx, %rdi
callq 0x21f0
jmp 0x2eb9
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Matrix/operations.cpp
// Function: operator+(Matrix const&, double const&)
Matrix operator+ (const Matrix &a, const double &b) {
    // create matrix 
    Matrix return_mat = Matrix(a.height, a.width);
    // operations
    for (int i = 0; i < a.height; i++) {
        for (int x = 0; x < a.width; x++) {
            Variable *new_var = new Variable();
            new_var->operation = op::argument;
            new_var->value = b;
            return_mat.array[i].array[x] = a.array[i].array[x] + (*new_var);
        }
    }
    // return
    return return_mat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %r14
movl 0x8(%rdi), %esi
movl 0xc(%rdi), %edx
leaq -0x48(%rbp), %rdi
callq 0x285c
xorl %r12d, %r12d
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jge 0x2f97
movq %r12, -0x30(%rbp)
shlq $0x4, %r12
xorl %r13d, %r13d
xorl %ebx, %ebx
movslq 0xc(%r14), %rax
cmpq %rax, %rbx
jge 0x2f8b
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
pushq $0x1
popq %rsi
callq 0x3bbc
movl $0x1, 0x8(%r15)
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%r15)
movq (%r14), %rax
movq (%rax,%r12), %rsi
addq %r13, %rsi
leaq -0x78(%rbp), %rdi
movq %r15, %rdx
callq 0x4e7c
movq -0x48(%rbp), %rax
movq (%rax,%r12), %rax
movups -0x78(%rbp), %xmm0
movups -0x68(%rbp), %xmm1
movups -0x58(%rbp), %xmm2
movups %xmm2, 0x20(%rax,%r13)
movups %xmm1, 0x10(%rax,%r13)
movups %xmm0, (%rax,%r13)
incq %rbx
addq $0x30, %r13
jmp 0x2f10
movq -0x30(%rbp), %r12
incq %r12
jmp 0x2ef6
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230