LLVMFuzzerTestOneInput:
   48|     26|{
   49|     26|    const std::string s(data, data + size);
   50|       |
   51|     26|    fuzzWithFlags<rapidjson::kParseDefaultFlags>(s);
   52|     26|    fuzzWithFlags<rapidjson::kParseFullPrecisionFlag>(s);
   53|     26|    fuzzWithFlags<rapidjson::kParseNumbersAsStringsFlag>(s);
   54|     26|    fuzzWithFlags<rapidjson::kParseCommentsFlag>(s);
   55|       |
   56|     26|    return 0;
   57|     26|}
_Z13fuzzWithFlagsILj0EEvRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
   27|     26|{
   28|       |    /* Parse input to rapidjson::Document */
   29|     26|    rapidjson::Document document;
   30|     26|    rapidjson::ParseResult pr = document.Parse<parseFlags>(s.c_str());
   31|     26|    if ( !pr ) {
  ------------------
  |  Branch (31:10): [True: 17, False: 9]
  ------------------
   32|     17|        return;
   33|     17|    }
   34|       |
   35|       |    /* Convert from rapidjson::Document to string */
   36|      9|    rapidjson::StringBuffer sb;
   37|      9|    rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(sb);
   38|      9|    document.Accept(writer);
   39|      9|    std::string str = sb.GetString();
   40|       |#ifdef MSAN
   41|       |    if ( str.size() ) {
   42|       |        __msan_check_mem_is_initialized(str.data(), str.size());
   43|       |    }
   44|       |#endif
   45|      9|}
_Z13fuzzWithFlagsILj16EEvRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
   27|     26|{
   28|       |    /* Parse input to rapidjson::Document */
   29|     26|    rapidjson::Document document;
   30|     26|    rapidjson::ParseResult pr = document.Parse<parseFlags>(s.c_str());
   31|     26|    if ( !pr ) {
  ------------------
  |  Branch (31:10): [True: 14, False: 12]
  ------------------
   32|     14|        return;
   33|     14|    }
   34|       |
   35|       |    /* Convert from rapidjson::Document to string */
   36|     12|    rapidjson::StringBuffer sb;
   37|     12|    rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(sb);
   38|     12|    document.Accept(writer);
   39|     12|    std::string str = sb.GetString();
   40|       |#ifdef MSAN
   41|       |    if ( str.size() ) {
   42|       |        __msan_check_mem_is_initialized(str.data(), str.size());
   43|       |    }
   44|       |#endif
   45|     12|}
_Z13fuzzWithFlagsILj64EEvRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
   27|     26|{
   28|       |    /* Parse input to rapidjson::Document */
   29|     26|    rapidjson::Document document;
   30|     26|    rapidjson::ParseResult pr = document.Parse<parseFlags>(s.c_str());
   31|     26|    if ( !pr ) {
  ------------------
  |  Branch (31:10): [True: 12, False: 14]
  ------------------
   32|     12|        return;
   33|     12|    }
   34|       |
   35|       |    /* Convert from rapidjson::Document to string */
   36|     14|    rapidjson::StringBuffer sb;
   37|     14|    rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(sb);
   38|     14|    document.Accept(writer);
   39|     14|    std::string str = sb.GetString();
   40|       |#ifdef MSAN
   41|       |    if ( str.size() ) {
   42|       |        __msan_check_mem_is_initialized(str.data(), str.size());
   43|       |    }
   44|       |#endif
   45|     14|}
_Z13fuzzWithFlagsILj32EEvRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
   27|     26|{
   28|       |    /* Parse input to rapidjson::Document */
   29|     26|    rapidjson::Document document;
   30|     26|    rapidjson::ParseResult pr = document.Parse<parseFlags>(s.c_str());
   31|     26|    if ( !pr ) {
  ------------------
  |  Branch (31:10): [True: 17, False: 9]
  ------------------
   32|     17|        return;
   33|     17|    }
   34|       |
   35|       |    /* Convert from rapidjson::Document to string */
   36|      9|    rapidjson::StringBuffer sb;
   37|      9|    rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(sb);
   38|      9|    document.Accept(writer);
   39|      9|    std::string str = sb.GetString();
   40|       |#ifdef MSAN
   41|       |    if ( str.size() ) {
   42|       |        __msan_check_mem_is_initialized(str.data(), str.size());
   43|       |    }
   44|       |#endif
   45|      9|}

_ZN9rapidjson19MemoryPoolAllocatorINS_12CrtAllocatorEEC2EmPS1_:
  171|    104|        chunk_capacity_(chunkSize),
  172|    104|        baseAllocator_(baseAllocator ? baseAllocator : RAPIDJSON_NEW(BaseAllocator)()),
  ------------------
  |  |  712|    104|#define RAPIDJSON_NEW(TypeName) new TypeName
  ------------------
  |  Branch (172:24): [True: 0, False: 104]
  ------------------
  173|    104|        shared_(static_cast<SharedData*>(baseAllocator_ ? baseAllocator_->Malloc(SIZEOF_SHARED_DATA + SIZEOF_CHUNK_HEADER) : 0))
  ------------------
  |  Branch (173:42): [True: 104, False: 0]
  ------------------
  174|    104|    {
  175|    104|        RAPIDJSON_ASSERT(baseAllocator_ != 0);
  ------------------
  |  |  437|    104|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (175:9): [True: 104, False: 0]
  ------------------
  176|    104|        RAPIDJSON_ASSERT(shared_ != 0);
  ------------------
  |  |  437|    104|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (176:9): [True: 104, False: 0]
  ------------------
  177|    104|        if (baseAllocator) {
  ------------------
  |  Branch (177:13): [True: 0, False: 104]
  ------------------
  178|      0|            shared_->ownBaseAllocator = 0;
  179|      0|        }
  180|    104|        else {
  181|    104|            shared_->ownBaseAllocator = baseAllocator_;
  182|    104|        }
  183|    104|        shared_->chunkHead = GetChunkHead(shared_);
  184|    104|        shared_->chunkHead->capacity = 0;
  185|    104|        shared_->chunkHead->size = 0;
  186|    104|        shared_->chunkHead->next = 0;
  187|    104|        shared_->ownBuffer = true;
  188|    104|        shared_->refcount = 1;
  189|    104|    }
_ZN9rapidjson12CrtAllocator6MallocEm:
   86|    201|    void* Malloc(size_t size) { 
   87|    201|        if (size) //  behavior of malloc(0) is implementation defined.
  ------------------
  |  Branch (87:13): [True: 201, False: 0]
  ------------------
   88|    201|            return RAPIDJSON_MALLOC(size);
  ------------------
  |  |  696|    201|#define RAPIDJSON_MALLOC(size) std::malloc(size)
  ------------------
   89|      0|        else
   90|      0|            return NULL; // standardize to returning NULL.
   91|    201|    }
_ZN9rapidjson19MemoryPoolAllocatorINS_12CrtAllocatorEE12GetChunkHeadEPNS2_10SharedDataE:
  151|    104|    {
  152|    104|        return reinterpret_cast<ChunkHeader*>(reinterpret_cast<uint8_t*>(shared) + SIZEOF_SHARED_DATA);
  153|    104|    }
_ZN9rapidjson12CrtAllocator4FreeEPv:
  100|    601|    static void Free(void *ptr) RAPIDJSON_NOEXCEPT { RAPIDJSON_FREE(ptr); }
  ------------------
  |  |  704|    601|#define RAPIDJSON_FREE(ptr) std::free(ptr)
  ------------------
_ZN9rapidjson12CrtAllocator7ReallocEPvmm:
   92|  1.85k|    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
   93|  1.85k|        (void)originalSize;
   94|  1.85k|        if (newSize == 0) {
  ------------------
  |  Branch (94:13): [True: 0, False: 1.85k]
  ------------------
   95|      0|            RAPIDJSON_FREE(originalPtr);
  ------------------
  |  |  704|      0|#define RAPIDJSON_FREE(ptr) std::free(ptr)
  ------------------
   96|      0|            return NULL;
   97|      0|        }
   98|  1.85k|        return RAPIDJSON_REALLOC(originalPtr, newSize);
  ------------------
  |  |  700|  1.85k|#define RAPIDJSON_REALLOC(ptr, new_size) std::realloc(ptr, new_size)
  ------------------
   99|  1.85k|    }
_ZN9rapidjson19MemoryPoolAllocatorINS_12CrtAllocatorEE6MallocEm:
  321|  43.4k|    void* Malloc(size_t size) {
  322|  43.4k|        RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0);
  ------------------
  |  |  687|  43.4k|#define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x)
  |  |  ------------------
  |  |  |  |  437|  43.4k|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  ------------------
  ------------------
  |  Branch (322:9): [True: 43.4k, False: 0]
  ------------------
  323|  43.4k|        if (!size)
  ------------------
  |  Branch (323:13): [True: 0, False: 43.4k]
  ------------------
  324|      0|            return NULL;
  325|       |
  326|  43.4k|        size = RAPIDJSON_ALIGN(size);
  ------------------
  |  |  307|  43.4k|#define RAPIDJSON_ALIGN(x) (((x) + static_cast<size_t>(7u)) & ~static_cast<size_t>(7u))
  ------------------
  327|  43.4k|        if (RAPIDJSON_UNLIKELY(shared_->chunkHead->size + size > shared_->chunkHead->capacity))
  ------------------
  |  |  505|  43.4k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 97, False: 43.3k]
  |  |  ------------------
  ------------------
  328|     97|            if (!AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size))
  ------------------
  |  Branch (328:17): [True: 0, False: 97]
  |  Branch (328:27): [True: 70, False: 27]
  ------------------
  329|      0|                return NULL;
  330|       |
  331|  43.4k|        void *buffer = GetChunkBuffer(shared_) + shared_->chunkHead->size;
  332|  43.4k|        shared_->chunkHead->size += size;
  333|  43.4k|        return buffer;
  334|  43.4k|    }
_ZN9rapidjson19MemoryPoolAllocatorINS_12CrtAllocatorEE8AddChunkEm:
  390|     97|    bool AddChunk(size_t capacity) {
  391|     97|        if (!baseAllocator_)
  ------------------
  |  Branch (391:13): [True: 0, False: 97]
  ------------------
  392|      0|            shared_->ownBaseAllocator = baseAllocator_ = RAPIDJSON_NEW(BaseAllocator)();
  ------------------
  |  |  712|      0|#define RAPIDJSON_NEW(TypeName) new TypeName
  ------------------
  393|     97|        if (ChunkHeader* chunk = static_cast<ChunkHeader*>(baseAllocator_->Malloc(SIZEOF_CHUNK_HEADER + capacity))) {
  ------------------
  |  Branch (393:26): [True: 97, False: 0]
  ------------------
  394|     97|            chunk->capacity = capacity;
  395|     97|            chunk->size = 0;
  396|     97|            chunk->next = shared_->chunkHead;
  397|     97|            shared_->chunkHead = chunk;
  398|     97|            return true;
  399|     97|        }
  400|      0|        else
  401|      0|            return false;
  402|     97|    }
_ZN9rapidjson19MemoryPoolAllocatorINS_12CrtAllocatorEE14GetChunkBufferEPNS2_10SharedDataE:
  155|  43.4k|    {
  156|  43.4k|        return reinterpret_cast<uint8_t*>(shared->chunkHead) + SIZEOF_CHUNK_HEADER;
  157|  43.4k|    }
_ZN9rapidjson6MallocINS_13GenericMemberINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEES6_EEPT_RT0_m:
  443|  15.1k|{
  444|       |    return Realloc<T, A>(a, NULL, 0, n);
  445|  15.1k|}
_ZN9rapidjson7ReallocINS_13GenericMemberINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEES6_EEPT_RT0_S9_mm:
  436|  15.1k|{
  437|  15.1k|    RAPIDJSON_NOEXCEPT_ASSERT(old_n <= (std::numeric_limits<size_t>::max)() / sizeof(T) && new_n <= (std::numeric_limits<size_t>::max)() / sizeof(T));
  ------------------
  |  |  687|  15.1k|#define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x)
  |  |  ------------------
  |  |  |  |  437|  15.1k|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  ------------------
  ------------------
  |  Branch (437:5): [True: 15.1k, False: 0]
  |  Branch (437:5): [True: 15.1k, False: 0]
  |  Branch (437:5): [True: 15.1k, False: 0]
  ------------------
  438|  15.1k|    return static_cast<T*>(a.Realloc(old_p, old_n * sizeof(T), new_n * sizeof(T)));
  439|  15.1k|}
_ZN9rapidjson19MemoryPoolAllocatorINS_12CrtAllocatorEE7ReallocEPvmm:
  337|  15.1k|    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
  338|  15.1k|        if (originalPtr == 0)
  ------------------
  |  Branch (338:13): [True: 15.1k, False: 0]
  ------------------
  339|  15.1k|            return Malloc(newSize);
  340|       |
  341|      0|        RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0);
  ------------------
  |  |  687|      0|#define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x)
  |  |  ------------------
  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  ------------------
  ------------------
  |  Branch (341:9): [True: 0, False: 0]
  ------------------
  342|      0|        if (newSize == 0)
  ------------------
  |  Branch (342:13): [True: 0, False: 0]
  ------------------
  343|      0|            return NULL;
  344|       |
  345|      0|        originalSize = RAPIDJSON_ALIGN(originalSize);
  ------------------
  |  |  307|      0|#define RAPIDJSON_ALIGN(x) (((x) + static_cast<size_t>(7u)) & ~static_cast<size_t>(7u))
  ------------------
  346|      0|        newSize = RAPIDJSON_ALIGN(newSize);
  ------------------
  |  |  307|      0|#define RAPIDJSON_ALIGN(x) (((x) + static_cast<size_t>(7u)) & ~static_cast<size_t>(7u))
  ------------------
  347|       |
  348|       |        // Do not shrink if new size is smaller than original
  349|      0|        if (originalSize >= newSize)
  ------------------
  |  Branch (349:13): [True: 0, False: 0]
  ------------------
  350|      0|            return originalPtr;
  351|       |
  352|       |        // Simply expand it if it is the last allocation and there is sufficient space
  353|      0|        if (originalPtr == GetChunkBuffer(shared_) + shared_->chunkHead->size - originalSize) {
  ------------------
  |  Branch (353:13): [True: 0, False: 0]
  ------------------
  354|      0|            size_t increment = static_cast<size_t>(newSize - originalSize);
  355|      0|            if (shared_->chunkHead->size + increment <= shared_->chunkHead->capacity) {
  ------------------
  |  Branch (355:17): [True: 0, False: 0]
  ------------------
  356|      0|                shared_->chunkHead->size += increment;
  357|      0|                return originalPtr;
  358|      0|            }
  359|      0|        }
  360|       |
  361|       |        // Realloc process: allocate and copy memory, do not free original buffer.
  362|      0|        if (void* newBuffer = Malloc(newSize)) {
  ------------------
  |  Branch (362:19): [True: 0, False: 0]
  ------------------
  363|      0|            if (originalSize)
  ------------------
  |  Branch (363:17): [True: 0, False: 0]
  ------------------
  364|      0|                std::memcpy(newBuffer, originalPtr, originalSize);
  365|      0|            return newBuffer;
  366|      0|        }
  367|      0|        else
  368|      0|            return NULL;
  369|      0|    }
_ZN9rapidjson19MemoryPoolAllocatorINS_12CrtAllocatorEED2Ev:
  259|    104|    ~MemoryPoolAllocator() RAPIDJSON_NOEXCEPT {
  260|    104|        if (!shared_) {
  ------------------
  |  Branch (260:13): [True: 0, False: 104]
  ------------------
  261|       |            // do nothing if moved
  262|      0|            return;
  263|      0|        }
  264|    104|        if (shared_->refcount > 1) {
  ------------------
  |  Branch (264:13): [True: 0, False: 104]
  ------------------
  265|      0|            --shared_->refcount;
  266|      0|            return;
  267|      0|        }
  268|    104|        Clear();
  269|    104|        BaseAllocator *a = shared_->ownBaseAllocator;
  270|    104|        if (shared_->ownBuffer) {
  ------------------
  |  Branch (270:13): [True: 104, False: 0]
  ------------------
  271|    104|            baseAllocator_->Free(shared_);
  272|    104|        }
  273|    104|        RAPIDJSON_DELETE(a);
  ------------------
  |  |  716|    104|#define RAPIDJSON_DELETE(x) delete x
  ------------------
  274|    104|    }
_ZN9rapidjson19MemoryPoolAllocatorINS_12CrtAllocatorEE5ClearEv:
  277|    104|    void Clear() RAPIDJSON_NOEXCEPT {
  278|    104|        RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0);
  ------------------
  |  |  687|    104|#define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x)
  |  |  ------------------
  |  |  |  |  437|    104|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  ------------------
  ------------------
  |  Branch (278:9): [True: 104, False: 0]
  ------------------
  279|    201|        for (;;) {
  280|    201|            ChunkHeader* c = shared_->chunkHead;
  281|    201|            if (!c->next) {
  ------------------
  |  Branch (281:17): [True: 104, False: 97]
  ------------------
  282|    104|                break;
  283|    104|            }
  284|     97|            shared_->chunkHead = c->next;
  285|     97|            baseAllocator_->Free(c);
  286|     97|        }
  287|    104|        shared_->chunkHead->size = 0;
  288|    104|    }

_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_EC2EPS5_mPS4_:
 2528|    104|        allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
 2529|    104|    {
 2530|    104|        if (!allocator_)
  ------------------
  |  Branch (2530:13): [True: 104, False: 0]
  ------------------
 2531|    104|            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
  ------------------
  |  |  712|    104|#define RAPIDJSON_NEW(TypeName) new TypeName
  ------------------
 2532|    104|    }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEC2Ev:
  690|    397|    GenericValue() RAPIDJSON_NOEXCEPT : data_() { data_.f.flags = kNullFlag; }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEED2Ev:
  880|    296|    ~GenericValue() {
  881|       |        // With RAPIDJSON_USE_MEMBERSMAP, the maps need to be destroyed to release
  882|       |        // their Allocator if it's refcounted (e.g. MemoryPoolAllocator).
  883|    296|        if (Allocator::kNeedFree || (RAPIDJSON_USE_MEMBERSMAP+0 &&
  ------------------
  |  |  180|      0|#define RAPIDJSON_USE_MEMBERSMAP 0 // not by default
  ------------------
  |  Branch (883:13): [Folded, False: 0]
  |  Branch (883:38): [Folded, False: 0]
  ------------------
  884|      0|                                     internal::IsRefCounted<Allocator>::Value)) {
  ------------------
  |  Branch (884:38): [True: 0, Folded]
  ------------------
  885|      0|            switch(data_.f.flags) {
  886|      0|            case kArrayFlag:
  ------------------
  |  Branch (886:13): [True: 0, False: 0]
  ------------------
  887|      0|                {
  888|      0|                    GenericValue* e = GetElementsPointer();
  889|      0|                    for (GenericValue* v = e; v != e + data_.a.size; ++v)
  ------------------
  |  Branch (889:47): [True: 0, False: 0]
  ------------------
  890|      0|                        v->~GenericValue();
  891|      0|                    if (Allocator::kNeedFree) { // Shortcut by Allocator's trait
  ------------------
  |  Branch (891:25): [Folded, False: 0]
  ------------------
  892|      0|                        Allocator::Free(e);
  893|      0|                    }
  894|      0|                }
  895|      0|                break;
  896|       |
  897|      0|            case kObjectFlag:
  ------------------
  |  Branch (897:13): [True: 0, False: 0]
  ------------------
  898|      0|                DoFreeMembers();
  899|      0|                break;
  900|       |
  901|      0|            case kCopyStringFlag:
  ------------------
  |  Branch (901:13): [True: 0, False: 0]
  ------------------
  902|      0|                if (Allocator::kNeedFree) { // Shortcut by Allocator's trait
  ------------------
  |  Branch (902:21): [Folded, False: 0]
  ------------------
  903|      0|                    Allocator::Free(const_cast<Ch*>(GetStringPointer()));
  904|      0|                }
  905|      0|                break;
  906|       |
  907|      0|            default:
  ------------------
  |  Branch (907:13): [True: 0, False: 0]
  ------------------
  908|      0|                break;  // Do nothing for other types.
  909|      0|            }
  910|      0|        }
  911|    296|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E5ParseILj0EEERS6_PKc:
 2720|     26|    GenericDocument& Parse(const Ch* str) {
 2721|     26|        return Parse<parseFlags, Encoding>(str);
 2722|     26|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E5ParseILj0ES2_EERS6_PKNT0_2ChE:
 2709|     26|    GenericDocument& Parse(const typename SourceEncoding::Ch* str) {
 2710|     26|        RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag));
  ------------------
  |  |  437|     26|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (2710:9): [True: 26, Folded]
  ------------------
 2711|     26|        GenericStringStream<SourceEncoding> s(str);
 2712|     26|        return ParseStream<parseFlags, SourceEncoding>(s);
 2713|     26|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E11ParseStreamILj0ES2_NS_19GenericStringStreamIS2_EEEERS6_RT1_:
 2643|     26|    GenericDocument& ParseStream(InputStream& is) {
 2644|     26|        GenericReader<SourceEncoding, Encoding, StackAllocator> reader(
 2645|     26|            stack_.HasAllocator() ? &stack_.GetAllocator() : 0);
  ------------------
  |  Branch (2645:13): [True: 0, False: 26]
  ------------------
 2646|     26|        ClearStackOnExit scope(*this);
 2647|     26|        parseResult_ = reader.template Parse<parseFlags>(is, *this);
 2648|     26|        if (parseResult_) {
  ------------------
  |  Branch (2648:13): [True: 9, False: 17]
  ------------------
 2649|      9|            RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object
  ------------------
  |  |  437|      9|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (2649:13): [True: 9, False: 0]
  ------------------
 2650|      9|            ValueType::operator=(*stack_.template Pop<ValueType>(1));// Move value from stack to document
 2651|      9|        }
 2652|     26|        return *this;
 2653|     26|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E16ClearStackOnExitC2ERS6_:
 2807|    104|        explicit ClearStackOnExit(GenericDocument& d) : d_(d) {}
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E4NullEv:
 2821|    145|    bool Null() { new (stack_.template Push<ValueType>()) ValueType(); return true; }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E4BoolEb:
 2822|  1.03k|    bool Bool(bool b) { new (stack_.template Push<ValueType>()) ValueType(b); return true; }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEC2IbEET_PNS_8internal8EnableIfINS9_15RemoveSfinaeTagIPFRNS9_9SfinaeTagENS9_6IsSameIbS8_EEEE4TypeEvE4TypeE:
  785|  1.03k|        : data_() {
  786|       |            // safe-guard against failing SFINAE
  787|  1.03k|            RAPIDJSON_STATIC_ASSERT((internal::IsSame<bool,T>::Value));
  ------------------
  |  |  447|  1.03k|   static_assert(x, RAPIDJSON_STRINGIFY(x))
  ------------------
  788|  1.03k|            data_.f.flags = b ? kTrueFlag : kFalseFlag;
  ------------------
  |  Branch (788:29): [True: 11, False: 1.02k]
  ------------------
  789|  1.03k|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E3KeyEPKcjb:
 2847|   757k|    bool Key(const Ch* str, SizeType length, bool copy) { return String(str, length, copy); }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E6StringEPKcjb:
 2837|   757k|    bool String(const Ch* str, SizeType length, bool copy) { 
 2838|   757k|        if (copy) 
  ------------------
  |  Branch (2838:13): [True: 757k, False: 0]
  ------------------
 2839|   757k|            new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
 2840|      0|        else
 2841|      0|            new (stack_.template Push<ValueType>()) ValueType(str, length);
 2842|   757k|        return true;
 2843|   757k|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E12GetAllocatorEv:
 2796|  4.03M|    Allocator& GetAllocator() {
 2797|  4.03M|        RAPIDJSON_ASSERT(allocator_);
  ------------------
  |  |  437|  4.03M|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (2797:9): [True: 4.03M, False: 0]
  ------------------
 2798|  4.03M|        return *allocator_;
 2799|  4.03M|    }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEC2EPKcjRS5_:
  843|  3.98M|    GenericValue(const Ch* s, SizeType length, Allocator& allocator) : data_() { SetStringRaw(StringRef(s, length), allocator); }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE12SetStringRawENS_16GenericStringRefIcEERS5_:
 2442|  3.98M|    void SetStringRaw(StringRefType s, Allocator& allocator) {
 2443|  3.98M|        Ch* str = 0;
 2444|  3.98M|        if (ShortString::Usable(s.length)) {
  ------------------
  |  Branch (2444:13): [True: 3.97M, False: 9.15k]
  ------------------
 2445|  3.97M|            data_.f.flags = kShortStringFlag;
 2446|  3.97M|            data_.ss.SetLength(s.length);
 2447|  3.97M|            str = data_.ss.str;
 2448|  3.97M|            std::memmove(str, s, s.length * sizeof(Ch));
 2449|  3.97M|        } else {
 2450|  9.15k|            data_.f.flags = kCopyStringFlag;
 2451|  9.15k|            data_.s.length = s.length;
 2452|  9.15k|            str = static_cast<Ch *>(allocator.Malloc((s.length + 1) * sizeof(Ch)));
 2453|  9.15k|            SetStringPointer(str);
 2454|  9.15k|            std::memcpy(str, s, s.length * sizeof(Ch));
 2455|  9.15k|        }
 2456|  3.98M|        str[s.length] = '\0';
 2457|  3.98M|    }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE11ShortString6UsableEj:
 2055|  3.98M|        inline static bool Usable(SizeType len) { return                       (MaxSize >= len); }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE11ShortString9SetLengthEj:
 2056|  3.97M|        inline void     SetLength(SizeType len) { str[LenPos] = static_cast<Ch>(MaxSize -  len); }
_ZNK9rapidjson16GenericStringRefIcEcvPKcEv:
  417|  3.98M|    operator const Ch *() const { return s; }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE16SetStringPointerEPKc:
 2115|  9.15k|    RAPIDJSON_FORCEINLINE const Ch* SetStringPointer(const Ch* str) { return RAPIDJSON_SETPOINTER(Ch, data_.s.str, str); }
  ------------------
  |  |  346|  9.15k|#define RAPIDJSON_SETPOINTER(type, p, x) (p = reinterpret_cast<type *>((reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0xFFFF0000, 0x00000000))) | reinterpret_cast<uintptr_t>(reinterpret_cast<const void*>(x))))
  |  |  ------------------
  |  |  |  |  320|  9.15k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  |  |  ------------------
  ------------------
_ZN9rapidjson9StringRefIcEENS_16GenericStringRefIT_EEPKS2_m:
  474|  3.98M|inline GenericStringRef<CharType> StringRef(const CharType* str, size_t length) {
  475|  3.98M|    return GenericStringRef<CharType>(str, SizeType(length));
  476|  3.98M|}
_ZN9rapidjson16GenericStringRefIcEC2EPKcj:
  412|  3.98M|        : s(RAPIDJSON_LIKELY(str) ? str : emptyString), length(len) { RAPIDJSON_ASSERT(str != 0 || len == 0u); }
  ------------------
  |  |  492|  3.98M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 3.98M, False: 0]
  |  |  ------------------
  ------------------
                      : s(RAPIDJSON_LIKELY(str) ? str : emptyString), length(len) { RAPIDJSON_ASSERT(str != 0 || len == 0u); }
  ------------------
  |  |  437|  3.98M|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (412:71): [True: 3.98M, False: 0]
  |  Branch (412:71): [True: 0, False: 0]
  |  Branch (412:71): [True: 3.98M, False: 0]
  ------------------
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E11StartObjectEv:
 2845|  30.1k|    bool StartObject() { new (stack_.template Push<ValueType>()) ValueType(kObjectType); return true; }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEC2ENS_4TypeE:
  720|  55.3k|    explicit GenericValue(Type type) RAPIDJSON_NOEXCEPT : data_() {
  721|  55.3k|        static const uint16_t defaultFlags[] = {
  722|  55.3k|            kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag,
  723|  55.3k|            kNumberAnyFlag
  724|  55.3k|        };
  725|  55.3k|        RAPIDJSON_NOEXCEPT_ASSERT(type >= kNullType && type <= kNumberType);
  ------------------
  |  |  687|  55.3k|#define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x)
  |  |  ------------------
  |  |  |  |  437|  55.3k|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  ------------------
  ------------------
  |  Branch (725:9): [True: 55.3k, False: 0]
  |  Branch (725:9): [True: 55.3k, False: 0]
  |  Branch (725:9): [True: 55.3k, False: 0]
  ------------------
  726|  55.3k|        data_.f.flags = defaultFlags[type];
  727|       |
  728|       |        // Use ShortString to store empty string.
  729|  55.3k|        if (type == kStringType)
  ------------------
  |  Branch (729:13): [True: 0, False: 55.3k]
  ------------------
  730|      0|            data_.ss.SetLength(0);
  731|  55.3k|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E9EndObjectEj:
 2849|  30.1k|    bool EndObject(SizeType memberCount) {
 2850|  30.1k|        typename ValueType::Member* members = stack_.template Pop<typename ValueType::Member>(memberCount);
 2851|  30.1k|        stack_.template Top<ValueType>()->SetObjectRaw(members, memberCount, GetAllocator());
 2852|  30.1k|        return true;
 2853|  30.1k|    }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE12SetObjectRawEPNS_13GenericMemberIS2_S5_EEjRS5_:
 2415|  30.1k|    void SetObjectRaw(Member* members, SizeType count, Allocator& allocator) {
 2416|  30.1k|        data_.f.flags = kObjectFlag;
 2417|  30.1k|        if (count) {
  ------------------
  |  Branch (2417:13): [True: 15.1k, False: 15.0k]
  ------------------
 2418|  15.1k|            Member* m = DoAllocMembers(count, allocator);
 2419|  15.1k|            SetMembersPointer(m);
 2420|  15.1k|            std::memcpy(static_cast<void*>(m), members, count * sizeof(Member));
 2421|       |#if RAPIDJSON_USE_MEMBERSMAP
 2422|       |            Map* &map = GetMap(m);
 2423|       |            MapIterator* mit = GetMapIterators(map);
 2424|       |            for (SizeType i = 0; i < count; i++) {
 2425|       |                new (&mit[i]) MapIterator(map->insert(MapPair(m[i].name.data_, i)));
 2426|       |            }
 2427|       |#endif
 2428|  15.1k|        }
 2429|  15.0k|        else
 2430|  15.0k|            SetMembersPointer(0);
 2431|  30.1k|        data_.o.size = data_.o.capacity = count;
 2432|  30.1k|    }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE14DoAllocMembersEjRS5_:
 2268|  15.1k|    RAPIDJSON_FORCEINLINE Member* DoAllocMembers(SizeType capacity, Allocator& allocator) {
 2269|  15.1k|        return Malloc<Member>(allocator, capacity);
 2270|  15.1k|    }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE17SetMembersPointerEPNS_13GenericMemberIS2_S5_EE:
 2119|  30.1k|    RAPIDJSON_FORCEINLINE Member* SetMembersPointer(Member* members) { return RAPIDJSON_SETPOINTER(Member, data_.o.members, members); }
  ------------------
  |  |  346|  30.1k|#define RAPIDJSON_SETPOINTER(type, p, x) (p = reinterpret_cast<type *>((reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0xFFFF0000, 0x00000000))) | reinterpret_cast<uintptr_t>(reinterpret_cast<const void*>(x))))
  |  |  ------------------
  |  |  |  |  320|  30.1k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  |  |  ------------------
  ------------------
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E10StartArrayEv:
 2855|  25.1k|    bool StartArray() { new (stack_.template Push<ValueType>()) ValueType(kArrayType); return true; }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E8EndArrayEj:
 2857|  19.1k|    bool EndArray(SizeType elementCount) {
 2858|  19.1k|        ValueType* elements = stack_.template Pop<ValueType>(elementCount);
 2859|  19.1k|        stack_.template Top<ValueType>()->SetArrayRaw(elements, elementCount, GetAllocator());
 2860|  19.1k|        return true;
 2861|  19.1k|    }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE11SetArrayRawEPS6_jRS5_:
 2402|  19.1k|    void SetArrayRaw(GenericValue* values, SizeType count, Allocator& allocator) {
 2403|  19.1k|        data_.f.flags = kArrayFlag;
 2404|  19.1k|        if (count) {
  ------------------
  |  Branch (2404:13): [True: 19.1k, False: 22]
  ------------------
 2405|  19.1k|            GenericValue* e = static_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));
 2406|  19.1k|            SetElementsPointer(e);
 2407|  19.1k|            std::memcpy(static_cast<void*>(e), values, count * sizeof(GenericValue));
 2408|  19.1k|        }
 2409|     22|        else
 2410|     22|            SetElementsPointer(0);
 2411|  19.1k|        data_.a.size = data_.a.capacity = count;
 2412|  19.1k|    }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE18SetElementsPointerEPS6_:
 2117|  19.1k|    RAPIDJSON_FORCEINLINE GenericValue* SetElementsPointer(GenericValue* elements) { return RAPIDJSON_SETPOINTER(GenericValue, data_.a.elements, elements); }
  ------------------
  |  |  346|  19.1k|#define RAPIDJSON_SETPOINTER(type, p, x) (p = reinterpret_cast<type *>((reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0xFFFF0000, 0x00000000))) | reinterpret_cast<uintptr_t>(reinterpret_cast<const void*>(x))))
  |  |  ------------------
  |  |  |  |  320|  19.1k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  |  |  ------------------
  ------------------
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E6DoubleEd:
 2827|  51.9k|    bool Double(double d) { new (stack_.template Push<ValueType>()) ValueType(d); return true; }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEC2Ed:
  831|  51.9k|    explicit GenericValue(double d) RAPIDJSON_NOEXCEPT : data_() { data_.n.d = d; data_.f.flags = kNumberDoubleFlag; }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E5Int64El:
 2825|    188|    bool Int64(int64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEC2El:
  804|    188|    explicit GenericValue(int64_t i64) RAPIDJSON_NOEXCEPT : data_() {
  805|    188|        data_.n.i64 = i64;
  806|    188|        data_.f.flags = kNumberInt64Flag;
  807|    188|        if (i64 >= 0) {
  ------------------
  |  Branch (807:13): [True: 0, False: 188]
  ------------------
  808|      0|            data_.f.flags |= kNumberUint64Flag;
  809|      0|            if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
  ------------------
  |  |  320|      0|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  |  Branch (809:17): [True: 0, False: 0]
  ------------------
  810|      0|                data_.f.flags |= kUintFlag;
  811|      0|            if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
  ------------------
  |  |  320|      0|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  |  Branch (811:17): [True: 0, False: 0]
  ------------------
  812|      0|                data_.f.flags |= kIntFlag;
  813|      0|        }
  814|    188|        else if (i64 >= static_cast<int64_t>(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
  ------------------
  |  |  320|    188|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  |  Branch (814:18): [True: 0, False: 188]
  ------------------
  815|      0|            data_.f.flags |= kIntFlag;
  816|    188|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E6Uint64Em:
 2826|  11.0k|    bool Uint64(uint64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEC2Em:
  819|  11.0k|    explicit GenericValue(uint64_t u64) RAPIDJSON_NOEXCEPT : data_() {
  820|  11.0k|        data_.n.u64 = u64;
  821|  11.0k|        data_.f.flags = kNumberUint64Flag;
  822|  11.0k|        if (!(u64 & RAPIDJSON_UINT64_C2(0x80000000, 0x00000000)))
  ------------------
  |  |  320|  11.0k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  |  Branch (822:13): [True: 9.22k, False: 1.80k]
  ------------------
  823|  9.22k|            data_.f.flags |= kInt64Flag;
  824|  11.0k|        if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
  ------------------
  |  |  320|  11.0k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  |  Branch (824:13): [True: 0, False: 11.0k]
  ------------------
  825|      0|            data_.f.flags |= kUintFlag;
  826|  11.0k|        if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
  ------------------
  |  |  320|  11.0k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  |  Branch (826:13): [True: 0, False: 11.0k]
  ------------------
  827|      0|            data_.f.flags |= kIntFlag;
  828|  11.0k|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E3IntEi:
 2823|  5.40k|    bool Int(int i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEC2Ei:
  792|  5.40k|    explicit GenericValue(int i) RAPIDJSON_NOEXCEPT : data_() {
  793|  5.40k|        data_.n.i64 = i;
  794|  5.40k|        data_.f.flags = (i >= 0) ? (kNumberIntFlag | kUintFlag | kUint64Flag) : kNumberIntFlag;
  ------------------
  |  Branch (794:25): [True: 644, False: 4.76k]
  ------------------
  795|  5.40k|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E4UintEj:
 2824|  6.66M|    bool Uint(unsigned i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEC2Ej:
  798|  6.66M|    explicit GenericValue(unsigned u) RAPIDJSON_NOEXCEPT : data_() {
  799|  6.66M|        data_.n.u64 = u; 
  800|  6.66M|        data_.f.flags = (u & 0x80000000) ? kNumberUintFlag : (kNumberUintFlag | kIntFlag | kInt64Flag);
  ------------------
  |  Branch (800:25): [True: 27, False: 6.66M]
  ------------------
  801|  6.66M|    }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEaSERS6_:
  921|     44|    GenericValue& operator=(GenericValue& rhs) RAPIDJSON_NOEXCEPT {
  922|     44|        if (RAPIDJSON_LIKELY(this != &rhs)) {
  ------------------
  |  |  492|     44|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 44, False: 0]
  |  |  ------------------
  ------------------
  923|       |            // Can't destroy "this" before assigning "rhs", otherwise "rhs"
  924|       |            // could be used after free if it's an sub-Value of "this",
  925|       |            // hence the temporary danse.
  926|     44|            GenericValue temp;
  927|     44|            temp.RawAssign(rhs);
  928|     44|            this->~GenericValue();
  929|     44|            RawAssign(temp);
  930|     44|        }
  931|     44|        return *this;
  932|     44|    }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE9RawAssignERS6_:
 2460|     88|    void RawAssign(GenericValue& rhs) RAPIDJSON_NOEXCEPT {
 2461|     88|        data_ = rhs.data_;
 2462|       |        // data_.f.flags = rhs.data_.f.flags;
 2463|     88|        rhs.data_.f.flags = kNullFlag;
 2464|     88|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E16ClearStackOnExitD2Ev:
 2808|    104|        ~ClearStackOnExit() { d_.ClearStack(); }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E10ClearStackEv:
 2869|    104|    void ClearStack() {
 2870|    104|        if (Allocator::kNeedFree)
  ------------------
  |  Branch (2870:13): [Folded, False: 104]
  ------------------
 2871|      0|            while (stack_.GetSize() > 0)    // Here assumes all elements in stack array are GenericValue (Member is actually 2 GenericValue objects)
  ------------------
  |  Branch (2871:20): [True: 0, False: 0]
  ------------------
 2872|      0|                (stack_.template Pop<ValueType>(1))->~ValueType();
 2873|    104|        else
 2874|    104|            stack_.Clear();
 2875|    104|        stack_.ShrinkToFit();
 2876|    104|    }
_ZNK9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_EcvNS_11ParseResultEEv:
 2792|    104|    operator ParseResult() const { return parseResult_; }
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE6AcceptINS_12PrettyWriterINS_19GenericStringBufferIS2_S4_EES2_S2_S4_Lj0EEEEEbRT_:
 1948|  3.47M|    bool Accept(Handler& handler) const {
 1949|  3.47M|        switch(GetType()) {
 1950|      9|        case kNullType:     return handler.Null();
  ------------------
  |  Branch (1950:9): [True: 9, False: 3.47M]
  ------------------
 1951|    300|        case kFalseType:    return handler.Bool(false);
  ------------------
  |  Branch (1951:9): [True: 300, False: 3.47M]
  ------------------
 1952|     11|        case kTrueType:     return handler.Bool(true);
  ------------------
  |  Branch (1952:9): [True: 11, False: 3.47M]
  ------------------
 1953|       |
 1954|     74|        case kObjectType:
  ------------------
  |  Branch (1954:9): [True: 74, False: 3.47M]
  ------------------
 1955|     74|            if (RAPIDJSON_UNLIKELY(!handler.StartObject()))
  ------------------
  |  |  505|     74|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 74]
  |  |  ------------------
  ------------------
 1956|      0|                return false;
 1957|   738k|            for (ConstMemberIterator m = MemberBegin(); m != MemberEnd(); ++m) {
  ------------------
  |  Branch (1957:57): [True: 738k, False: 74]
  ------------------
 1958|   738k|                RAPIDJSON_ASSERT(m->name.IsString()); // User may change the type of name by MemberIterator.
  ------------------
  |  |  437|   738k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (1958:17): [True: 738k, False: 0]
  ------------------
 1959|   738k|                if (RAPIDJSON_UNLIKELY(!handler.Key(m->name.GetString(), m->name.GetStringLength(), (m->name.data_.f.flags & kCopyFlag) != 0)))
  ------------------
  |  |  505|   738k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 738k]
  |  |  ------------------
  ------------------
 1960|      0|                    return false;
 1961|   738k|                if (RAPIDJSON_UNLIKELY(!m->value.Accept(handler)))
  ------------------
  |  |  505|   738k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 738k]
  |  |  ------------------
  ------------------
 1962|      0|                    return false;
 1963|   738k|            }
 1964|     74|            return handler.EndObject(data_.o.size);
 1965|       |
 1966|  15.4k|        case kArrayType:
  ------------------
  |  Branch (1966:9): [True: 15.4k, False: 3.45M]
  ------------------
 1967|  15.4k|            if (RAPIDJSON_UNLIKELY(!handler.StartArray()))
  ------------------
  |  |  505|  15.4k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 15.4k]
  |  |  ------------------
  ------------------
 1968|      0|                return false;
 1969|  2.74M|            for (ConstValueIterator v = Begin(); v != End(); ++v)
  ------------------
  |  Branch (1969:50): [True: 2.73M, False: 15.4k]
  ------------------
 1970|  2.73M|                if (RAPIDJSON_UNLIKELY(!v->Accept(handler)))
  ------------------
  |  |  505|  2.73M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 2.73M]
  |  |  ------------------
  ------------------
 1971|      0|                    return false;
 1972|  15.4k|            return handler.EndArray(data_.a.size);
 1973|       |    
 1974|  1.75M|        case kStringType:
  ------------------
  |  Branch (1974:9): [True: 1.75M, False: 1.71M]
  ------------------
 1975|  1.75M|            return handler.String(GetString(), GetStringLength(), (data_.f.flags & kCopyFlag) != 0);
 1976|       |    
 1977|  1.70M|        default:
  ------------------
  |  Branch (1977:9): [True: 1.70M, False: 1.76M]
  ------------------
 1978|  1.70M|            RAPIDJSON_ASSERT(GetType() == kNumberType);
  ------------------
  |  |  437|  1.70M|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (1978:13): [True: 1.70M, False: 0]
  ------------------
 1979|  1.70M|            if (IsDouble())         return handler.Double(data_.n.d);
  ------------------
  |  Branch (1979:17): [True: 7.71k, False: 1.69M]
  ------------------
 1980|  1.69M|            else if (IsInt())       return handler.Int(data_.n.i.i);
  ------------------
  |  Branch (1980:22): [True: 1.68M, False: 5.98k]
  ------------------
 1981|  5.98k|            else if (IsUint())      return handler.Uint(data_.n.u.u);
  ------------------
  |  Branch (1981:22): [True: 6, False: 5.97k]
  ------------------
 1982|  5.97k|            else if (IsInt64())     return handler.Int64(data_.n.i64);
  ------------------
  |  Branch (1982:22): [True: 5.90k, False: 74]
  ------------------
 1983|     74|            else                    return handler.Uint64(data_.n.u64);
 1984|  3.47M|        }
 1985|  3.47M|    }
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE7GetTypeEv:
 1111|  5.17M|    Type GetType()  const { return static_cast<Type>(data_.f.flags & kTypeMask); }
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE11MemberBeginEv:
 1268|     74|    ConstMemberIterator MemberBegin() const { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(GetMembersPointer()); }
  ------------------
  |  |  437|     74|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (1268:47): [True: 74, False: 0]
  ------------------
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE8IsObjectEv:
 1116|   738k|    bool IsObject() const { return data_.f.flags == kObjectFlag; }
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE17GetMembersPointerEv:
 2118|   738k|    RAPIDJSON_FORCEINLINE Member* GetMembersPointer() const { return RAPIDJSON_GETPOINTER(Member, data_.o.members); }
  ------------------
  |  |  347|   738k|#define RAPIDJSON_GETPOINTER(type, p) (reinterpret_cast<type *>(reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0x0000FFFF, 0xFFFFFFFF))))
  |  |  ------------------
  |  |  |  |  320|   738k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  |  |  ------------------
  ------------------
_ZN9rapidjson21GenericMemberIteratorILb1ENS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEC2EPKNS_13GenericMemberIS2_S5_EE:
  286|   738k|    explicit GenericMemberIterator(Pointer p) : ptr_(p) {}
_ZNK9rapidjson21GenericMemberIteratorILb1ENS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEneILb1EEEbRKNS0_IXT_ES2_S5_EE:
  263|   738k|    template <bool Const_> bool operator!=(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const { return ptr_ != that.ptr_; }
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE9MemberEndEv:
 1271|   738k|    ConstMemberIterator MemberEnd() const   { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(GetMembersPointer() + data_.o.size); }
  ------------------
  |  |  437|   738k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (1271:47): [True: 738k, False: 0]
  ------------------
_ZNK9rapidjson21GenericMemberIteratorILb1ENS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEptEv:
  277|  3.69M|    Pointer   operator->() const { return ptr_; }
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE8IsStringEv:
 1124|  5.71M|    bool IsString() const { return (data_.f.flags & kStringFlag) != 0; }
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE9GetStringEv:
 1853|  2.48M|    const Ch* GetString() const { RAPIDJSON_ASSERT(IsString()); return DataString(data_); }
  ------------------
  |  |  437|  2.48M|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (1853:35): [True: 2.48M, False: 0]
  ------------------
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE10DataStringERKNS6_4DataE:
 2107|  2.48M|    static RAPIDJSON_FORCEINLINE const Ch* DataString(const Data& data) {
 2108|  2.48M|        return (data.f.flags & kInlineStrFlag) ? data.ss.str : RAPIDJSON_GETPOINTER(Ch, data.s.str);
  ------------------
  |  |  347|  7.00k|#define RAPIDJSON_GETPOINTER(type, p) (reinterpret_cast<type *>(reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0x0000FFFF, 0xFFFFFFFF))))
  |  |  ------------------
  |  |  |  |  320|  7.00k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  |  |  ------------------
  ------------------
  |  Branch (2108:16): [True: 2.48M, False: 7.00k]
  ------------------
 2109|  2.48M|    }
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE15GetStringLengthEv:
 1858|  2.48M|    SizeType GetStringLength() const { RAPIDJSON_ASSERT(IsString()); return DataStringLength(data_); }
  ------------------
  |  |  437|  2.48M|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (1858:40): [True: 2.48M, False: 0]
  ------------------
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE16DataStringLengthERKNS6_4DataE:
 2110|  2.48M|    static RAPIDJSON_FORCEINLINE SizeType DataStringLength(const Data& data) {
 2111|  2.48M|        return (data.f.flags & kInlineStrFlag) ? data.ss.GetLength() : data.s.length;
  ------------------
  |  Branch (2111:16): [True: 2.48M, False: 7.00k]
  ------------------
 2112|  2.48M|    }
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE11ShortString9GetLengthEv:
 2057|  2.48M|        inline SizeType GetLength() const       { return  static_cast<SizeType>(MaxSize -  str[LenPos]); }
_ZN9rapidjson21GenericMemberIteratorILb1ENS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEppEv:
  245|   738k|    Iterator& operator++(){ ++ptr_; return *this; }
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE5BeginEv:
 1683|  15.4k|    ConstValueIterator Begin() const { return const_cast<GenericValue&>(*this).Begin(); }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE5BeginEv:
 1677|  15.4k|    ValueIterator Begin() { RAPIDJSON_ASSERT(IsArray()); return GetElementsPointer(); }
  ------------------
  |  |  437|  15.4k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (1677:29): [True: 15.4k, False: 0]
  ------------------
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE7IsArrayEv:
 1117|  2.76M|    bool IsArray()  const { return data_.f.flags == kArrayFlag; }
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE18GetElementsPointerEv:
 2116|  2.76M|    RAPIDJSON_FORCEINLINE GenericValue* GetElementsPointer() const { return RAPIDJSON_GETPOINTER(GenericValue, data_.a.elements); }
  ------------------
  |  |  347|  2.76M|#define RAPIDJSON_GETPOINTER(type, p) (reinterpret_cast<type *>(reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0x0000FFFF, 0xFFFFFFFF))))
  |  |  ------------------
  |  |  |  |  320|  2.76M|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  |  |  ------------------
  ------------------
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE3EndEv:
 1686|  2.74M|    ConstValueIterator End() const { return const_cast<GenericValue&>(*this).End(); }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE3EndEv:
 1680|  2.74M|    ValueIterator End() { RAPIDJSON_ASSERT(IsArray()); return GetElementsPointer() + data_.a.size; }
  ------------------
  |  |  437|  2.74M|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (1680:27): [True: 2.74M, False: 0]
  ------------------
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE8IsDoubleEv:
 1123|  1.70M|    bool IsDouble() const { return (data_.f.flags & kDoubleFlag) != 0; }
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE5IsIntEv:
 1119|  1.69M|    bool IsInt()    const { return (data_.f.flags & kIntFlag) != 0; }
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE6IsUintEv:
 1120|  5.98k|    bool IsUint()   const { return (data_.f.flags & kUintFlag) != 0; }
_ZNK9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE7IsInt64Ev:
 1121|  5.97k|    bool IsInt64()  const { return (data_.f.flags & kInt64Flag) != 0; }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_ED2Ev:
 2549|    104|    ~GenericDocument() {
 2550|       |        // Clear the ::ValueType before ownAllocator is destroyed, ~ValueType()
 2551|       |        // runs last and may access its elements or members which would be freed
 2552|       |        // with an allocator like MemoryPoolAllocator (CrtAllocator does not
 2553|       |        // free its data when destroyed, but MemoryPoolAllocator does).
 2554|    104|        if (ownAllocator_) {
  ------------------
  |  Branch (2554:13): [True: 104, False: 0]
  ------------------
 2555|    104|            ValueType::SetNull();
 2556|    104|        }
 2557|    104|        Destroy();
 2558|    104|    }
_ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE7SetNullEv:
 1169|    104|    GenericValue& SetNull() { this->~GenericValue(); new (this) GenericValue(); return *this; }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E7DestroyEv:
 2878|    104|    void Destroy() {
 2879|    104|        RAPIDJSON_DELETE(ownAllocator_);
  ------------------
  |  |  716|    104|#define RAPIDJSON_DELETE(x) delete x
  ------------------
 2880|    104|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E5ParseILj16EEERS6_PKc:
 2720|     26|    GenericDocument& Parse(const Ch* str) {
 2721|     26|        return Parse<parseFlags, Encoding>(str);
 2722|     26|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E5ParseILj16ES2_EERS6_PKNT0_2ChE:
 2709|     26|    GenericDocument& Parse(const typename SourceEncoding::Ch* str) {
 2710|     26|        RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag));
  ------------------
  |  |  437|     26|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (2710:9): [True: 26, Folded]
  ------------------
 2711|     26|        GenericStringStream<SourceEncoding> s(str);
 2712|     26|        return ParseStream<parseFlags, SourceEncoding>(s);
 2713|     26|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E11ParseStreamILj16ES2_NS_19GenericStringStreamIS2_EEEERS6_RT1_:
 2643|     26|    GenericDocument& ParseStream(InputStream& is) {
 2644|     26|        GenericReader<SourceEncoding, Encoding, StackAllocator> reader(
 2645|     26|            stack_.HasAllocator() ? &stack_.GetAllocator() : 0);
  ------------------
  |  Branch (2645:13): [True: 0, False: 26]
  ------------------
 2646|     26|        ClearStackOnExit scope(*this);
 2647|     26|        parseResult_ = reader.template Parse<parseFlags>(is, *this);
 2648|     26|        if (parseResult_) {
  ------------------
  |  Branch (2648:13): [True: 12, False: 14]
  ------------------
 2649|     12|            RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object
  ------------------
  |  |  437|     12|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (2649:13): [True: 12, False: 0]
  ------------------
 2650|     12|            ValueType::operator=(*stack_.template Pop<ValueType>(1));// Move value from stack to document
 2651|     12|        }
 2652|     26|        return *this;
 2653|     26|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E5ParseILj64EEERS6_PKc:
 2720|     26|    GenericDocument& Parse(const Ch* str) {
 2721|     26|        return Parse<parseFlags, Encoding>(str);
 2722|     26|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E5ParseILj64ES2_EERS6_PKNT0_2ChE:
 2709|     26|    GenericDocument& Parse(const typename SourceEncoding::Ch* str) {
 2710|     26|        RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag));
  ------------------
  |  |  437|     26|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (2710:9): [True: 26, Folded]
  ------------------
 2711|     26|        GenericStringStream<SourceEncoding> s(str);
 2712|     26|        return ParseStream<parseFlags, SourceEncoding>(s);
 2713|     26|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E11ParseStreamILj64ES2_NS_19GenericStringStreamIS2_EEEERS6_RT1_:
 2643|     26|    GenericDocument& ParseStream(InputStream& is) {
 2644|     26|        GenericReader<SourceEncoding, Encoding, StackAllocator> reader(
 2645|     26|            stack_.HasAllocator() ? &stack_.GetAllocator() : 0);
  ------------------
  |  Branch (2645:13): [True: 0, False: 26]
  ------------------
 2646|     26|        ClearStackOnExit scope(*this);
 2647|     26|        parseResult_ = reader.template Parse<parseFlags>(is, *this);
 2648|     26|        if (parseResult_) {
  ------------------
  |  Branch (2648:13): [True: 14, False: 12]
  ------------------
 2649|     14|            RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object
  ------------------
  |  |  437|     14|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (2649:13): [True: 14, False: 0]
  ------------------
 2650|     14|            ValueType::operator=(*stack_.template Pop<ValueType>(1));// Move value from stack to document
 2651|     14|        }
 2652|     26|        return *this;
 2653|     26|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E9RawNumberEPKcjb:
 2829|  3.23M|    bool RawNumber(const Ch* str, SizeType length, bool copy) { 
 2830|  3.23M|        if (copy) 
  ------------------
  |  Branch (2830:13): [True: 3.23M, False: 0]
  ------------------
 2831|  3.23M|            new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
 2832|      0|        else
 2833|      0|            new (stack_.template Push<ValueType>()) ValueType(str, length);
 2834|  3.23M|        return true;
 2835|  3.23M|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E5ParseILj32EEERS6_PKc:
 2720|     26|    GenericDocument& Parse(const Ch* str) {
 2721|     26|        return Parse<parseFlags, Encoding>(str);
 2722|     26|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E5ParseILj32ES2_EERS6_PKNT0_2ChE:
 2709|     26|    GenericDocument& Parse(const typename SourceEncoding::Ch* str) {
 2710|     26|        RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag));
  ------------------
  |  |  437|     26|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (2710:9): [True: 26, Folded]
  ------------------
 2711|     26|        GenericStringStream<SourceEncoding> s(str);
 2712|     26|        return ParseStream<parseFlags, SourceEncoding>(s);
 2713|     26|    }
_ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E11ParseStreamILj32ES2_NS_19GenericStringStreamIS2_EEEERS6_RT1_:
 2643|     26|    GenericDocument& ParseStream(InputStream& is) {
 2644|     26|        GenericReader<SourceEncoding, Encoding, StackAllocator> reader(
 2645|     26|            stack_.HasAllocator() ? &stack_.GetAllocator() : 0);
  ------------------
  |  Branch (2645:13): [True: 0, False: 26]
  ------------------
 2646|     26|        ClearStackOnExit scope(*this);
 2647|     26|        parseResult_ = reader.template Parse<parseFlags>(is, *this);
 2648|     26|        if (parseResult_) {
  ------------------
  |  Branch (2648:13): [True: 9, False: 17]
  ------------------
 2649|      9|            RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object
  ------------------
  |  |  437|      9|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (2649:13): [True: 9, False: 0]
  ------------------
 2650|      9|            ValueType::operator=(*stack_.template Pop<ValueType>(1));// Move value from stack to document
 2651|      9|        }
 2652|     26|        return *this;
 2653|     26|    }

_ZN9rapidjson4UTF8IcE6EncodeINS_13GenericReaderIS1_S1_NS_12CrtAllocatorEE11StackStreamIcEEEEvRT_j:
  102|  4.66k|    static void Encode(OutputStream& os, unsigned codepoint) {
  103|  4.66k|        if (codepoint <= 0x7F) 
  ------------------
  |  Branch (103:13): [True: 4, False: 4.66k]
  ------------------
  104|      4|            os.Put(static_cast<Ch>(codepoint & 0xFF));
  105|  4.66k|        else if (codepoint <= 0x7FF) {
  ------------------
  |  Branch (105:18): [True: 0, False: 4.66k]
  ------------------
  106|      0|            os.Put(static_cast<Ch>(0xC0 | ((codepoint >> 6) & 0xFF)));
  107|      0|            os.Put(static_cast<Ch>(0x80 | ((codepoint & 0x3F))));
  108|      0|        }
  109|  4.66k|        else if (codepoint <= 0xFFFF) {
  ------------------
  |  Branch (109:18): [True: 413, False: 4.24k]
  ------------------
  110|    413|            os.Put(static_cast<Ch>(0xE0 | ((codepoint >> 12) & 0xFF)));
  111|    413|            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
  112|    413|            os.Put(static_cast<Ch>(0x80 | (codepoint & 0x3F)));
  113|    413|        }
  114|  4.24k|        else {
  115|  4.24k|            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
  ------------------
  |  |  437|  4.24k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (115:13): [True: 4.24k, False: 0]
  ------------------
  116|  4.24k|            os.Put(static_cast<Ch>(0xF0 | ((codepoint >> 18) & 0xFF)));
  117|  4.24k|            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 12) & 0x3F)));
  118|  4.24k|            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
  119|  4.24k|            os.Put(static_cast<Ch>(0x80 | (codepoint & 0x3F)));
  120|  4.24k|        }
  121|  4.66k|    }
_ZN9rapidjson10TranscoderINS_4UTF8IcEES2_E9TranscodeINS_19GenericStringStreamIS2_EENS_13GenericReaderIS2_S2_NS_12CrtAllocatorEE11StackStreamIcEEEEbRT_RT0_:
  693|  13.9M|    static RAPIDJSON_FORCEINLINE bool Transcode(InputStream& is, OutputStream& os) {
  694|  13.9M|        os.Put(is.Take());  // Just copy one code unit. This semantic is different from primary template class.
  695|  13.9M|        return true;
  696|  13.9M|    }
_ZN9rapidjson10TranscoderINS_4UTF8IcEES2_E15TranscodeUnsafeINS_19GenericStringStreamIS2_EENS_19GenericStringBufferIS2_NS_12CrtAllocatorEEEEEbRT_RT0_:
  699|  11.4M|    static RAPIDJSON_FORCEINLINE bool TranscodeUnsafe(InputStream& is, OutputStream& os) {
  700|  11.4M|        PutUnsafe(os, is.Take());  // Just copy one code unit. This semantic is different from primary template class.
  701|  11.4M|        return true;
  702|  11.4M|    }

_ZN9rapidjson11ParseResultC2Ev:
  111|    208|    ParseResult() : code_(kParseErrorNone), offset_(0) {}
_ZN9rapidjson11ParseResult5ClearEv:
  134|    104|    void Clear() { Set(kParseErrorNone); }
_ZN9rapidjson11ParseResult3SetENS_14ParseErrorCodeEm:
  136|    164|    void Set(ParseErrorCode code, size_t offset = 0) { code_ = code; offset_ = offset; }
_ZNK9rapidjson11ParseResult7IsErrorEv:
  123|  33.1M|    bool IsError() const { return code_ != kParseErrorNone; }
_ZNK9rapidjson11ParseResultcvMS0_KFbvEEv:
  121|    208|    operator BooleanType() const { return !IsError() ? &ParseResult::IsError : NULL; }
  ------------------
  |  Branch (121:43): [True: 88, False: 120]
  ------------------

_ZN9rapidjson8internal10BigIntegerC2IcEEPKT_m:
   45|      8|    BigInteger(const Ch* decimals, size_t length) : count_(1) {
   46|      8|        RAPIDJSON_ASSERT(length > 0);
  ------------------
  |  |  437|      8|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (46:9): [True: 8, False: 0]
  ------------------
   47|      8|        digits_[0] = 0;
   48|      8|        size_t i = 0;
   49|      8|        const size_t kMaxDigitPerIteration = 19;  // 2^64 = 18446744073709551616 > 10^19
   50|     10|        while (length >= kMaxDigitPerIteration) {
  ------------------
  |  Branch (50:16): [True: 2, False: 8]
  ------------------
   51|      2|            AppendDecimal64(decimals + i, decimals + i + kMaxDigitPerIteration);
   52|      2|            length -= kMaxDigitPerIteration;
   53|      2|            i += kMaxDigitPerIteration;
   54|      2|        }
   55|       |
   56|      8|        if (length > 0)
  ------------------
  |  Branch (56:13): [True: 8, False: 0]
  ------------------
   57|      8|            AppendDecimal64(decimals + i, decimals + i + length);
   58|      8|    }
_ZN9rapidjson8internal10BigInteger15AppendDecimal64IcEEvPKT_S5_:
  230|     10|    void AppendDecimal64(const Ch* begin, const Ch* end) {
  231|     10|        uint64_t u = ParseUint64(begin, end);
  232|     10|        if (IsZero())
  ------------------
  |  Branch (232:13): [True: 8, False: 2]
  ------------------
  233|      8|            *this = u;
  234|      2|        else {
  235|      2|            unsigned exp = static_cast<unsigned>(end - begin);
  236|      2|            (MultiplyPow5(exp) <<= exp) += u;   // *this = *this * 10^exp + u
  237|      2|        }
  238|     10|    }
_ZN9rapidjson8internal10BigInteger11ParseUint64IcEEmPKT_S5_:
  246|     10|    static uint64_t ParseUint64(const Ch* begin, const Ch* end) {
  247|     10|        uint64_t r = 0;
  248|    168|        for (const Ch* p = begin; p != end; ++p) {
  ------------------
  |  Branch (248:35): [True: 158, False: 10]
  ------------------
  249|    158|            RAPIDJSON_ASSERT(*p >= Ch('0') && *p <= Ch('9'));
  ------------------
  |  |  437|    158|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (249:13): [True: 158, False: 0]
  |  Branch (249:13): [True: 158, False: 0]
  |  Branch (249:13): [True: 158, False: 0]
  ------------------
  250|    158|            r = r * 10u + static_cast<unsigned>(*p - Ch('0'));
  251|    158|        }
  252|     10|        return r;
  253|     10|    }
_ZNK9rapidjson8internal10BigInteger6IsZeroEv:
  226|     36|    bool IsZero() const { return count_ == 1 && digits_[0] == 0; }
  ------------------
  |  Branch (226:34): [True: 31, False: 5]
  |  Branch (226:49): [True: 8, False: 23]
  ------------------
_ZN9rapidjson8internal10BigIntegeraSEm:
   69|     16|    BigInteger& operator=(uint64_t u) {
   70|     16|        digits_[0] = u;            
   71|     16|        count_ = 1;
   72|     16|        return *this;
   73|     16|    }
_ZN9rapidjson8internal10BigInteger12MultiplyPow5Ej:
  167|     26|    BigInteger& MultiplyPow5(unsigned exp) {
  168|     26|        static const uint32_t kPow5[12] = {
  169|     26|            5,
  170|     26|            5 * 5,
  171|     26|            5 * 5 * 5,
  172|     26|            5 * 5 * 5 * 5,
  173|     26|            5 * 5 * 5 * 5 * 5,
  174|     26|            5 * 5 * 5 * 5 * 5 * 5,
  175|     26|            5 * 5 * 5 * 5 * 5 * 5 * 5,
  176|     26|            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
  177|     26|            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
  178|     26|            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
  179|     26|            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
  180|     26|            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5
  181|     26|        };
  182|     26|        if (exp == 0) return *this;
  ------------------
  |  Branch (182:13): [True: 8, False: 18]
  ------------------
  183|     18|        for (; exp >= 27; exp -= 27) *this *= RAPIDJSON_UINT64_C2(0X6765C793, 0XFA10079D); // 5^27
  ------------------
  |  |  320|     18|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  |  Branch (183:16): [True: 0, False: 18]
  ------------------
  184|     21|        for (; exp >= 13; exp -= 13) *this *= static_cast<uint32_t>(1220703125u); // 5^13
  ------------------
  |  Branch (184:16): [True: 3, False: 18]
  ------------------
  185|     18|        if (exp > 0)                 *this *= kPow5[exp - 1];
  ------------------
  |  Branch (185:13): [True: 18, False: 0]
  ------------------
  186|     18|        return *this;
  187|     26|    }
_ZNK9rapidjson8internal10BigIntegereqEm:
  163|     21|    bool operator==(const Type rhs) const {
  164|     21|        return count_ == 1 && digits_[0] == rhs;
  ------------------
  |  Branch (164:16): [True: 18, False: 3]
  |  Branch (164:31): [True: 8, False: 10]
  ------------------
  165|     21|    }
_ZN9rapidjson8internal10BigInteger8PushBackEm:
  240|      2|    void PushBack(Type digit) {
  241|      2|        RAPIDJSON_ASSERT(count_ < kCapacity);
  ------------------
  |  |  437|      2|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (241:9): [True: 2, False: 0]
  ------------------
  242|      2|        digits_[count_++] = digit;
  243|      2|    }
_ZN9rapidjson8internal10BigIntegermLEj:
  110|     21|    BigInteger& operator*=(uint32_t u) {
  111|     21|        if (u == 0) return *this = 0;
  ------------------
  |  Branch (111:13): [True: 0, False: 21]
  ------------------
  112|     21|        if (u == 1) return *this;
  ------------------
  |  Branch (112:13): [True: 0, False: 21]
  ------------------
  113|     21|        if (*this == 1) return *this = u;
  ------------------
  |  Branch (113:13): [True: 8, False: 13]
  ------------------
  114|       |
  115|     13|        uint64_t k = 0;
  116|     29|        for (size_t i = 0; i < count_; i++) {
  ------------------
  |  Branch (116:28): [True: 16, False: 13]
  ------------------
  117|     16|            const uint64_t c = digits_[i] >> 32;
  118|     16|            const uint64_t d = digits_[i] & 0xFFFFFFFF;
  119|     16|            const uint64_t uc = u * c;
  120|     16|            const uint64_t ud = u * d;
  121|     16|            const uint64_t p0 = ud + k;
  122|     16|            const uint64_t p1 = uc + (p0 >> 32);
  123|     16|            digits_[i] = (p0 & 0xFFFFFFFF) | (p1 << 32);
  124|     16|            k = p1 >> 32;
  125|     16|        }
  126|       |        
  127|     13|        if (k > 0)
  ------------------
  |  Branch (127:13): [True: 2, False: 11]
  ------------------
  128|      2|            PushBack(k);
  129|       |
  130|     13|        return *this;
  131|     21|    }
_ZN9rapidjson8internal10BigIntegerlSEm:
  133|     26|    BigInteger& operator<<=(size_t shift) {
  134|     26|        if (IsZero() || shift == 0) return *this;
  ------------------
  |  Branch (134:13): [True: 0, False: 26]
  |  Branch (134:25): [True: 15, False: 11]
  ------------------
  135|       |
  136|     11|        size_t offset = shift / kTypeBit;
  137|     11|        size_t interShift = shift % kTypeBit;
  138|     11|        RAPIDJSON_ASSERT(count_ + offset <= kCapacity);
  ------------------
  |  |  437|     11|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (138:9): [True: 11, False: 0]
  ------------------
  139|       |
  140|     11|        if (interShift == 0) {
  ------------------
  |  Branch (140:13): [True: 0, False: 11]
  ------------------
  141|      0|            std::memmove(digits_ + offset, digits_, count_ * sizeof(Type));
  142|      0|            count_ += offset;
  143|      0|        }
  144|     11|        else {
  145|     11|            digits_[count_] = 0;
  146|     25|            for (size_t i = count_; i > 0; i--)
  ------------------
  |  Branch (146:37): [True: 14, False: 11]
  ------------------
  147|     14|                digits_[i + offset] = (digits_[i] << interShift) | (digits_[i - 1] >> (kTypeBit - interShift));
  148|     11|            digits_[offset] = digits_[0] << interShift;
  149|     11|            count_ += offset;
  150|     11|            if (digits_[count_])
  ------------------
  |  Branch (150:17): [True: 2, False: 9]
  ------------------
  151|      2|                count_++;
  152|     11|        }
  153|       |
  154|     11|        std::memset(digits_, 0, offset * sizeof(Type));
  155|       |
  156|     11|        return *this;
  157|     11|    }
_ZN9rapidjson8internal10BigIntegerpLEm:
   75|      2|    BigInteger& operator+=(uint64_t u) {
   76|      2|        Type backup = digits_[0];
   77|      2|        digits_[0] += u;
   78|      2|        for (size_t i = 0; i < count_ - 1; i++) {
  ------------------
  |  Branch (78:28): [True: 2, False: 0]
  ------------------
   79|      2|            if (digits_[i] >= backup)
  ------------------
  |  Branch (79:17): [True: 2, False: 0]
  ------------------
   80|      2|                return *this; // no carry
   81|      0|            backup = digits_[i + 1];
   82|      0|            digits_[i + 1] += 1;
   83|      0|        }
   84|       |
   85|       |        // Last carry
   86|      0|        if (digits_[count_ - 1] < backup)
  ------------------
  |  Branch (86:13): [True: 0, False: 0]
  ------------------
   87|      0|            PushBack(1);
   88|       |
   89|      0|        return *this;
   90|      2|    }
_ZN9rapidjson8internal10BigIntegerC2ERKS1_:
   36|      8|    BigInteger(const BigInteger& rhs) : count_(rhs.count_) {
   37|      8|        std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type));
   38|      8|    }
_ZN9rapidjson8internal10BigIntegerC2Em:
   40|     24|    explicit BigInteger(uint64_t u) : count_(1) {
   41|     24|        digits_[0] = u;
   42|     24|    }
_ZNK9rapidjson8internal10BigInteger10DifferenceERKS1_PS1_:
  191|      8|    bool Difference(const BigInteger& rhs, BigInteger* out) const {
  192|      8|        int cmp = Compare(rhs);
  193|      8|        RAPIDJSON_ASSERT(cmp != 0);
  ------------------
  |  |  437|      8|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (193:9): [True: 8, False: 0]
  ------------------
  194|      8|        const BigInteger *a, *b;  // Makes a > b
  195|      8|        bool ret;
  196|      8|        if (cmp < 0) { a = &rhs; b = this; ret = true; }
  ------------------
  |  Branch (196:13): [True: 0, False: 8]
  ------------------
  197|      8|        else         { a = this; b = &rhs; ret = false; }
  198|       |
  199|      8|        Type borrow = 0;
  200|     18|        for (size_t i = 0; i < a->count_; i++) {
  ------------------
  |  Branch (200:28): [True: 10, False: 8]
  ------------------
  201|     10|            Type d = a->digits_[i] - borrow;
  202|     10|            if (i < b->count_)
  ------------------
  |  Branch (202:17): [True: 9, False: 1]
  ------------------
  203|      9|                d -= b->digits_[i];
  204|     10|            borrow = (d > a->digits_[i]) ? 1 : 0;
  ------------------
  |  Branch (204:22): [True: 1, False: 9]
  ------------------
  205|     10|            out->digits_[i] = d;
  206|     10|            if (d != 0)
  ------------------
  |  Branch (206:17): [True: 9, False: 1]
  ------------------
  207|      9|                out->count_ = i + 1;
  208|     10|        }
  209|       |
  210|      8|        return ret;
  211|      8|    }
_ZNK9rapidjson8internal10BigInteger7CompareERKS1_:
  213|     16|    int Compare(const BigInteger& rhs) const {
  214|     16|        if (count_ != rhs.count_)
  ------------------
  |  Branch (214:13): [True: 1, False: 15]
  ------------------
  215|      1|            return count_ < rhs.count_ ? -1 : 1;
  ------------------
  |  Branch (215:20): [True: 0, False: 1]
  ------------------
  216|       |
  217|     22|        for (size_t i = count_; i-- > 0;)
  ------------------
  |  Branch (217:33): [True: 15, False: 7]
  ------------------
  218|     15|            if (digits_[i] != rhs.digits_[i])
  ------------------
  |  Branch (218:17): [True: 8, False: 7]
  ------------------
  219|      8|                return digits_[i] < rhs.digits_[i] ? -1 : 1;
  ------------------
  |  Branch (219:24): [True: 1, False: 7]
  ------------------
  220|       |
  221|      7|        return 0;
  222|     15|    }

_ZN9rapidjson8internal5clzllEm:
   32|  15.3k|inline uint32_t clzll(uint64_t x) {
   33|       |    // Passing 0 to __builtin_clzll is UB in GCC and results in an
   34|       |    // infinite loop in the software implementation.
   35|  15.3k|    RAPIDJSON_ASSERT(x != 0);
  ------------------
  |  |  437|  15.3k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (35:5): [True: 15.3k, False: 0]
  ------------------
   36|       |
   37|       |#if defined(_MSC_VER) && !defined(UNDER_CE)
   38|       |    unsigned long r = 0;
   39|       |#if defined(_WIN64)
   40|       |    _BitScanReverse64(&r, x);
   41|       |#else
   42|       |    // Scan the high 32 bits.
   43|       |    if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
   44|       |        return 63 - (r + 32);
   45|       |
   46|       |    // Scan the low 32 bits.
   47|       |    _BitScanReverse(&r, static_cast<uint32_t>(x & 0xFFFFFFFF));
   48|       |#endif // _WIN64
   49|       |
   50|       |    return 63 - r;
   51|       |#elif (defined(__GNUC__) && __GNUC__ >= 4) || RAPIDJSON_HAS_BUILTIN(__builtin_clzll)
   52|       |    // __builtin_clzll wrapper
   53|  15.3k|    return static_cast<uint32_t>(__builtin_clzll(x));
   54|       |#else
   55|       |    // naive version
   56|       |    uint32_t r = 0;
   57|       |    while (!(x & (static_cast<uint64_t>(1) << 63))) {
   58|       |        x <<= 1;
   59|       |        ++r;
   60|       |    }
   61|       |
   62|       |    return r;
   63|       |#endif // _MSC_VER
   64|  15.3k|}

_ZN9rapidjson8internal5DiyFpC2Ed:
   53|  7.70k|    explicit DiyFp(double d) {
   54|  7.70k|        union {
   55|  7.70k|            double d;
   56|  7.70k|            uint64_t u64;
   57|  7.70k|        } u = { d };
   58|       |
   59|  7.70k|        int biased_e = static_cast<int>((u.u64 & kDpExponentMask) >> kDpSignificandSize);
   60|  7.70k|        uint64_t significand = (u.u64 & kDpSignificandMask);
   61|  7.70k|        if (biased_e != 0) {
  ------------------
  |  Branch (61:13): [True: 6.57k, False: 1.13k]
  ------------------
   62|  6.57k|            f = significand + kDpHiddenBit;
   63|  6.57k|            e = biased_e - kDpExponentBias;
   64|  6.57k|        }
   65|  1.13k|        else {
   66|  1.13k|            f = significand;
   67|  1.13k|            e = kDpMinExponent + 1;
   68|  1.13k|        }
   69|  7.70k|    }
_ZN9rapidjson8internal5DiyFpC2Ev:
   49|  15.4k|    DiyFp() : f(), e() {}
_ZNK9rapidjson8internal5DiyFp20NormalizedBoundariesEPS1_S2_:
  122|  7.70k|    void NormalizedBoundaries(DiyFp* minus, DiyFp* plus) const {
  123|  7.70k|        DiyFp pl = DiyFp((f << 1) + 1, e - 1).NormalizeBoundary();
  124|  7.70k|        DiyFp mi = (f == kDpHiddenBit) ? DiyFp((f << 2) - 1, e - 2) : DiyFp((f << 1) - 1, e - 1);
  ------------------
  |  Branch (124:20): [True: 24, False: 7.67k]
  ------------------
  125|  7.70k|        mi.f <<= mi.e - pl.e;
  126|  7.70k|        mi.e = pl.e;
  127|  7.70k|        *plus = pl;
  128|  7.70k|        *minus = mi;
  129|  7.70k|    }
_ZN9rapidjson8internal5DiyFpC2Emi:
   51|  95.6k|    DiyFp(uint64_t fp, int exp) : f(fp), e(exp) {}
_ZNK9rapidjson8internal5DiyFp17NormalizeBoundaryEv:
  111|  7.70k|    DiyFp NormalizeBoundary() const {
  112|  7.70k|        DiyFp res = *this;
  113|  63.5k|        while (!(res.f & (kDpHiddenBit << 1))) {
  ------------------
  |  Branch (113:16): [True: 55.8k, False: 7.70k]
  ------------------
  114|  55.8k|            res.f <<= 1;
  115|  55.8k|            res.e--;
  116|  55.8k|        }
  117|  7.70k|        res.f <<= (kDiySignificandSize - kDpSignificandSize - 2);
  118|  7.70k|        res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2);
  119|  7.70k|        return res;
  120|  7.70k|    }
_ZN9rapidjson8internal14GetCachedPowerEiPi:
  228|  7.70k|inline DiyFp GetCachedPower(int e, int* K) {
  229|       |
  230|       |    //int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
  231|  7.70k|    double dk = (-61 - e) * 0.30102999566398114 + 347;  // dk must be positive, so can do ceiling in positive
  232|  7.70k|    int k = static_cast<int>(dk);
  233|  7.70k|    if (dk - k > 0.0)
  ------------------
  |  Branch (233:9): [True: 7.22k, False: 476]
  ------------------
  234|  7.22k|        k++;
  235|       |
  236|  7.70k|    unsigned index = static_cast<unsigned>((k >> 3) + 1);
  237|  7.70k|    *K = -(-348 + static_cast<int>(index << 3));    // decimal exponent no need lookup table
  238|       |
  239|  7.70k|    return GetCachedPowerByIndex(index);
  240|  7.70k|}
_ZN9rapidjson8internal21GetCachedPowerByIndexEm:
  165|  11.5k|inline DiyFp GetCachedPowerByIndex(size_t index) {
  166|       |    // 10^-348, 10^-340, ..., 10^340
  167|  11.5k|    static const uint64_t kCachedPowers_F[] = {
  168|  11.5k|        RAPIDJSON_UINT64_C2(0xfa8fd5a0, 0x081c0288), RAPIDJSON_UINT64_C2(0xbaaee17f, 0xa23ebf76),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xfa8fd5a0, 0x081c0288), RAPIDJSON_UINT64_C2(0xbaaee17f, 0xa23ebf76),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  169|  11.5k|        RAPIDJSON_UINT64_C2(0x8b16fb20, 0x3055ac76), RAPIDJSON_UINT64_C2(0xcf42894a, 0x5dce35ea),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0x8b16fb20, 0x3055ac76), RAPIDJSON_UINT64_C2(0xcf42894a, 0x5dce35ea),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  170|  11.5k|        RAPIDJSON_UINT64_C2(0x9a6bb0aa, 0x55653b2d), RAPIDJSON_UINT64_C2(0xe61acf03, 0x3d1a45df),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0x9a6bb0aa, 0x55653b2d), RAPIDJSON_UINT64_C2(0xe61acf03, 0x3d1a45df),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  171|  11.5k|        RAPIDJSON_UINT64_C2(0xab70fe17, 0xc79ac6ca), RAPIDJSON_UINT64_C2(0xff77b1fc, 0xbebcdc4f),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xab70fe17, 0xc79ac6ca), RAPIDJSON_UINT64_C2(0xff77b1fc, 0xbebcdc4f),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  172|  11.5k|        RAPIDJSON_UINT64_C2(0xbe5691ef, 0x416bd60c), RAPIDJSON_UINT64_C2(0x8dd01fad, 0x907ffc3c),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xbe5691ef, 0x416bd60c), RAPIDJSON_UINT64_C2(0x8dd01fad, 0x907ffc3c),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  173|  11.5k|        RAPIDJSON_UINT64_C2(0xd3515c28, 0x31559a83), RAPIDJSON_UINT64_C2(0x9d71ac8f, 0xada6c9b5),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xd3515c28, 0x31559a83), RAPIDJSON_UINT64_C2(0x9d71ac8f, 0xada6c9b5),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  174|  11.5k|        RAPIDJSON_UINT64_C2(0xea9c2277, 0x23ee8bcb), RAPIDJSON_UINT64_C2(0xaecc4991, 0x4078536d),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xea9c2277, 0x23ee8bcb), RAPIDJSON_UINT64_C2(0xaecc4991, 0x4078536d),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  175|  11.5k|        RAPIDJSON_UINT64_C2(0x823c1279, 0x5db6ce57), RAPIDJSON_UINT64_C2(0xc2109436, 0x4dfb5637),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0x823c1279, 0x5db6ce57), RAPIDJSON_UINT64_C2(0xc2109436, 0x4dfb5637),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  176|  11.5k|        RAPIDJSON_UINT64_C2(0x9096ea6f, 0x3848984f), RAPIDJSON_UINT64_C2(0xd77485cb, 0x25823ac7),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0x9096ea6f, 0x3848984f), RAPIDJSON_UINT64_C2(0xd77485cb, 0x25823ac7),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  177|  11.5k|        RAPIDJSON_UINT64_C2(0xa086cfcd, 0x97bf97f4), RAPIDJSON_UINT64_C2(0xef340a98, 0x172aace5),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xa086cfcd, 0x97bf97f4), RAPIDJSON_UINT64_C2(0xef340a98, 0x172aace5),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  178|  11.5k|        RAPIDJSON_UINT64_C2(0xb23867fb, 0x2a35b28e), RAPIDJSON_UINT64_C2(0x84c8d4df, 0xd2c63f3b),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xb23867fb, 0x2a35b28e), RAPIDJSON_UINT64_C2(0x84c8d4df, 0xd2c63f3b),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  179|  11.5k|        RAPIDJSON_UINT64_C2(0xc5dd4427, 0x1ad3cdba), RAPIDJSON_UINT64_C2(0x936b9fce, 0xbb25c996),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xc5dd4427, 0x1ad3cdba), RAPIDJSON_UINT64_C2(0x936b9fce, 0xbb25c996),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  180|  11.5k|        RAPIDJSON_UINT64_C2(0xdbac6c24, 0x7d62a584), RAPIDJSON_UINT64_C2(0xa3ab6658, 0x0d5fdaf6),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xdbac6c24, 0x7d62a584), RAPIDJSON_UINT64_C2(0xa3ab6658, 0x0d5fdaf6),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  181|  11.5k|        RAPIDJSON_UINT64_C2(0xf3e2f893, 0xdec3f126), RAPIDJSON_UINT64_C2(0xb5b5ada8, 0xaaff80b8),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xf3e2f893, 0xdec3f126), RAPIDJSON_UINT64_C2(0xb5b5ada8, 0xaaff80b8),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  182|  11.5k|        RAPIDJSON_UINT64_C2(0x87625f05, 0x6c7c4a8b), RAPIDJSON_UINT64_C2(0xc9bcff60, 0x34c13053),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0x87625f05, 0x6c7c4a8b), RAPIDJSON_UINT64_C2(0xc9bcff60, 0x34c13053),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  183|  11.5k|        RAPIDJSON_UINT64_C2(0x964e858c, 0x91ba2655), RAPIDJSON_UINT64_C2(0xdff97724, 0x70297ebd),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0x964e858c, 0x91ba2655), RAPIDJSON_UINT64_C2(0xdff97724, 0x70297ebd),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  184|  11.5k|        RAPIDJSON_UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), RAPIDJSON_UINT64_C2(0xf8a95fcf, 0x88747d94),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), RAPIDJSON_UINT64_C2(0xf8a95fcf, 0x88747d94),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  185|  11.5k|        RAPIDJSON_UINT64_C2(0xb9447093, 0x8fa89bcf), RAPIDJSON_UINT64_C2(0x8a08f0f8, 0xbf0f156b),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xb9447093, 0x8fa89bcf), RAPIDJSON_UINT64_C2(0x8a08f0f8, 0xbf0f156b),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  186|  11.5k|        RAPIDJSON_UINT64_C2(0xcdb02555, 0x653131b6), RAPIDJSON_UINT64_C2(0x993fe2c6, 0xd07b7fac),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xcdb02555, 0x653131b6), RAPIDJSON_UINT64_C2(0x993fe2c6, 0xd07b7fac),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  187|  11.5k|        RAPIDJSON_UINT64_C2(0xe45c10c4, 0x2a2b3b06), RAPIDJSON_UINT64_C2(0xaa242499, 0x697392d3),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xe45c10c4, 0x2a2b3b06), RAPIDJSON_UINT64_C2(0xaa242499, 0x697392d3),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  188|  11.5k|        RAPIDJSON_UINT64_C2(0xfd87b5f2, 0x8300ca0e), RAPIDJSON_UINT64_C2(0xbce50864, 0x92111aeb),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xfd87b5f2, 0x8300ca0e), RAPIDJSON_UINT64_C2(0xbce50864, 0x92111aeb),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  189|  11.5k|        RAPIDJSON_UINT64_C2(0x8cbccc09, 0x6f5088cc), RAPIDJSON_UINT64_C2(0xd1b71758, 0xe219652c),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0x8cbccc09, 0x6f5088cc), RAPIDJSON_UINT64_C2(0xd1b71758, 0xe219652c),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  190|  11.5k|        RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), RAPIDJSON_UINT64_C2(0xe8d4a510, 0x00000000),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), RAPIDJSON_UINT64_C2(0xe8d4a510, 0x00000000),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  191|  11.5k|        RAPIDJSON_UINT64_C2(0xad78ebc5, 0xac620000), RAPIDJSON_UINT64_C2(0x813f3978, 0xf8940984),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xad78ebc5, 0xac620000), RAPIDJSON_UINT64_C2(0x813f3978, 0xf8940984),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  192|  11.5k|        RAPIDJSON_UINT64_C2(0xc097ce7b, 0xc90715b3), RAPIDJSON_UINT64_C2(0x8f7e32ce, 0x7bea5c70),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xc097ce7b, 0xc90715b3), RAPIDJSON_UINT64_C2(0x8f7e32ce, 0x7bea5c70),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  193|  11.5k|        RAPIDJSON_UINT64_C2(0xd5d238a4, 0xabe98068), RAPIDJSON_UINT64_C2(0x9f4f2726, 0x179a2245),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xd5d238a4, 0xabe98068), RAPIDJSON_UINT64_C2(0x9f4f2726, 0x179a2245),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  194|  11.5k|        RAPIDJSON_UINT64_C2(0xed63a231, 0xd4c4fb27), RAPIDJSON_UINT64_C2(0xb0de6538, 0x8cc8ada8),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xed63a231, 0xd4c4fb27), RAPIDJSON_UINT64_C2(0xb0de6538, 0x8cc8ada8),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  195|  11.5k|        RAPIDJSON_UINT64_C2(0x83c7088e, 0x1aab65db), RAPIDJSON_UINT64_C2(0xc45d1df9, 0x42711d9a),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0x83c7088e, 0x1aab65db), RAPIDJSON_UINT64_C2(0xc45d1df9, 0x42711d9a),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  196|  11.5k|        RAPIDJSON_UINT64_C2(0x924d692c, 0xa61be758), RAPIDJSON_UINT64_C2(0xda01ee64, 0x1a708dea),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0x924d692c, 0xa61be758), RAPIDJSON_UINT64_C2(0xda01ee64, 0x1a708dea),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  197|  11.5k|        RAPIDJSON_UINT64_C2(0xa26da399, 0x9aef774a), RAPIDJSON_UINT64_C2(0xf209787b, 0xb47d6b85),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xa26da399, 0x9aef774a), RAPIDJSON_UINT64_C2(0xf209787b, 0xb47d6b85),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  198|  11.5k|        RAPIDJSON_UINT64_C2(0xb454e4a1, 0x79dd1877), RAPIDJSON_UINT64_C2(0x865b8692, 0x5b9bc5c2),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xb454e4a1, 0x79dd1877), RAPIDJSON_UINT64_C2(0x865b8692, 0x5b9bc5c2),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  199|  11.5k|        RAPIDJSON_UINT64_C2(0xc83553c5, 0xc8965d3d), RAPIDJSON_UINT64_C2(0x952ab45c, 0xfa97a0b3),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xc83553c5, 0xc8965d3d), RAPIDJSON_UINT64_C2(0x952ab45c, 0xfa97a0b3),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  200|  11.5k|        RAPIDJSON_UINT64_C2(0xde469fbd, 0x99a05fe3), RAPIDJSON_UINT64_C2(0xa59bc234, 0xdb398c25),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xde469fbd, 0x99a05fe3), RAPIDJSON_UINT64_C2(0xa59bc234, 0xdb398c25),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  201|  11.5k|        RAPIDJSON_UINT64_C2(0xf6c69a72, 0xa3989f5c), RAPIDJSON_UINT64_C2(0xb7dcbf53, 0x54e9bece),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xf6c69a72, 0xa3989f5c), RAPIDJSON_UINT64_C2(0xb7dcbf53, 0x54e9bece),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  202|  11.5k|        RAPIDJSON_UINT64_C2(0x88fcf317, 0xf22241e2), RAPIDJSON_UINT64_C2(0xcc20ce9b, 0xd35c78a5),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0x88fcf317, 0xf22241e2), RAPIDJSON_UINT64_C2(0xcc20ce9b, 0xd35c78a5),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  203|  11.5k|        RAPIDJSON_UINT64_C2(0x98165af3, 0x7b2153df), RAPIDJSON_UINT64_C2(0xe2a0b5dc, 0x971f303a),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0x98165af3, 0x7b2153df), RAPIDJSON_UINT64_C2(0xe2a0b5dc, 0x971f303a),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  204|  11.5k|        RAPIDJSON_UINT64_C2(0xa8d9d153, 0x5ce3b396), RAPIDJSON_UINT64_C2(0xfb9b7cd9, 0xa4a7443c),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xa8d9d153, 0x5ce3b396), RAPIDJSON_UINT64_C2(0xfb9b7cd9, 0xa4a7443c),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  205|  11.5k|        RAPIDJSON_UINT64_C2(0xbb764c4c, 0xa7a44410), RAPIDJSON_UINT64_C2(0x8bab8eef, 0xb6409c1a),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xbb764c4c, 0xa7a44410), RAPIDJSON_UINT64_C2(0x8bab8eef, 0xb6409c1a),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  206|  11.5k|        RAPIDJSON_UINT64_C2(0xd01fef10, 0xa657842c), RAPIDJSON_UINT64_C2(0x9b10a4e5, 0xe9913129),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xd01fef10, 0xa657842c), RAPIDJSON_UINT64_C2(0x9b10a4e5, 0xe9913129),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  207|  11.5k|        RAPIDJSON_UINT64_C2(0xe7109bfb, 0xa19c0c9d), RAPIDJSON_UINT64_C2(0xac2820d9, 0x623bf429),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0xe7109bfb, 0xa19c0c9d), RAPIDJSON_UINT64_C2(0xac2820d9, 0x623bf429),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  208|  11.5k|        RAPIDJSON_UINT64_C2(0x80444b5e, 0x7aa7cf85), RAPIDJSON_UINT64_C2(0xbf21e440, 0x03acdd2d),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0x80444b5e, 0x7aa7cf85), RAPIDJSON_UINT64_C2(0xbf21e440, 0x03acdd2d),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  209|  11.5k|        RAPIDJSON_UINT64_C2(0x8e679c2f, 0x5e44ff8f), RAPIDJSON_UINT64_C2(0xd433179d, 0x9c8cb841),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0x8e679c2f, 0x5e44ff8f), RAPIDJSON_UINT64_C2(0xd433179d, 0x9c8cb841),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  210|  11.5k|        RAPIDJSON_UINT64_C2(0x9e19db92, 0xb4e31ba9), RAPIDJSON_UINT64_C2(0xeb96bf6e, 0xbadf77d9),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
                      RAPIDJSON_UINT64_C2(0x9e19db92, 0xb4e31ba9), RAPIDJSON_UINT64_C2(0xeb96bf6e, 0xbadf77d9),
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  211|  11.5k|        RAPIDJSON_UINT64_C2(0xaf87023b, 0x9bf0ee6b)
  ------------------
  |  |  320|  11.5k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  212|  11.5k|    };
  213|  11.5k|    static const int16_t kCachedPowers_E[] = {
  214|  11.5k|        -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,
  215|  11.5k|        -954,  -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,
  216|  11.5k|        -688,  -661,  -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,
  217|  11.5k|        -422,  -396,  -369,  -343,  -316,  -289,  -263,  -236,  -210,  -183,
  218|  11.5k|        -157,  -130,  -103,   -77,   -50,   -24,     3,    30,    56,    83,
  219|  11.5k|        109,   136,   162,   189,   216,   242,   269,   295,   322,   348,
  220|  11.5k|        375,   402,   428,   455,   481,   508,   534,   561,   588,   614,
  221|  11.5k|        641,   667,   694,   720,   747,   774,   800,   827,   853,   880,
  222|  11.5k|        907,   933,   960,   986,  1013,  1039,  1066
  223|  11.5k|    };
  224|  11.5k|    RAPIDJSON_ASSERT(index < 87);
  ------------------
  |  |  437|  11.5k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (224:5): [True: 11.5k, False: 0]
  ------------------
  225|  11.5k|    return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]);
  226|  11.5k|}
_ZNK9rapidjson8internal5DiyFp9NormalizeEv:
  106|  15.3k|    DiyFp Normalize() const {
  107|  15.3k|        int s = static_cast<int>(clzll(f));
  108|  15.3k|        return DiyFp(f << s, e - s);
  109|  15.3k|    }
_ZNK9rapidjson8internal5DiyFpmlERKS1_:
   75|  30.1k|    DiyFp operator*(const DiyFp& rhs) const {
   76|       |#if defined(_MSC_VER) && defined(_M_AMD64)
   77|       |        uint64_t h;
   78|       |        uint64_t l = _umul128(f, rhs.f, &h);
   79|       |        if (l & (uint64_t(1) << 63)) // rounding
   80|       |            h++;
   81|       |        return DiyFp(h, e + rhs.e + 64);
   82|       |#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
   83|       |        __extension__ typedef unsigned __int128 uint128;
   84|       |        uint128 p = static_cast<uint128>(f) * static_cast<uint128>(rhs.f);
   85|       |        uint64_t h = static_cast<uint64_t>(p >> 64);
   86|       |        uint64_t l = static_cast<uint64_t>(p);
   87|       |        if (l & (uint64_t(1) << 63)) // rounding
   88|       |            h++;
   89|       |        return DiyFp(h, e + rhs.e + 64);
   90|       |#else
   91|  30.1k|        const uint64_t M32 = 0xFFFFFFFF;
   92|  30.1k|        const uint64_t a = f >> 32;
   93|  30.1k|        const uint64_t b = f & M32;
   94|  30.1k|        const uint64_t c = rhs.f >> 32;
   95|  30.1k|        const uint64_t d = rhs.f & M32;
   96|  30.1k|        const uint64_t ac = a * c;
   97|  30.1k|        const uint64_t bc = b * c;
   98|  30.1k|        const uint64_t ad = a * d;
   99|  30.1k|        const uint64_t bd = b * d;
  100|  30.1k|        uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32);
  101|  30.1k|        tmp += 1U << 31;  /// mult_round
  102|  30.1k|        return DiyFp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), e + rhs.e + 64);
  103|  30.1k|#endif
  104|  30.1k|    }
_ZNK9rapidjson8internal5DiyFpmiERKS1_:
   71|  7.70k|    DiyFp operator-(const DiyFp& rhs) const {
   72|  7.70k|        return DiyFp(f - rhs.f, e);
   73|  7.70k|    }
_ZN9rapidjson8internal16GetCachedPower10EiPi:
  242|  3.84k|inline DiyFp GetCachedPower10(int exp, int *outExp) {
  243|  3.84k|    RAPIDJSON_ASSERT(exp >= -348);
  ------------------
  |  |  437|  3.84k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (243:5): [True: 3.84k, False: 0]
  ------------------
  244|  3.84k|    unsigned index = static_cast<unsigned>(exp + 348) / 8u;
  245|  3.84k|    *outExp = -348 + static_cast<int>(index) * 8;
  246|  3.84k|    return GetCachedPowerByIndex(index);
  247|  3.84k|}
_ZNK9rapidjson8internal5DiyFp8ToDoubleEv:
  131|  3.84k|    double ToDouble() const {
  132|  3.84k|        union {
  133|  3.84k|            double d;
  134|  3.84k|            uint64_t u64;
  135|  3.84k|        }u;
  136|  3.84k|        RAPIDJSON_ASSERT(f <= kDpHiddenBit + kDpSignificandMask);
  ------------------
  |  |  437|  3.84k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (136:9): [True: 3.84k, False: 0]
  ------------------
  137|  3.84k|        if (e < kDpDenormalExponent) {
  ------------------
  |  Branch (137:13): [True: 0, False: 3.84k]
  ------------------
  138|       |            // Underflow.
  139|      0|            return 0.0;
  140|      0|        }
  141|  3.84k|        if (e >= kDpMaxExponent) {
  ------------------
  |  Branch (141:13): [True: 0, False: 3.84k]
  ------------------
  142|       |            // Overflow.
  143|      0|            return std::numeric_limits<double>::infinity();
  144|      0|        }
  145|  3.84k|        const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 :
  ------------------
  |  Branch (145:30): [True: 543, False: 3.29k]
  |  Branch (145:58): [True: 543, False: 0]
  ------------------
  146|  3.84k|            static_cast<uint64_t>(e + kDpExponentBias);
  147|  3.84k|        u.u64 = (f & kDpSignificandMask) | (be << kDpSignificandSize);
  148|  3.84k|        return u.d;
  149|  3.84k|    }

_ZN9rapidjson8internal4dtoaEdPci:
  220|  7.71k|inline char* dtoa(double value, char* buffer, int maxDecimalPlaces = 324) {
  221|  7.71k|    RAPIDJSON_ASSERT(maxDecimalPlaces >= 1);
  ------------------
  |  |  437|  7.71k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (221:5): [True: 7.71k, False: 0]
  ------------------
  222|  7.71k|    Double d(value);
  223|  7.71k|    if (d.IsZero()) {
  ------------------
  |  Branch (223:9): [True: 8, False: 7.70k]
  ------------------
  224|      8|        if (d.Sign())
  ------------------
  |  Branch (224:13): [True: 0, False: 8]
  ------------------
  225|      0|            *buffer++ = '-';     // -0.0, Issue #289
  226|      8|        buffer[0] = '0';
  227|      8|        buffer[1] = '.';
  228|      8|        buffer[2] = '0';
  229|      8|        return &buffer[3];
  230|      8|    }
  231|  7.70k|    else {
  232|  7.70k|        if (value < 0) {
  ------------------
  |  Branch (232:13): [True: 6, False: 7.69k]
  ------------------
  233|      6|            *buffer++ = '-';
  234|      6|            value = -value;
  235|      6|        }
  236|  7.70k|        int length, K;
  237|  7.70k|        Grisu2(value, buffer, &length, &K);
  238|  7.70k|        return Prettify(buffer, length, K, maxDecimalPlaces);
  239|  7.70k|    }
  240|  7.71k|}
_ZN9rapidjson8internal6Grisu2EdPcPiS2_:
  116|  7.70k|inline void Grisu2(double value, char* buffer, int* length, int* K) {
  117|  7.70k|    const DiyFp v(value);
  118|  7.70k|    DiyFp w_m, w_p;
  119|  7.70k|    v.NormalizedBoundaries(&w_m, &w_p);
  120|       |
  121|  7.70k|    const DiyFp c_mk = GetCachedPower(w_p.e, K);
  122|  7.70k|    const DiyFp W = v.Normalize() * c_mk;
  123|  7.70k|    DiyFp Wp = w_p * c_mk;
  124|  7.70k|    DiyFp Wm = w_m * c_mk;
  125|  7.70k|    Wm.f++;
  126|  7.70k|    Wp.f--;
  127|  7.70k|    DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K);
  128|  7.70k|}
_ZN9rapidjson8internal8DigitGenERKNS0_5DiyFpES3_mPcPiS5_:
   60|  7.70k|inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buffer, int* len, int* K) {
   61|  7.70k|    static const uint64_t kPow10[] = { 1ULL, 10ULL, 100ULL, 1000ULL, 10000ULL, 100000ULL, 1000000ULL, 10000000ULL, 100000000ULL,
   62|  7.70k|                                       1000000000ULL, 10000000000ULL, 100000000000ULL, 1000000000000ULL,
   63|  7.70k|                                       10000000000000ULL, 100000000000000ULL, 1000000000000000ULL,
   64|  7.70k|                                       10000000000000000ULL, 100000000000000000ULL, 1000000000000000000ULL,
   65|  7.70k|                                       10000000000000000000ULL };
   66|  7.70k|    const DiyFp one(uint64_t(1) << -Mp.e, Mp.e);
   67|  7.70k|    const DiyFp wp_w = Mp - W;
   68|  7.70k|    uint32_t p1 = static_cast<uint32_t>(Mp.f >> -one.e);
   69|  7.70k|    uint64_t p2 = Mp.f & (one.f - 1);
   70|  7.70k|    int kappa = CountDecimalDigit32(p1); // kappa in [0, 9]
   71|  7.70k|    *len = 0;
   72|       |
   73|  16.2k|    while (kappa > 0) {
  ------------------
  |  Branch (73:12): [True: 15.0k, False: 1.22k]
  ------------------
   74|  15.0k|        uint32_t d = 0;
   75|  15.0k|        switch (kappa) {
   76|     21|            case  9: d = p1 /  100000000; p1 %=  100000000; break;
  ------------------
  |  Branch (76:13): [True: 21, False: 14.9k]
  ------------------
   77|    499|            case  8: d = p1 /   10000000; p1 %=   10000000; break;
  ------------------
  |  Branch (77:13): [True: 499, False: 14.5k]
  ------------------
   78|  1.71k|            case  7: d = p1 /    1000000; p1 %=    1000000; break;
  ------------------
  |  Branch (78:13): [True: 1.71k, False: 13.2k]
  ------------------
   79|  5.32k|            case  6: d = p1 /     100000; p1 %=     100000; break;
  ------------------
  |  Branch (79:13): [True: 5.32k, False: 9.67k]
  ------------------
   80|  1.25k|            case  5: d = p1 /      10000; p1 %=      10000; break;
  ------------------
  |  Branch (80:13): [True: 1.25k, False: 13.7k]
  ------------------
   81|  1.45k|            case  4: d = p1 /       1000; p1 %=       1000; break;
  ------------------
  |  Branch (81:13): [True: 1.45k, False: 13.5k]
  ------------------
   82|  1.19k|            case  3: d = p1 /        100; p1 %=        100; break;
  ------------------
  |  Branch (82:13): [True: 1.19k, False: 13.8k]
  ------------------
   83|  1.43k|            case  2: d = p1 /         10; p1 %=         10; break;
  ------------------
  |  Branch (83:13): [True: 1.43k, False: 13.5k]
  ------------------
   84|  2.10k|            case  1: d = p1;              p1 =           0; break;
  ------------------
  |  Branch (84:13): [True: 2.10k, False: 12.8k]
  ------------------
   85|      0|            default:;
  ------------------
  |  Branch (85:13): [True: 0, False: 15.0k]
  ------------------
   86|  15.0k|        }
   87|  15.0k|        if (d || *len)
  ------------------
  |  Branch (87:13): [True: 13.3k, False: 1.68k]
  |  Branch (87:18): [True: 1.68k, False: 0]
  ------------------
   88|  15.0k|            buffer[(*len)++] = static_cast<char>('0' + static_cast<char>(d));
   89|  15.0k|        kappa--;
   90|  15.0k|        uint64_t tmp = (static_cast<uint64_t>(p1) << -one.e) + p2;
   91|  15.0k|        if (tmp <= delta) {
  ------------------
  |  Branch (91:13): [True: 6.47k, False: 8.52k]
  ------------------
   92|  6.47k|            *K += kappa;
   93|  6.47k|            GrisuRound(buffer, *len, delta, tmp, kPow10[kappa] << -one.e, wp_w.f);
   94|  6.47k|            return;
   95|  6.47k|        }
   96|  15.0k|    }
   97|       |
   98|       |    // kappa = 0
   99|  12.6k|    for (;;) {
  100|  12.6k|        p2 *= 10;
  101|  12.6k|        delta *= 10;
  102|  12.6k|        char d = static_cast<char>(p2 >> -one.e);
  103|  12.6k|        if (d || *len)
  ------------------
  |  Branch (103:13): [True: 10.8k, False: 1.84k]
  |  Branch (103:18): [True: 1.84k, False: 0]
  ------------------
  104|  12.6k|            buffer[(*len)++] = static_cast<char>('0' + d);
  105|  12.6k|        p2 &= one.f - 1;
  106|  12.6k|        kappa--;
  107|  12.6k|        if (p2 < delta) {
  ------------------
  |  Branch (107:13): [True: 1.22k, False: 11.4k]
  ------------------
  108|  1.22k|            *K += kappa;
  109|  1.22k|            int index = -kappa;
  110|  1.22k|            GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * (index < 20 ? kPow10[index] : 0));
  ------------------
  |  Branch (110:66): [True: 1.22k, False: 0]
  ------------------
  111|  1.22k|            return;
  112|  1.22k|        }
  113|  12.6k|    }
  114|  1.22k|}
_ZN9rapidjson8internal19CountDecimalDigit32Ej:
   44|  7.70k|inline int CountDecimalDigit32(uint32_t n) {
   45|       |    // Simple pure C++ implementation was faster than __builtin_clz version in this situation.
   46|  7.70k|    if (n < 10) return 1;
  ------------------
  |  Branch (46:9): [True: 859, False: 6.84k]
  ------------------
   47|  6.84k|    if (n < 100) return 2;
  ------------------
  |  Branch (47:9): [True: 310, False: 6.53k]
  ------------------
   48|  6.53k|    if (n < 1000) return 3;
  ------------------
  |  Branch (48:9): [True: 252, False: 6.28k]
  ------------------
   49|  6.28k|    if (n < 10000) return 4;
  ------------------
  |  Branch (49:9): [True: 343, False: 5.93k]
  ------------------
   50|  5.93k|    if (n < 100000) return 5;
  ------------------
  |  Branch (50:9): [True: 585, False: 5.35k]
  ------------------
   51|  5.35k|    if (n < 1000000) return 6;
  ------------------
  |  Branch (51:9): [True: 3.60k, False: 1.74k]
  ------------------
   52|  1.74k|    if (n < 10000000) return 7;
  ------------------
  |  Branch (52:9): [True: 1.22k, False: 517]
  ------------------
   53|    517|    if (n < 100000000) return 8;
  ------------------
  |  Branch (53:9): [True: 496, False: 21]
  ------------------
   54|       |    // Will not reach 10 digits in DigitGen()
   55|       |    //if (n < 1000000000) return 9;
   56|       |    //return 10;
   57|     21|    return 9;
   58|    517|}
_ZN9rapidjson8internal10GrisuRoundEPcimmmm:
   35|  7.70k|inline void GrisuRound(char* buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w) {
   36|  10.0k|    while (rest < wp_w && delta - rest >= ten_kappa &&
  ------------------
  |  Branch (36:12): [True: 5.35k, False: 4.66k]
  |  Branch (36:27): [True: 3.46k, False: 1.89k]
  ------------------
   37|  3.46k|           (rest + ten_kappa < wp_w ||  /// closer
  ------------------
  |  Branch (37:13): [True: 2.16k, False: 1.30k]
  ------------------
   38|  2.32k|            wp_w - rest > rest + ten_kappa - wp_w)) {
  ------------------
  |  Branch (38:13): [True: 162, False: 1.14k]
  ------------------
   39|  2.32k|        buffer[len - 1]--;
   40|  2.32k|        rest += ten_kappa;
   41|  2.32k|    }
   42|  7.70k|}
_ZN9rapidjson8internal8PrettifyEPciii:
  154|  7.70k|inline char* Prettify(char* buffer, int length, int k, int maxDecimalPlaces) {
  155|  7.70k|    const int kk = length + k;  // 10^(kk-1) <= v < 10^kk
  156|       |
  157|  7.70k|    if (0 <= k && kk <= 21) {
  ------------------
  |  Branch (157:9): [True: 5.92k, False: 1.78k]
  |  Branch (157:19): [True: 4.33k, False: 1.58k]
  ------------------
  158|       |        // 1234e7 -> 12340000000
  159|  42.7k|        for (int i = length; i < kk; i++)
  ------------------
  |  Branch (159:30): [True: 38.4k, False: 4.33k]
  ------------------
  160|  38.4k|            buffer[i] = '0';
  161|  4.33k|        buffer[kk] = '.';
  162|  4.33k|        buffer[kk + 1] = '0';
  163|  4.33k|        return &buffer[kk + 2];
  164|  4.33k|    }
  165|  3.36k|    else if (0 < kk && kk <= 21) {
  ------------------
  |  Branch (165:14): [True: 2.16k, False: 1.20k]
  |  Branch (165:24): [True: 572, False: 1.58k]
  ------------------
  166|       |        // 1234e-2 -> 12.34
  167|    572|        std::memmove(&buffer[kk + 1], &buffer[kk], static_cast<size_t>(length - kk));
  168|    572|        buffer[kk] = '.';
  169|    572|        if (0 > k + maxDecimalPlaces) {
  ------------------
  |  Branch (169:13): [True: 0, False: 572]
  ------------------
  170|       |            // When maxDecimalPlaces = 2, 1.2345 -> 1.23, 1.102 -> 1.1
  171|       |            // Remove extra trailing zeros (at least one) after truncation.
  172|      0|            for (int i = kk + maxDecimalPlaces; i > kk + 1; i--)
  ------------------
  |  Branch (172:49): [True: 0, False: 0]
  ------------------
  173|      0|                if (buffer[i] != '0')
  ------------------
  |  Branch (173:21): [True: 0, False: 0]
  ------------------
  174|      0|                    return &buffer[i + 1];
  175|      0|            return &buffer[kk + 2]; // Reserve one zero
  176|      0|        }
  177|    572|        else
  178|    572|            return &buffer[length + 1];
  179|    572|    }
  180|  2.79k|    else if (-6 < kk && kk <= 0) {
  ------------------
  |  Branch (180:14): [True: 1.60k, False: 1.18k]
  |  Branch (180:25): [True: 20, False: 1.58k]
  ------------------
  181|       |        // 1234e-6 -> 0.001234
  182|     20|        const int offset = 2 - kk;
  183|     20|        std::memmove(&buffer[offset], &buffer[0], static_cast<size_t>(length));
  184|     20|        buffer[0] = '0';
  185|     20|        buffer[1] = '.';
  186|     32|        for (int i = 2; i < offset; i++)
  ------------------
  |  Branch (186:25): [True: 12, False: 20]
  ------------------
  187|     12|            buffer[i] = '0';
  188|     20|        if (length - kk > maxDecimalPlaces) {
  ------------------
  |  Branch (188:13): [True: 0, False: 20]
  ------------------
  189|       |            // When maxDecimalPlaces = 2, 0.123 -> 0.12, 0.102 -> 0.1
  190|       |            // Remove extra trailing zeros (at least one) after truncation.
  191|      0|            for (int i = maxDecimalPlaces + 1; i > 2; i--)
  ------------------
  |  Branch (191:48): [True: 0, False: 0]
  ------------------
  192|      0|                if (buffer[i] != '0')
  ------------------
  |  Branch (192:21): [True: 0, False: 0]
  ------------------
  193|      0|                    return &buffer[i + 1];
  194|      0|            return &buffer[3]; // Reserve one zero
  195|      0|        }
  196|     20|        else
  197|     20|            return &buffer[length + offset];
  198|     20|    }
  199|  2.77k|    else if (kk < -maxDecimalPlaces) {
  ------------------
  |  Branch (199:14): [True: 0, False: 2.77k]
  ------------------
  200|       |        // Truncate to zero
  201|      0|        buffer[0] = '0';
  202|      0|        buffer[1] = '.';
  203|      0|        buffer[2] = '0';
  204|      0|        return &buffer[3];
  205|      0|    }
  206|  2.77k|    else if (length == 1) {
  ------------------
  |  Branch (206:14): [True: 1.64k, False: 1.13k]
  ------------------
  207|       |        // 1e30
  208|  1.64k|        buffer[1] = 'e';
  209|  1.64k|        return WriteExponent(kk - 1, &buffer[2]);
  210|  1.64k|    }
  211|  1.13k|    else {
  212|       |        // 1234e30 -> 1.234e33
  213|  1.13k|        std::memmove(&buffer[2], &buffer[1], static_cast<size_t>(length - 1));
  214|  1.13k|        buffer[1] = '.';
  215|  1.13k|        buffer[length + 1] = 'e';
  216|  1.13k|        return WriteExponent(kk - 1, &buffer[0 + length + 2]);
  217|  1.13k|    }
  218|  7.70k|}
_ZN9rapidjson8internal13WriteExponentEiPc:
  130|  2.77k|inline char* WriteExponent(int K, char* buffer) {
  131|  2.77k|    if (K < 0) {
  ------------------
  |  Branch (131:9): [True: 1.18k, False: 1.58k]
  ------------------
  132|  1.18k|        *buffer++ = '-';
  133|  1.18k|        K = -K;
  134|  1.18k|    }
  135|       |
  136|  2.77k|    if (K >= 100) {
  ------------------
  |  Branch (136:9): [True: 1.23k, False: 1.54k]
  ------------------
  137|  1.23k|        *buffer++ = static_cast<char>('0' + static_cast<char>(K / 100));
  138|  1.23k|        K %= 100;
  139|  1.23k|        const char* d = GetDigitsLut() + K * 2;
  140|  1.23k|        *buffer++ = d[0];
  141|  1.23k|        *buffer++ = d[1];
  142|  1.23k|    }
  143|  1.54k|    else if (K >= 10) {
  ------------------
  |  Branch (143:14): [True: 1.54k, False: 1]
  ------------------
  144|  1.54k|        const char* d = GetDigitsLut() + K * 2;
  145|  1.54k|        *buffer++ = d[0];
  146|  1.54k|        *buffer++ = d[1];
  147|  1.54k|    }
  148|      1|    else
  149|      1|        *buffer++ = static_cast<char>('0' + static_cast<char>(K));
  150|       |
  151|  2.77k|    return buffer;
  152|  2.77k|}

_ZN9rapidjson8internal6DoubleC2Ed:
   26|  15.4k|    Double(double d) : d_(d) {}
_ZNK9rapidjson8internal6Double10IsNanOrInfEv:
   43|  7.71k|    bool IsNanOrInf() const { return (u_ & kExponentMask) == kExponentMask; }
_ZNK9rapidjson8internal6Double6IsZeroEv:
   45|  7.71k|    bool IsZero() const { return (u_ & (kExponentMask | kSignificandMask)) == 0; }
_ZNK9rapidjson8internal6Double4SignEv:
   37|      8|    bool Sign() const { return (u_ & kSignMask) != 0; }
_ZN9rapidjson8internal6Double24EffectiveSignificandSizeEi:
   51|  3.84k|    static int EffectiveSignificandSize(int order) {
   52|  3.84k|        if (order >= -1021)
  ------------------
  |  Branch (52:13): [True: 3.29k, False: 543]
  ------------------
   53|  3.29k|            return 53;
   54|    543|        else if (order <= -1074)
  ------------------
  |  Branch (54:18): [True: 282, False: 261]
  ------------------
   55|    282|            return 0;
   56|    261|        else
   57|    261|            return order + 1074;
   58|  3.84k|    }
_ZNK9rapidjson8internal6Double18IntegerSignificandEv:
   47|      8|    uint64_t IntegerSignificand() const { return IsNormal() ? Significand() | kHiddenBit : Significand(); }
  ------------------
  |  Branch (47:50): [True: 8, False: 0]
  ------------------
_ZNK9rapidjson8internal6Double8IsNormalEv:
   44|     16|    bool IsNormal() const { return (u_ & kExponentMask) != 0 || Significand() == 0; }
  ------------------
  |  Branch (44:36): [True: 16, False: 0]
  |  Branch (44:65): [True: 0, False: 0]
  ------------------
_ZNK9rapidjson8internal6Double15IntegerExponentEv:
   48|      8|    int IntegerExponent() const { return (IsNormal() ? Exponent() : kDenormalExponent) - kSignificandSize; }
  ------------------
  |  Branch (48:43): [True: 8, False: 0]
  ------------------
_ZNK9rapidjson8internal6Double8ExponentEv:
   39|      8|    int Exponent() const { return static_cast<int>(((u_ & kExponentMask) >> kSignificandSize) - kExponentBias); }
_ZNK9rapidjson8internal6Double5ValueEv:
   29|     16|    double Value() const { return d_; }
_ZNK9rapidjson8internal6Double11SignificandEv:
   38|     15|    uint64_t Significand() const { return u_ & kSignificandMask; }

_ZN9rapidjson8internal12GetDigitsLutEv:
   23|  1.69M|inline const char* GetDigitsLut() {
   24|  1.69M|    static const char cDigitsLut[200] = {
   25|  1.69M|        '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9',
   26|  1.69M|        '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9',
   27|  1.69M|        '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9',
   28|  1.69M|        '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9',
   29|  1.69M|        '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9',
   30|  1.69M|        '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9',
   31|  1.69M|        '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9',
   32|  1.69M|        '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9',
   33|  1.69M|        '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9',
   34|  1.69M|        '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9'
   35|  1.69M|    };
   36|  1.69M|    return cDigitsLut;
   37|  1.69M|}
_ZN9rapidjson8internal6i32toaEiPc:
  115|  1.68M|inline char* i32toa(int32_t value, char* buffer) {
  116|  1.68M|    RAPIDJSON_ASSERT(buffer != 0);
  ------------------
  |  |  437|  1.68M|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (116:5): [True: 1.68M, False: 0]
  ------------------
  117|  1.68M|    uint32_t u = static_cast<uint32_t>(value);
  118|  1.68M|    if (value < 0) {
  ------------------
  |  Branch (118:9): [True: 335, False: 1.68M]
  ------------------
  119|    335|        *buffer++ = '-';
  120|    335|        u = ~u + 1;
  121|    335|    }
  122|       |
  123|  1.68M|    return u32toa(u, buffer);
  124|  1.68M|}
_ZN9rapidjson8internal6u32toaEjPc:
   39|  1.68M|inline char* u32toa(uint32_t value, char* buffer) {
   40|  1.68M|    RAPIDJSON_ASSERT(buffer != 0);
  ------------------
  |  |  437|  1.68M|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (40:5): [True: 1.68M, False: 0]
  ------------------
   41|       |
   42|  1.68M|    const char* cDigitsLut = GetDigitsLut();
   43|       |
   44|  1.68M|    if (value < 10000) {
  ------------------
  |  Branch (44:9): [True: 1.68M, False: 2.25k]
  ------------------
   45|  1.68M|        const uint32_t d1 = (value / 100) << 1;
   46|  1.68M|        const uint32_t d2 = (value % 100) << 1;
   47|       |
   48|  1.68M|        if (value >= 1000)
  ------------------
  |  Branch (48:13): [True: 122, False: 1.68M]
  ------------------
   49|    122|            *buffer++ = cDigitsLut[d1];
   50|  1.68M|        if (value >= 100)
  ------------------
  |  Branch (50:13): [True: 779, False: 1.68M]
  ------------------
   51|    779|            *buffer++ = cDigitsLut[d1 + 1];
   52|  1.68M|        if (value >= 10)
  ------------------
  |  Branch (52:13): [True: 4.82k, False: 1.68M]
  ------------------
   53|  4.82k|            *buffer++ = cDigitsLut[d2];
   54|  1.68M|        *buffer++ = cDigitsLut[d2 + 1];
   55|  1.68M|    }
   56|  2.25k|    else if (value < 100000000) {
  ------------------
  |  Branch (56:14): [True: 2.08k, False: 170]
  ------------------
   57|       |        // value = bbbbcccc
   58|  2.08k|        const uint32_t b = value / 10000;
   59|  2.08k|        const uint32_t c = value % 10000;
   60|       |
   61|  2.08k|        const uint32_t d1 = (b / 100) << 1;
   62|  2.08k|        const uint32_t d2 = (b % 100) << 1;
   63|       |
   64|  2.08k|        const uint32_t d3 = (c / 100) << 1;
   65|  2.08k|        const uint32_t d4 = (c % 100) << 1;
   66|       |
   67|  2.08k|        if (value >= 10000000)
  ------------------
  |  Branch (67:13): [True: 212, False: 1.87k]
  ------------------
   68|    212|            *buffer++ = cDigitsLut[d1];
   69|  2.08k|        if (value >= 1000000)
  ------------------
  |  Branch (69:13): [True: 702, False: 1.38k]
  ------------------
   70|    702|            *buffer++ = cDigitsLut[d1 + 1];
   71|  2.08k|        if (value >= 100000)
  ------------------
  |  Branch (71:13): [True: 1.19k, False: 892]
  ------------------
   72|  1.19k|            *buffer++ = cDigitsLut[d2];
   73|  2.08k|        *buffer++ = cDigitsLut[d2 + 1];
   74|       |
   75|  2.08k|        *buffer++ = cDigitsLut[d3];
   76|  2.08k|        *buffer++ = cDigitsLut[d3 + 1];
   77|  2.08k|        *buffer++ = cDigitsLut[d4];
   78|  2.08k|        *buffer++ = cDigitsLut[d4 + 1];
   79|  2.08k|    }
   80|    170|    else {
   81|       |        // value = aabbbbcccc in decimal
   82|       |
   83|    170|        const uint32_t a = value / 100000000; // 1 to 42
   84|    170|        value %= 100000000;
   85|       |
   86|    170|        if (a >= 10) {
  ------------------
  |  Branch (86:13): [True: 6, False: 164]
  ------------------
   87|      6|            const unsigned i = a << 1;
   88|      6|            *buffer++ = cDigitsLut[i];
   89|      6|            *buffer++ = cDigitsLut[i + 1];
   90|      6|        }
   91|    164|        else
   92|    164|            *buffer++ = static_cast<char>('0' + static_cast<char>(a));
   93|       |
   94|    170|        const uint32_t b = value / 10000; // 0 to 9999
   95|    170|        const uint32_t c = value % 10000; // 0 to 9999
   96|       |
   97|    170|        const uint32_t d1 = (b / 100) << 1;
   98|    170|        const uint32_t d2 = (b % 100) << 1;
   99|       |
  100|    170|        const uint32_t d3 = (c / 100) << 1;
  101|    170|        const uint32_t d4 = (c % 100) << 1;
  102|       |
  103|    170|        *buffer++ = cDigitsLut[d1];
  104|    170|        *buffer++ = cDigitsLut[d1 + 1];
  105|    170|        *buffer++ = cDigitsLut[d2];
  106|    170|        *buffer++ = cDigitsLut[d2 + 1];
  107|    170|        *buffer++ = cDigitsLut[d3];
  108|    170|        *buffer++ = cDigitsLut[d3 + 1];
  109|    170|        *buffer++ = cDigitsLut[d4];
  110|    170|        *buffer++ = cDigitsLut[d4 + 1];
  111|    170|    }
  112|  1.68M|    return buffer;
  113|  1.68M|}
_ZN9rapidjson8internal6i64toaElPc:
  294|  5.90k|inline char* i64toa(int64_t value, char* buffer) {
  295|  5.90k|    RAPIDJSON_ASSERT(buffer != 0);
  ------------------
  |  |  437|  5.90k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (295:5): [True: 5.90k, False: 0]
  ------------------
  296|  5.90k|    uint64_t u = static_cast<uint64_t>(value);
  297|  5.90k|    if (value < 0) {
  ------------------
  |  Branch (297:9): [True: 40, False: 5.86k]
  ------------------
  298|     40|        *buffer++ = '-';
  299|     40|        u = ~u + 1;
  300|     40|    }
  301|       |
  302|  5.90k|    return u64toa(u, buffer);
  303|  5.90k|}
_ZN9rapidjson8internal6u64toaEmPc:
  126|  5.97k|inline char* u64toa(uint64_t value, char* buffer) {
  127|  5.97k|    RAPIDJSON_ASSERT(buffer != 0);
  ------------------
  |  |  437|  5.97k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (127:5): [True: 5.97k, False: 0]
  ------------------
  128|  5.97k|    const char* cDigitsLut = GetDigitsLut();
  129|  5.97k|    const uint64_t  kTen8 = 100000000;
  130|  5.97k|    const uint64_t  kTen9 = kTen8 * 10;
  131|  5.97k|    const uint64_t kTen10 = kTen8 * 100;
  132|  5.97k|    const uint64_t kTen11 = kTen8 * 1000;
  133|  5.97k|    const uint64_t kTen12 = kTen8 * 10000;
  134|  5.97k|    const uint64_t kTen13 = kTen8 * 100000;
  135|  5.97k|    const uint64_t kTen14 = kTen8 * 1000000;
  136|  5.97k|    const uint64_t kTen15 = kTen8 * 10000000;
  137|  5.97k|    const uint64_t kTen16 = kTen8 * kTen8;
  138|       |
  139|  5.97k|    if (value < kTen8) {
  ------------------
  |  Branch (139:9): [True: 0, False: 5.97k]
  ------------------
  140|      0|        uint32_t v = static_cast<uint32_t>(value);
  141|      0|        if (v < 10000) {
  ------------------
  |  Branch (141:13): [True: 0, False: 0]
  ------------------
  142|      0|            const uint32_t d1 = (v / 100) << 1;
  143|      0|            const uint32_t d2 = (v % 100) << 1;
  144|       |
  145|      0|            if (v >= 1000)
  ------------------
  |  Branch (145:17): [True: 0, False: 0]
  ------------------
  146|      0|                *buffer++ = cDigitsLut[d1];
  147|      0|            if (v >= 100)
  ------------------
  |  Branch (147:17): [True: 0, False: 0]
  ------------------
  148|      0|                *buffer++ = cDigitsLut[d1 + 1];
  149|      0|            if (v >= 10)
  ------------------
  |  Branch (149:17): [True: 0, False: 0]
  ------------------
  150|      0|                *buffer++ = cDigitsLut[d2];
  151|      0|            *buffer++ = cDigitsLut[d2 + 1];
  152|      0|        }
  153|      0|        else {
  154|       |            // value = bbbbcccc
  155|      0|            const uint32_t b = v / 10000;
  156|      0|            const uint32_t c = v % 10000;
  157|       |
  158|      0|            const uint32_t d1 = (b / 100) << 1;
  159|      0|            const uint32_t d2 = (b % 100) << 1;
  160|       |
  161|      0|            const uint32_t d3 = (c / 100) << 1;
  162|      0|            const uint32_t d4 = (c % 100) << 1;
  163|       |
  164|      0|            if (value >= 10000000)
  ------------------
  |  Branch (164:17): [True: 0, False: 0]
  ------------------
  165|      0|                *buffer++ = cDigitsLut[d1];
  166|      0|            if (value >= 1000000)
  ------------------
  |  Branch (166:17): [True: 0, False: 0]
  ------------------
  167|      0|                *buffer++ = cDigitsLut[d1 + 1];
  168|      0|            if (value >= 100000)
  ------------------
  |  Branch (168:17): [True: 0, False: 0]
  ------------------
  169|      0|                *buffer++ = cDigitsLut[d2];
  170|      0|            *buffer++ = cDigitsLut[d2 + 1];
  171|       |
  172|      0|            *buffer++ = cDigitsLut[d3];
  173|      0|            *buffer++ = cDigitsLut[d3 + 1];
  174|      0|            *buffer++ = cDigitsLut[d4];
  175|      0|            *buffer++ = cDigitsLut[d4 + 1];
  176|      0|        }
  177|      0|    }
  178|  5.97k|    else if (value < kTen16) {
  ------------------
  |  Branch (178:14): [True: 4.99k, False: 984]
  ------------------
  179|  4.99k|        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
  180|  4.99k|        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
  181|       |
  182|  4.99k|        const uint32_t b0 = v0 / 10000;
  183|  4.99k|        const uint32_t c0 = v0 % 10000;
  184|       |
  185|  4.99k|        const uint32_t d1 = (b0 / 100) << 1;
  186|  4.99k|        const uint32_t d2 = (b0 % 100) << 1;
  187|       |
  188|  4.99k|        const uint32_t d3 = (c0 / 100) << 1;
  189|  4.99k|        const uint32_t d4 = (c0 % 100) << 1;
  190|       |
  191|  4.99k|        const uint32_t b1 = v1 / 10000;
  192|  4.99k|        const uint32_t c1 = v1 % 10000;
  193|       |
  194|  4.99k|        const uint32_t d5 = (b1 / 100) << 1;
  195|  4.99k|        const uint32_t d6 = (b1 % 100) << 1;
  196|       |
  197|  4.99k|        const uint32_t d7 = (c1 / 100) << 1;
  198|  4.99k|        const uint32_t d8 = (c1 % 100) << 1;
  199|       |
  200|  4.99k|        if (value >= kTen15)
  ------------------
  |  Branch (200:13): [True: 3.99k, False: 997]
  ------------------
  201|  3.99k|            *buffer++ = cDigitsLut[d1];
  202|  4.99k|        if (value >= kTen14)
  ------------------
  |  Branch (202:13): [True: 4.08k, False: 911]
  ------------------
  203|  4.08k|            *buffer++ = cDigitsLut[d1 + 1];
  204|  4.99k|        if (value >= kTen13)
  ------------------
  |  Branch (204:13): [True: 4.08k, False: 904]
  ------------------
  205|  4.08k|            *buffer++ = cDigitsLut[d2];
  206|  4.99k|        if (value >= kTen12)
  ------------------
  |  Branch (206:13): [True: 4.26k, False: 723]
  ------------------
  207|  4.26k|            *buffer++ = cDigitsLut[d2 + 1];
  208|  4.99k|        if (value >= kTen11)
  ------------------
  |  Branch (208:13): [True: 4.37k, False: 615]
  ------------------
  209|  4.37k|            *buffer++ = cDigitsLut[d3];
  210|  4.99k|        if (value >= kTen10)
  ------------------
  |  Branch (210:13): [True: 4.39k, False: 599]
  ------------------
  211|  4.39k|            *buffer++ = cDigitsLut[d3 + 1];
  212|  4.99k|        if (value >= kTen9)
  ------------------
  |  Branch (212:13): [True: 4.99k, False: 0]
  ------------------
  213|  4.99k|            *buffer++ = cDigitsLut[d4];
  214|       |
  215|  4.99k|        *buffer++ = cDigitsLut[d4 + 1];
  216|  4.99k|        *buffer++ = cDigitsLut[d5];
  217|  4.99k|        *buffer++ = cDigitsLut[d5 + 1];
  218|  4.99k|        *buffer++ = cDigitsLut[d6];
  219|  4.99k|        *buffer++ = cDigitsLut[d6 + 1];
  220|  4.99k|        *buffer++ = cDigitsLut[d7];
  221|  4.99k|        *buffer++ = cDigitsLut[d7 + 1];
  222|  4.99k|        *buffer++ = cDigitsLut[d8];
  223|  4.99k|        *buffer++ = cDigitsLut[d8 + 1];
  224|  4.99k|    }
  225|    984|    else {
  226|    984|        const uint32_t a = static_cast<uint32_t>(value / kTen16); // 1 to 1844
  227|    984|        value %= kTen16;
  228|       |
  229|    984|        if (a < 10)
  ------------------
  |  Branch (229:13): [True: 799, False: 185]
  ------------------
  230|    799|            *buffer++ = static_cast<char>('0' + static_cast<char>(a));
  231|    185|        else if (a < 100) {
  ------------------
  |  Branch (231:18): [True: 83, False: 102]
  ------------------
  232|     83|            const uint32_t i = a << 1;
  233|     83|            *buffer++ = cDigitsLut[i];
  234|     83|            *buffer++ = cDigitsLut[i + 1];
  235|     83|        }
  236|    102|        else if (a < 1000) {
  ------------------
  |  Branch (236:18): [True: 33, False: 69]
  ------------------
  237|     33|            *buffer++ = static_cast<char>('0' + static_cast<char>(a / 100));
  238|       |
  239|     33|            const uint32_t i = (a % 100) << 1;
  240|     33|            *buffer++ = cDigitsLut[i];
  241|     33|            *buffer++ = cDigitsLut[i + 1];
  242|     33|        }
  243|     69|        else {
  244|     69|            const uint32_t i = (a / 100) << 1;
  245|     69|            const uint32_t j = (a % 100) << 1;
  246|     69|            *buffer++ = cDigitsLut[i];
  247|     69|            *buffer++ = cDigitsLut[i + 1];
  248|     69|            *buffer++ = cDigitsLut[j];
  249|     69|            *buffer++ = cDigitsLut[j + 1];
  250|     69|        }
  251|       |
  252|    984|        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
  253|    984|        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
  254|       |
  255|    984|        const uint32_t b0 = v0 / 10000;
  256|    984|        const uint32_t c0 = v0 % 10000;
  257|       |
  258|    984|        const uint32_t d1 = (b0 / 100) << 1;
  259|    984|        const uint32_t d2 = (b0 % 100) << 1;
  260|       |
  261|    984|        const uint32_t d3 = (c0 / 100) << 1;
  262|    984|        const uint32_t d4 = (c0 % 100) << 1;
  263|       |
  264|    984|        const uint32_t b1 = v1 / 10000;
  265|    984|        const uint32_t c1 = v1 % 10000;
  266|       |
  267|    984|        const uint32_t d5 = (b1 / 100) << 1;
  268|    984|        const uint32_t d6 = (b1 % 100) << 1;
  269|       |
  270|    984|        const uint32_t d7 = (c1 / 100) << 1;
  271|    984|        const uint32_t d8 = (c1 % 100) << 1;
  272|       |
  273|    984|        *buffer++ = cDigitsLut[d1];
  274|    984|        *buffer++ = cDigitsLut[d1 + 1];
  275|    984|        *buffer++ = cDigitsLut[d2];
  276|    984|        *buffer++ = cDigitsLut[d2 + 1];
  277|    984|        *buffer++ = cDigitsLut[d3];
  278|    984|        *buffer++ = cDigitsLut[d3 + 1];
  279|    984|        *buffer++ = cDigitsLut[d4];
  280|    984|        *buffer++ = cDigitsLut[d4 + 1];
  281|    984|        *buffer++ = cDigitsLut[d5];
  282|    984|        *buffer++ = cDigitsLut[d5 + 1];
  283|    984|        *buffer++ = cDigitsLut[d6];
  284|    984|        *buffer++ = cDigitsLut[d6 + 1];
  285|    984|        *buffer++ = cDigitsLut[d7];
  286|    984|        *buffer++ = cDigitsLut[d7 + 1];
  287|    984|        *buffer++ = cDigitsLut[d8];
  288|    984|        *buffer++ = cDigitsLut[d8 + 1];
  289|    984|    }
  290|       |
  291|  5.97k|    return buffer;
  292|  5.97k|}

_ZN9rapidjson8internal5Pow10Ei:
   28|  48.9k|inline double Pow10(int n) {
   29|  48.9k|    static const double e[] = { // 1e-0...1e308: 309 * 8 bytes = 2472 bytes
   30|  48.9k|        1e+0,  
   31|  48.9k|        1e+1,  1e+2,  1e+3,  1e+4,  1e+5,  1e+6,  1e+7,  1e+8,  1e+9,  1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20, 
   32|  48.9k|        1e+21, 1e+22, 1e+23, 1e+24, 1e+25, 1e+26, 1e+27, 1e+28, 1e+29, 1e+30, 1e+31, 1e+32, 1e+33, 1e+34, 1e+35, 1e+36, 1e+37, 1e+38, 1e+39, 1e+40,
   33|  48.9k|        1e+41, 1e+42, 1e+43, 1e+44, 1e+45, 1e+46, 1e+47, 1e+48, 1e+49, 1e+50, 1e+51, 1e+52, 1e+53, 1e+54, 1e+55, 1e+56, 1e+57, 1e+58, 1e+59, 1e+60,
   34|  48.9k|        1e+61, 1e+62, 1e+63, 1e+64, 1e+65, 1e+66, 1e+67, 1e+68, 1e+69, 1e+70, 1e+71, 1e+72, 1e+73, 1e+74, 1e+75, 1e+76, 1e+77, 1e+78, 1e+79, 1e+80,
   35|  48.9k|        1e+81, 1e+82, 1e+83, 1e+84, 1e+85, 1e+86, 1e+87, 1e+88, 1e+89, 1e+90, 1e+91, 1e+92, 1e+93, 1e+94, 1e+95, 1e+96, 1e+97, 1e+98, 1e+99, 1e+100,
   36|  48.9k|        1e+101,1e+102,1e+103,1e+104,1e+105,1e+106,1e+107,1e+108,1e+109,1e+110,1e+111,1e+112,1e+113,1e+114,1e+115,1e+116,1e+117,1e+118,1e+119,1e+120,
   37|  48.9k|        1e+121,1e+122,1e+123,1e+124,1e+125,1e+126,1e+127,1e+128,1e+129,1e+130,1e+131,1e+132,1e+133,1e+134,1e+135,1e+136,1e+137,1e+138,1e+139,1e+140,
   38|  48.9k|        1e+141,1e+142,1e+143,1e+144,1e+145,1e+146,1e+147,1e+148,1e+149,1e+150,1e+151,1e+152,1e+153,1e+154,1e+155,1e+156,1e+157,1e+158,1e+159,1e+160,
   39|  48.9k|        1e+161,1e+162,1e+163,1e+164,1e+165,1e+166,1e+167,1e+168,1e+169,1e+170,1e+171,1e+172,1e+173,1e+174,1e+175,1e+176,1e+177,1e+178,1e+179,1e+180,
   40|  48.9k|        1e+181,1e+182,1e+183,1e+184,1e+185,1e+186,1e+187,1e+188,1e+189,1e+190,1e+191,1e+192,1e+193,1e+194,1e+195,1e+196,1e+197,1e+198,1e+199,1e+200,
   41|  48.9k|        1e+201,1e+202,1e+203,1e+204,1e+205,1e+206,1e+207,1e+208,1e+209,1e+210,1e+211,1e+212,1e+213,1e+214,1e+215,1e+216,1e+217,1e+218,1e+219,1e+220,
   42|  48.9k|        1e+221,1e+222,1e+223,1e+224,1e+225,1e+226,1e+227,1e+228,1e+229,1e+230,1e+231,1e+232,1e+233,1e+234,1e+235,1e+236,1e+237,1e+238,1e+239,1e+240,
   43|  48.9k|        1e+241,1e+242,1e+243,1e+244,1e+245,1e+246,1e+247,1e+248,1e+249,1e+250,1e+251,1e+252,1e+253,1e+254,1e+255,1e+256,1e+257,1e+258,1e+259,1e+260,
   44|  48.9k|        1e+261,1e+262,1e+263,1e+264,1e+265,1e+266,1e+267,1e+268,1e+269,1e+270,1e+271,1e+272,1e+273,1e+274,1e+275,1e+276,1e+277,1e+278,1e+279,1e+280,
   45|  48.9k|        1e+281,1e+282,1e+283,1e+284,1e+285,1e+286,1e+287,1e+288,1e+289,1e+290,1e+291,1e+292,1e+293,1e+294,1e+295,1e+296,1e+297,1e+298,1e+299,1e+300,
   46|  48.9k|        1e+301,1e+302,1e+303,1e+304,1e+305,1e+306,1e+307,1e+308
   47|  48.9k|    };
   48|  48.9k|    RAPIDJSON_ASSERT(n >= 0 && n <= 308);
  ------------------
  |  |  437|  48.9k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (48:5): [True: 48.9k, False: 0]
  |  Branch (48:5): [True: 48.9k, False: 0]
  |  Branch (48:5): [True: 48.9k, False: 0]
  ------------------
   49|  48.9k|    return e[n];
   50|  48.9k|}

_ZN9rapidjson8internal5StackINS_12CrtAllocatorEEC2EPS2_m:
   41|    296|    Stack(Allocator* allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator_(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity) {
   42|    296|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEED2Ev:
   62|    296|    ~Stack() {
   63|    296|        Destroy();
   64|    296|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE7DestroyEv:
  208|    296|    void Destroy() {
  209|    296|        Allocator::Free(stack_);
  210|    296|        RAPIDJSON_DELETE(ownAllocator_); // Only delete if it is owned by the stack
  ------------------
  |  |  716|    296|#define RAPIDJSON_DELETE(x) delete x
  ------------------
  211|    296|    }
_ZNK9rapidjson8internal5StackINS_12CrtAllocatorEE12HasAllocatorEv:
  168|    104|    bool HasAllocator() const {
  169|    104|        return allocator_ != 0;
  170|    104|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE4PushINS_12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorIS2_EEEEEEPT_m:
  123|  10.7M|    RAPIDJSON_FORCEINLINE T* Push(size_t count = 1) {
  124|  10.7M|        Reserve<T>(count);
  125|  10.7M|        return PushUnsafe<T>(count);
  126|  10.7M|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE7ReserveINS_12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorIS2_EEEEEEvm:
  116|  10.7M|    RAPIDJSON_FORCEINLINE void Reserve(size_t count = 1) {
  117|       |         // Expand the stack if needed
  118|  10.7M|        if (RAPIDJSON_UNLIKELY(static_cast<std::ptrdiff_t>(sizeof(T) * count) > (stackEnd_ - stackTop_)))
  ------------------
  |  |  505|  10.7M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 752, False: 10.7M]
  |  |  ------------------
  ------------------
  119|    752|            Expand<T>(count);
  120|  10.7M|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE6ExpandINS_12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorIS2_EEEEEEvm:
  183|    752|    void Expand(size_t count) {
  184|       |        // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.
  185|    752|        size_t newCapacity;
  186|    752|        if (stack_ == 0) {
  ------------------
  |  Branch (186:13): [True: 70, False: 682]
  ------------------
  187|     70|            if (!allocator_)
  ------------------
  |  Branch (187:17): [True: 70, False: 0]
  ------------------
  188|     70|                ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
  ------------------
  |  |  712|     70|#define RAPIDJSON_NEW(TypeName) new TypeName
  ------------------
  189|     70|            newCapacity = initialCapacity_;
  190|    682|        } else {
  191|    682|            newCapacity = GetCapacity();
  192|    682|            newCapacity += (newCapacity + 1) / 2;
  193|    682|        }
  194|    752|        size_t newSize = GetSize() + sizeof(T) * count;
  195|    752|        if (newCapacity < newSize)
  ------------------
  |  Branch (195:13): [True: 0, False: 752]
  ------------------
  196|      0|            newCapacity = newSize;
  197|       |
  198|    752|        Resize(newCapacity);
  199|    752|    }
_ZNK9rapidjson8internal5StackINS_12CrtAllocatorEE11GetCapacityEv:
  179|  3.52k|    size_t GetCapacity() const { return static_cast<size_t>(stackEnd_ - stack_); }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE6ResizeEm:
  201|  1.85k|    void Resize(size_t newCapacity) {
  202|  1.85k|        const size_t size = GetSize();  // Backup the current size
  203|  1.85k|        stack_ = static_cast<char*>(allocator_->Realloc(stack_, GetCapacity(), newCapacity));
  204|  1.85k|        stackTop_ = stack_ + size;
  205|  1.85k|        stackEnd_ = stack_ + newCapacity;
  206|  1.85k|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE10PushUnsafeINS_12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorIS2_EEEEEEPT_m:
  129|  10.7M|    RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) {
  130|  10.7M|        RAPIDJSON_ASSERT(stackTop_);
  ------------------
  |  |  437|  10.7M|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (130:9): [True: 10.7M, False: 0]
  ------------------
  131|  10.7M|        RAPIDJSON_ASSERT(static_cast<std::ptrdiff_t>(sizeof(T) * count) <= (stackEnd_ - stackTop_));
  ------------------
  |  |  437|  10.7M|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (131:9): [True: 10.7M, False: 0]
  ------------------
  132|  10.7M|        T* ret = reinterpret_cast<T*>(stackTop_);
  133|  10.7M|        stackTop_ += sizeof(T) * count;
  134|  10.7M|        return ret;
  135|  10.7M|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE4PushIcEEPT_m:
  123|  65.2M|    RAPIDJSON_FORCEINLINE T* Push(size_t count = 1) {
  124|  65.2M|        Reserve<T>(count);
  125|  65.2M|        return PushUnsafe<T>(count);
  126|  65.2M|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE7ReserveIcEEvm:
  116|  67.7M|    RAPIDJSON_FORCEINLINE void Reserve(size_t count = 1) {
  117|       |         // Expand the stack if needed
  118|  67.7M|        if (RAPIDJSON_UNLIKELY(static_cast<std::ptrdiff_t>(sizeof(T) * count) > (stackEnd_ - stackTop_)))
  ------------------
  |  |  505|  67.7M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 1.01k, False: 67.7M]
  |  |  ------------------
  ------------------
  119|  1.01k|            Expand<T>(count);
  120|  67.7M|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE6ExpandIcEEvm:
  183|  1.01k|    void Expand(size_t count) {
  184|       |        // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.
  185|  1.01k|        size_t newCapacity;
  186|  1.01k|        if (stack_ == 0) {
  ------------------
  |  Branch (186:13): [True: 100, False: 912]
  ------------------
  187|    100|            if (!allocator_)
  ------------------
  |  Branch (187:17): [True: 100, False: 0]
  ------------------
  188|    100|                ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
  ------------------
  |  |  712|    100|#define RAPIDJSON_NEW(TypeName) new TypeName
  ------------------
  189|    100|            newCapacity = initialCapacity_;
  190|    912|        } else {
  191|    912|            newCapacity = GetCapacity();
  192|    912|            newCapacity += (newCapacity + 1) / 2;
  193|    912|        }
  194|  1.01k|        size_t newSize = GetSize() + sizeof(T) * count;
  195|  1.01k|        if (newCapacity < newSize)
  ------------------
  |  Branch (195:13): [True: 10, False: 1.00k]
  ------------------
  196|     10|            newCapacity = newSize;
  197|       |
  198|  1.01k|        Resize(newCapacity);
  199|  1.01k|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE10PushUnsafeIcEEPT_m:
  129|  81.6M|    RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) {
  130|  81.6M|        RAPIDJSON_ASSERT(stackTop_);
  ------------------
  |  |  437|  81.6M|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (130:9): [True: 81.6M, False: 0]
  ------------------
  131|  81.6M|        RAPIDJSON_ASSERT(static_cast<std::ptrdiff_t>(sizeof(T) * count) <= (stackEnd_ - stackTop_));
  ------------------
  |  |  437|  81.6M|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (131:9): [True: 81.6M, False: 0]
  ------------------
  132|  81.6M|        T* ret = reinterpret_cast<T*>(stackTop_);
  133|  81.6M|        stackTop_ += sizeof(T) * count;
  134|  81.6M|        return ret;
  135|  81.6M|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE3PopIcEEPT_m:
  138|  12.0M|    T* Pop(size_t count) {
  139|  12.0M|        RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T));
  ------------------
  |  |  437|  12.0M|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (139:9): [True: 12.0M, False: 0]
  ------------------
  140|  12.0M|        stackTop_ -= count * sizeof(T);
  141|  12.0M|        return reinterpret_cast<T*>(stackTop_);
  142|  12.0M|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE3PopINS_13GenericMemberINS_4UTF8IcEENS_19MemoryPoolAllocatorIS2_EEEEEEPT_m:
  138|  30.1k|    T* Pop(size_t count) {
  139|  30.1k|        RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T));
  ------------------
  |  |  437|  30.1k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (139:9): [True: 30.1k, False: 0]
  ------------------
  140|  30.1k|        stackTop_ -= count * sizeof(T);
  141|  30.1k|        return reinterpret_cast<T*>(stackTop_);
  142|  30.1k|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE3TopINS_12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorIS2_EEEEEEPT_v:
  145|  49.3k|    T* Top() { 
  146|  49.3k|        RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
  ------------------
  |  |  437|  49.3k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (146:9): [True: 49.3k, False: 0]
  ------------------
  147|  49.3k|        return reinterpret_cast<T*>(stackTop_ - sizeof(T));
  148|  49.3k|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE5ClearEv:
   99|    208|    void Clear() { stackTop_ = stack_; }
_ZNK9rapidjson8internal5StackINS_12CrtAllocatorEE7GetSizeEv:
  178|  24.1M|    size_t GetSize() const { return static_cast<size_t>(stackTop_ - stack_); }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE3PopINS_12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorIS2_EEEEEEPT_m:
  138|  19.2k|    T* Pop(size_t count) {
  139|  19.2k|        RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T));
  ------------------
  |  |  437|  19.2k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (139:9): [True: 19.2k, False: 0]
  ------------------
  140|  19.2k|        stackTop_ -= count * sizeof(T);
  141|  19.2k|        return reinterpret_cast<T*>(stackTop_);
  142|  19.2k|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE11ShrinkToFitEv:
  101|    104|    void ShrinkToFit() { 
  102|    104|        if (Empty()) {
  ------------------
  |  Branch (102:13): [True: 104, False: 0]
  ------------------
  103|       |            // If the stack is empty, completely deallocate the memory.
  104|    104|            Allocator::Free(stack_); // NOLINT (+clang-analyzer-unix.Malloc)
  105|    104|            stack_ = 0;
  106|    104|            stackTop_ = 0;
  107|    104|            stackEnd_ = 0;
  108|    104|        }
  109|      0|        else
  110|      0|            Resize(GetSize());
  111|    104|    }
_ZNK9rapidjson8internal5StackINS_12CrtAllocatorEE5EmptyEv:
  177|  4.22M|    bool Empty() const { return stackTop_ == stack_; }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE3TopINS_6WriterINS_19GenericStringBufferINS_4UTF8IcEES2_EES8_S8_S2_Lj0EE5LevelEEEPT_v:
  145|  4.22M|    T* Top() { 
  146|  4.22M|        RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
  ------------------
  |  |  437|  4.22M|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (146:9): [True: 4.22M, False: 0]
  ------------------
  147|  4.22M|        return reinterpret_cast<T*>(stackTop_ - sizeof(T));
  148|  4.22M|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE4PushINS_6WriterINS_19GenericStringBufferINS_4UTF8IcEES2_EES8_S8_S2_Lj0EE5LevelEEEPT_m:
  123|  15.4k|    RAPIDJSON_FORCEINLINE T* Push(size_t count = 1) {
  124|  15.4k|        Reserve<T>(count);
  125|  15.4k|        return PushUnsafe<T>(count);
  126|  15.4k|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE7ReserveINS_6WriterINS_19GenericStringBufferINS_4UTF8IcEES2_EES8_S8_S2_Lj0EE5LevelEEEvm:
  116|  15.4k|    RAPIDJSON_FORCEINLINE void Reserve(size_t count = 1) {
  117|       |         // Expand the stack if needed
  118|  15.4k|        if (RAPIDJSON_UNLIKELY(static_cast<std::ptrdiff_t>(sizeof(T) * count) > (stackEnd_ - stackTop_)))
  ------------------
  |  |  505|  15.4k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 92, False: 15.4k]
  |  |  ------------------
  ------------------
  119|     92|            Expand<T>(count);
  120|  15.4k|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE6ExpandINS_6WriterINS_19GenericStringBufferINS_4UTF8IcEES2_EES8_S8_S2_Lj0EE5LevelEEEvm:
  183|     92|    void Expand(size_t count) {
  184|       |        // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.
  185|     92|        size_t newCapacity;
  186|     92|        if (stack_ == 0) {
  ------------------
  |  Branch (186:13): [True: 15, False: 77]
  ------------------
  187|     15|            if (!allocator_)
  ------------------
  |  Branch (187:17): [True: 15, False: 0]
  ------------------
  188|     15|                ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
  ------------------
  |  |  712|     15|#define RAPIDJSON_NEW(TypeName) new TypeName
  ------------------
  189|     15|            newCapacity = initialCapacity_;
  190|     77|        } else {
  191|     77|            newCapacity = GetCapacity();
  192|     77|            newCapacity += (newCapacity + 1) / 2;
  193|     77|        }
  194|     92|        size_t newSize = GetSize() + sizeof(T) * count;
  195|     92|        if (newCapacity < newSize)
  ------------------
  |  Branch (195:13): [True: 0, False: 92]
  ------------------
  196|      0|            newCapacity = newSize;
  197|       |
  198|     92|        Resize(newCapacity);
  199|     92|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE10PushUnsafeINS_6WriterINS_19GenericStringBufferINS_4UTF8IcEES2_EES8_S8_S2_Lj0EE5LevelEEEPT_m:
  129|  15.4k|    RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) {
  130|  15.4k|        RAPIDJSON_ASSERT(stackTop_);
  ------------------
  |  |  437|  15.4k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (130:9): [True: 15.4k, False: 0]
  ------------------
  131|  15.4k|        RAPIDJSON_ASSERT(static_cast<std::ptrdiff_t>(sizeof(T) * count) <= (stackEnd_ - stackTop_));
  ------------------
  |  |  437|  15.4k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (131:9): [True: 15.4k, False: 0]
  ------------------
  132|  15.4k|        T* ret = reinterpret_cast<T*>(stackTop_);
  133|  15.4k|        stackTop_ += sizeof(T) * count;
  134|  15.4k|        return ret;
  135|  15.4k|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE3PopINS_6WriterINS_19GenericStringBufferINS_4UTF8IcEES2_EES8_S8_S2_Lj0EE5LevelEEEPT_m:
  138|  15.4k|    T* Pop(size_t count) {
  139|  15.4k|        RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T));
  ------------------
  |  |  437|  15.4k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (139:9): [True: 15.4k, False: 0]
  ------------------
  140|  15.4k|        stackTop_ -= count * sizeof(T);
  141|  15.4k|        return reinterpret_cast<T*>(stackTop_);
  142|  15.4k|    }
_ZN9rapidjson8internal5StackINS_12CrtAllocatorEE6BottomIcEEPT_v:
  163|     44|    T* Bottom() { return reinterpret_cast<T*>(stack_); }

_ZN9rapidjson8internal21StrtodNormalPrecisionEdi:
   37|  30.7k|inline double StrtodNormalPrecision(double d, int p) {
   38|  30.7k|    if (p < -308) {
  ------------------
  |  Branch (38:9): [True: 852, False: 29.8k]
  ------------------
   39|       |        // Prevent expSum < -308, making Pow10(p) = 0
   40|    852|        d = FastPath(d, -308);
   41|    852|        d = FastPath(d, p + 308);
   42|    852|    }
   43|  29.8k|    else
   44|  29.8k|        d = FastPath(d, p);
   45|  30.7k|    return d;
   46|  30.7k|}
_ZN9rapidjson8internal8FastPathEdi:
   28|  48.9k|inline double FastPath(double significand, int exp) {
   29|  48.9k|    if (exp < -308)
  ------------------
  |  Branch (29:9): [True: 20, False: 48.9k]
  ------------------
   30|     20|        return 0.0;
   31|  48.9k|    else if (exp >= 0)
  ------------------
  |  Branch (31:14): [True: 14.8k, False: 34.0k]
  ------------------
   32|  14.8k|        return significand * internal::Pow10(exp);
   33|  34.0k|    else
   34|  34.0k|        return significand / internal::Pow10(-exp);
   35|  48.9k|}
_ZN9rapidjson8internal19StrtodFullPrecisionIcEEddiPKT_mmi:
  229|  21.2k|inline double StrtodFullPrecision(double d, int p, const Ch* decimals, size_t length, size_t decimalPosition, int exp) {
  230|  21.2k|    RAPIDJSON_ASSERT(d >= 0.0);
  ------------------
  |  |  437|  21.2k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (230:5): [True: 21.2k, False: 0]
  ------------------
  231|  21.2k|    RAPIDJSON_ASSERT(length >= 1);
  ------------------
  |  |  437|  21.2k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (231:5): [True: 21.2k, False: 0]
  ------------------
  232|       |
  233|  21.2k|    double result = 0.0;
  234|  21.2k|    if (StrtodFast(d, p, &result))
  ------------------
  |  Branch (234:9): [True: 17.4k, False: 3.85k]
  ------------------
  235|  17.4k|        return result;
  236|       |
  237|  3.85k|    RAPIDJSON_ASSERT(length <= INT_MAX);
  ------------------
  |  |  437|  3.85k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (237:5): [True: 3.85k, False: 0]
  ------------------
  238|  3.85k|    int dLen = static_cast<int>(length);
  239|       |
  240|  3.85k|    RAPIDJSON_ASSERT(length >= decimalPosition);
  ------------------
  |  |  437|  3.85k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (240:5): [True: 3.85k, False: 0]
  ------------------
  241|  3.85k|    RAPIDJSON_ASSERT(length - decimalPosition <= INT_MAX);
  ------------------
  |  |  437|  3.85k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (241:5): [True: 3.85k, False: 0]
  ------------------
  242|  3.85k|    int dExpAdjust = static_cast<int>(length - decimalPosition);
  243|       |
  244|  3.85k|    RAPIDJSON_ASSERT(exp >= INT_MIN + dExpAdjust);
  ------------------
  |  |  437|  3.85k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (244:5): [True: 3.85k, False: 0]
  ------------------
  245|  3.85k|    int dExp = exp - dExpAdjust;
  246|       |
  247|       |    // Make sure length+dExp does not overflow
  248|  3.85k|    RAPIDJSON_ASSERT(dExp <= INT_MAX - dLen);
  ------------------
  |  |  437|  3.85k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (248:5): [True: 3.85k, False: 0]
  ------------------
  249|       |
  250|       |    // Trim leading zeros
  251|  5.77k|    while (dLen > 0 && *decimals == '0') {
  ------------------
  |  Branch (251:12): [True: 5.77k, False: 4]
  |  Branch (251:24): [True: 1.91k, False: 3.85k]
  ------------------
  252|  1.91k|        dLen--;
  253|  1.91k|        decimals++;
  254|  1.91k|    }
  255|       |
  256|       |    // Trim trailing zeros
  257|  1.10M|    while (dLen > 0 && decimals[dLen - 1] == '0') {
  ------------------
  |  Branch (257:12): [True: 1.10M, False: 4]
  |  Branch (257:24): [True: 1.10M, False: 3.85k]
  ------------------
  258|  1.10M|        dLen--;
  259|  1.10M|        dExp++;
  260|  1.10M|    }
  261|       |
  262|  3.85k|    if (dLen == 0) { // Buffer only contains zeros.
  ------------------
  |  Branch (262:9): [True: 4, False: 3.85k]
  ------------------
  263|      4|        return 0.0;
  264|      4|    }
  265|       |
  266|       |    // Trim right-most digits
  267|  3.85k|    const int kMaxDecimalDigit = 767 + 1;
  268|  3.85k|    if (dLen > kMaxDecimalDigit) {
  ------------------
  |  Branch (268:9): [True: 10, False: 3.84k]
  ------------------
  269|     10|        dExp += dLen - kMaxDecimalDigit;
  270|     10|        dLen = kMaxDecimalDigit;
  271|     10|    }
  272|       |
  273|       |    // If too small, underflow to zero.
  274|       |    // Any x <= 10^-324 is interpreted as zero.
  275|  3.85k|    if (dLen + dExp <= -324)
  ------------------
  |  Branch (275:9): [True: 10, False: 3.84k]
  ------------------
  276|     10|        return 0.0;
  277|       |
  278|       |    // If too large, overflow to infinity.
  279|       |    // Any x >= 10^309 is interpreted as +infinity.
  280|  3.84k|    if (dLen + dExp > 309)
  ------------------
  |  Branch (280:9): [True: 3, False: 3.84k]
  ------------------
  281|      3|        return std::numeric_limits<double>::infinity();
  282|       |
  283|  3.84k|    if (StrtodDiyFp(decimals, dLen, dExp, &result))
  ------------------
  |  Branch (283:9): [True: 3.83k, False: 8]
  ------------------
  284|  3.83k|        return result;
  285|       |
  286|       |    // Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison
  287|      8|    return StrtodBigInteger(result, decimals, dLen, dExp);
  288|  3.84k|}
_ZN9rapidjson8internal10StrtodFastEdiPd:
  113|  21.2k|inline bool StrtodFast(double d, int p, double* result) {
  114|       |    // Use fast path for string-to-double conversion if possible
  115|       |    // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/
  116|  21.2k|    if (p > 22  && p < 22 + 16) {
  ------------------
  |  Branch (116:9): [True: 832, False: 20.4k]
  |  Branch (116:20): [True: 0, False: 832]
  ------------------
  117|       |        // Fast Path Cases In Disguise
  118|      0|        d *= internal::Pow10(p - 22);
  119|      0|        p = 22;
  120|      0|    }
  121|       |
  122|  21.2k|    if (p >= -22 && p <= 22 && d <= 9007199254740991.0) { // 2^53 - 1
  ------------------
  |  Branch (122:9): [True: 20.6k, False: 598]
  |  Branch (122:21): [True: 19.8k, False: 832]
  |  Branch (122:32): [True: 17.4k, False: 2.42k]
  ------------------
  123|  17.4k|        *result = FastPath(d, p);
  124|  17.4k|        return true;
  125|  17.4k|    }
  126|  3.85k|    else
  127|  3.85k|        return false;
  128|  21.2k|}
_ZN9rapidjson8internal11StrtodDiyFpIcEEbPKT_iiPd:
  132|  3.84k|inline bool StrtodDiyFp(const Ch* decimals, int dLen, int dExp, double* result) {
  133|  3.84k|    uint64_t significand = 0;
  134|  3.84k|    int i = 0;   // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999    
  135|  54.1k|    for (; i < dLen; i++) {
  ------------------
  |  Branch (135:12): [True: 52.7k, False: 1.42k]
  ------------------
  136|  52.7k|        if (significand  >  RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) ||
  ------------------
  |  |  320|   105k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  |  Branch (136:13): [True: 2.41k, False: 50.3k]
  ------------------
  137|  50.3k|            (significand == RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] >= Ch('5')))
  ------------------
  |  |  320|   100k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  |  Branch (137:14): [True: 0, False: 50.3k]
  |  Branch (137:76): [True: 0, False: 0]
  ------------------
  138|  2.41k|            break;
  139|  50.3k|        significand = significand * 10u + static_cast<unsigned>(decimals[i] - Ch('0'));
  140|  50.3k|    }
  141|       |    
  142|  3.84k|    if (i < dLen && decimals[i] >= Ch('5')) // Rounding
  ------------------
  |  Branch (142:9): [True: 2.41k, False: 1.42k]
  |  Branch (142:21): [True: 526, False: 1.88k]
  ------------------
  143|    526|        significand++;
  144|       |
  145|  3.84k|    int remaining = dLen - i;
  146|  3.84k|    const int kUlpShift = 3;
  147|  3.84k|    const int kUlp = 1 << kUlpShift;
  148|  3.84k|    int64_t error = (remaining == 0) ? 0 : kUlp / 2;
  ------------------
  |  Branch (148:21): [True: 1.42k, False: 2.41k]
  ------------------
  149|       |
  150|  3.84k|    DiyFp v(significand, 0);
  151|  3.84k|    v = v.Normalize();
  152|  3.84k|    error <<= -v.e;
  153|       |
  154|  3.84k|    dExp += remaining;
  155|       |
  156|  3.84k|    int actualExp;
  157|  3.84k|    DiyFp cachedPower = GetCachedPower10(dExp, &actualExp);
  158|  3.84k|    if (actualExp != dExp) {
  ------------------
  |  Branch (158:9): [True: 3.24k, False: 596]
  ------------------
  159|  3.24k|        static const DiyFp kPow10[] = {
  160|  3.24k|            DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 0x00000000), -60),  // 10^1
  ------------------
  |  |  320|  3.24k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  161|  3.24k|            DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 0x00000000), -57),  // 10^2
  ------------------
  |  |  320|  3.24k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  162|  3.24k|            DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 0x00000000), -54),  // 10^3
  ------------------
  |  |  320|  3.24k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  163|  3.24k|            DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), -50),  // 10^4
  ------------------
  |  |  320|  3.24k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  164|  3.24k|            DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 0x00000000), -47),  // 10^5
  ------------------
  |  |  320|  3.24k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  165|  3.24k|            DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 0x00000000), -44),  // 10^6
  ------------------
  |  |  320|  3.24k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  166|  3.24k|            DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 0x00000000), -40)   // 10^7
  ------------------
  |  |  320|  3.24k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  167|  3.24k|        };
  168|  3.24k|        int adjustment = dExp - actualExp;
  169|  3.24k|        RAPIDJSON_ASSERT(adjustment >= 1 && adjustment < 8);
  ------------------
  |  |  437|  3.24k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (169:9): [True: 3.24k, False: 0]
  |  Branch (169:9): [True: 3.24k, False: 0]
  |  Branch (169:9): [True: 3.24k, False: 0]
  ------------------
  170|  3.24k|        v = v * kPow10[adjustment - 1];
  171|  3.24k|        if (dLen + adjustment > 19) // has more digits than decimal digits in 64-bit
  ------------------
  |  Branch (171:13): [True: 2.40k, False: 846]
  ------------------
  172|  2.40k|            error += kUlp / 2;
  173|  3.24k|    }
  174|       |
  175|  3.84k|    v = v * cachedPower;
  176|       |
  177|  3.84k|    error += kUlp + (error == 0 ? 0 : 1);
  ------------------
  |  Branch (177:22): [True: 1.37k, False: 2.46k]
  ------------------
  178|       |
  179|  3.84k|    const int oldExp = v.e;
  180|  3.84k|    v = v.Normalize();
  181|  3.84k|    error <<= oldExp - v.e;
  182|       |
  183|  3.84k|    const int effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e);
  184|  3.84k|    int precisionSize = 64 - effectiveSignificandSize;
  185|  3.84k|    if (precisionSize + kUlpShift >= 64) {
  ------------------
  |  Branch (185:9): [True: 289, False: 3.55k]
  ------------------
  186|    289|        int scaleExp = (precisionSize + kUlpShift) - 63;
  187|    289|        v.f >>= scaleExp;
  188|    289|        v.e += scaleExp; 
  189|    289|        error = (error >> scaleExp) + 1 + kUlp;
  190|    289|        precisionSize -= scaleExp;
  191|    289|    }
  192|       |
  193|  3.84k|    DiyFp rounded(v.f >> precisionSize, v.e + precisionSize);
  194|  3.84k|    const uint64_t precisionBits = (v.f & ((uint64_t(1) << precisionSize) - 1)) * kUlp;
  195|  3.84k|    const uint64_t halfWay = (uint64_t(1) << (precisionSize - 1)) * kUlp;
  196|  3.84k|    if (precisionBits >= halfWay + static_cast<unsigned>(error)) {
  ------------------
  |  Branch (196:9): [True: 1.25k, False: 2.59k]
  ------------------
  197|  1.25k|        rounded.f++;
  198|  1.25k|        if (rounded.f & (DiyFp::kDpHiddenBit << 1)) { // rounding overflows mantissa (issue #340)
  ------------------
  |  Branch (198:13): [True: 0, False: 1.25k]
  ------------------
  199|      0|            rounded.f >>= 1;
  200|      0|            rounded.e++;
  201|      0|        }
  202|  1.25k|    }
  203|       |
  204|  3.84k|    *result = rounded.ToDouble();
  205|       |
  206|  3.84k|    return halfWay - static_cast<unsigned>(error) >= precisionBits || precisionBits >= halfWay + static_cast<unsigned>(error);
  ------------------
  |  Branch (206:12): [True: 2.58k, False: 1.26k]
  |  Branch (206:71): [True: 1.25k, False: 8]
  ------------------
  207|  3.84k|}
_ZN9rapidjson8internal16StrtodBigIntegerIcEEddPKT_ii:
  210|      8|inline double StrtodBigInteger(double approx, const Ch* decimals, int dLen, int dExp) {
  211|      8|    RAPIDJSON_ASSERT(dLen >= 0);
  ------------------
  |  |  437|      8|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (211:5): [True: 8, False: 0]
  ------------------
  212|      8|    const BigInteger dInt(decimals, static_cast<unsigned>(dLen));
  213|      8|    Double a(approx);
  214|      8|    int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp);
  215|      8|    if (cmp < 0)
  ------------------
  |  Branch (215:9): [True: 1, False: 7]
  ------------------
  216|      1|        return a.Value();  // within half ULP
  217|      7|    else if (cmp == 0) {
  ------------------
  |  Branch (217:14): [True: 7, False: 0]
  ------------------
  218|       |        // Round towards even
  219|      7|        if (a.Significand() & 1)
  ------------------
  |  Branch (219:13): [True: 0, False: 7]
  ------------------
  220|      0|            return a.NextPositiveDouble();
  221|      7|        else
  222|      7|            return a.Value();
  223|      7|    }
  224|      0|    else // adjustment
  225|      0|        return a.NextPositiveDouble();
  226|      8|}
_ZN9rapidjson8internal18CheckWithinHalfULPEdRKNS0_10BigIntegerEi:
   56|      8|inline int CheckWithinHalfULP(double b, const BigInteger& d, int dExp) {
   57|      8|    const Double db(b);
   58|      8|    const uint64_t bInt = db.IntegerSignificand();
   59|      8|    const int bExp = db.IntegerExponent();
   60|      8|    const int hExp = bExp - 1;
   61|       |
   62|      8|    int dS_Exp2 = 0, dS_Exp5 = 0, bS_Exp2 = 0, bS_Exp5 = 0, hS_Exp2 = 0, hS_Exp5 = 0;
   63|       |
   64|       |    // Adjust for decimal exponent
   65|      8|    if (dExp >= 0) {
  ------------------
  |  Branch (65:9): [True: 0, False: 8]
  ------------------
   66|      0|        dS_Exp2 += dExp;
   67|      0|        dS_Exp5 += dExp;
   68|      0|    }
   69|      8|    else {
   70|      8|        bS_Exp2 -= dExp;
   71|      8|        bS_Exp5 -= dExp;
   72|      8|        hS_Exp2 -= dExp;
   73|      8|        hS_Exp5 -= dExp;
   74|      8|    }
   75|       |
   76|       |    // Adjust for binary exponent
   77|      8|    if (bExp >= 0)
  ------------------
  |  Branch (77:9): [True: 8, False: 0]
  ------------------
   78|      8|        bS_Exp2 += bExp;
   79|      0|    else {
   80|      0|        dS_Exp2 -= bExp;
   81|      0|        hS_Exp2 -= bExp;
   82|      0|    }
   83|       |
   84|       |    // Adjust for half ulp exponent
   85|      8|    if (hExp >= 0)
  ------------------
  |  Branch (85:9): [True: 1, False: 7]
  ------------------
   86|      1|        hS_Exp2 += hExp;
   87|      7|    else {
   88|      7|        dS_Exp2 -= hExp;
   89|      7|        bS_Exp2 -= hExp;
   90|      7|    }
   91|       |
   92|       |    // Remove common power of two factor from all three scaled values
   93|      8|    int common_Exp2 = Min3(dS_Exp2, bS_Exp2, hS_Exp2);
   94|      8|    dS_Exp2 -= common_Exp2;
   95|      8|    bS_Exp2 -= common_Exp2;
   96|      8|    hS_Exp2 -= common_Exp2;
   97|       |
   98|      8|    BigInteger dS = d;
   99|      8|    dS.MultiplyPow5(static_cast<unsigned>(dS_Exp5)) <<= static_cast<unsigned>(dS_Exp2);
  100|       |
  101|      8|    BigInteger bS(bInt);
  102|      8|    bS.MultiplyPow5(static_cast<unsigned>(bS_Exp5)) <<= static_cast<unsigned>(bS_Exp2);
  103|       |
  104|      8|    BigInteger hS(1);
  105|      8|    hS.MultiplyPow5(static_cast<unsigned>(hS_Exp5)) <<= static_cast<unsigned>(hS_Exp2);
  106|       |
  107|      8|    BigInteger delta(0);
  108|      8|    dS.Difference(bS, &delta);
  109|       |
  110|      8|    return delta.Compare(hS);
  111|      8|}
_ZN9rapidjson8internal4Min3IiEET_S2_S2_S2_:
   49|      8|inline T Min3(T a, T b, T c) {
   50|      8|    T m = a;
   51|      8|    if (m > b) m = b;
  ------------------
  |  Branch (51:9): [True: 0, False: 8]
  ------------------
   52|      8|    if (m > c) m = c;
  ------------------
  |  Branch (52:9): [True: 0, False: 8]
  ------------------
   53|      8|    return m;
   54|      8|}

_ZN9rapidjson12PrettyWriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EEC2ERS5_PS4_m:
   59|     44|        Base(os, allocator, levelDepth), indentChar_(' '), indentCharCount_(4), formatOptions_(kFormatDefault) {}
_ZN9rapidjson12PrettyWriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE4NullEv:
   95|      9|    bool Null()                 { PrettyPrefix(kNullType);   return Base::EndValue(Base::WriteNull()); }
_ZN9rapidjson12PrettyWriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE12PrettyPrefixENS_4TypeE:
  208|  4.20M|    void PrettyPrefix(Type type) {
  209|  4.20M|        (void)type;
  210|  4.20M|        if (Base::level_stack_.GetSize() != 0) { // this value is not at root
  ------------------
  |  Branch (210:13): [True: 4.20M, False: 44]
  ------------------
  211|  4.20M|            typename Base::Level* level = Base::level_stack_.template Top<typename Base::Level>();
  212|       |
  213|  4.20M|            if (level->inArray) {
  ------------------
  |  Branch (213:17): [True: 2.73M, False: 1.47M]
  ------------------
  214|  2.73M|                if (level->valueCount > 0) {
  ------------------
  |  Branch (214:21): [True: 2.71M, False: 15.4k]
  ------------------
  215|  2.71M|                    Base::os_->Put(','); // add comma if it is not the first element in array
  216|  2.71M|                    if (formatOptions_ & kFormatSingleLineArray)
  ------------------
  |  Branch (216:25): [True: 0, False: 2.71M]
  ------------------
  217|      0|                        Base::os_->Put(' ');
  218|  2.71M|                }
  219|       |
  220|  2.73M|                if (!(formatOptions_ & kFormatSingleLineArray)) {
  ------------------
  |  Branch (220:21): [True: 2.73M, False: 0]
  ------------------
  221|  2.73M|                    Base::os_->Put('\n');
  222|  2.73M|                    WriteIndent();
  223|  2.73M|                }
  224|  2.73M|            }
  225|  1.47M|            else {  // in object
  226|  1.47M|                if (level->valueCount > 0) {
  ------------------
  |  Branch (226:21): [True: 1.47M, False: 74]
  ------------------
  227|  1.47M|                    if (level->valueCount % 2 == 0) {
  ------------------
  |  Branch (227:25): [True: 738k, False: 738k]
  ------------------
  228|   738k|                        Base::os_->Put(',');
  229|   738k|                        Base::os_->Put('\n');
  230|   738k|                    }
  231|   738k|                    else {
  232|   738k|                        Base::os_->Put(':');
  233|   738k|                        Base::os_->Put(' ');
  234|   738k|                    }
  235|  1.47M|                }
  236|     74|                else
  237|     74|                    Base::os_->Put('\n');
  238|       |
  239|  1.47M|                if (level->valueCount % 2 == 0)
  ------------------
  |  Branch (239:21): [True: 738k, False: 738k]
  ------------------
  240|   738k|                    WriteIndent();
  241|  1.47M|            }
  242|  4.20M|            if (!level->inArray && level->valueCount % 2 == 0)
  ------------------
  |  Branch (242:17): [True: 1.47M, False: 2.73M]
  |  Branch (242:36): [True: 738k, False: 738k]
  ------------------
  243|  4.20M|                RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
  ------------------
  |  |  437|  4.20M|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (243:17): [True: 738k, False: 0]
  ------------------
  244|  4.20M|            level->valueCount++;
  245|  4.20M|        }
  246|     44|        else {
  247|     44|            RAPIDJSON_ASSERT(!Base::hasRoot_);  // Should only has one and only one root.
  ------------------
  |  |  437|     44|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (247:13): [True: 44, False: 0]
  ------------------
  248|     44|            Base::hasRoot_ = true;
  249|     44|        }
  250|  4.20M|    }
_ZN9rapidjson12PrettyWriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE11WriteIndentEv:
  252|  3.48M|    void WriteIndent()  {
  253|  3.48M|        size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_;
  254|  3.48M|        PutN(*Base::os_, static_cast<typename OutputStream::Ch>(indentChar_), count);
  255|  3.48M|    }
_ZN9rapidjson12PrettyWriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE4BoolEb:
   96|    311|    bool Bool(bool b)           { PrettyPrefix(b ? kTrueType : kFalseType); return Base::EndValue(Base::WriteBool(b)); }
  ------------------
  |  Branch (96:48): [True: 11, False: 300]
  ------------------
_ZN9rapidjson12PrettyWriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE11StartObjectEv:
  123|     74|    bool StartObject() {
  124|     74|        PrettyPrefix(kObjectType);
  125|     74|        new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(false);
  126|     74|        return Base::WriteStartObject();
  127|     74|    }
_ZN9rapidjson12PrettyWriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE3KeyEPKcjb:
  129|   738k|    bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); }
_ZN9rapidjson12PrettyWriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE9EndObjectEj:
  137|     74|    bool EndObject(SizeType memberCount = 0) {
  138|     74|        (void)memberCount;
  139|     74|        RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level)); // not inside an Object
  ------------------
  |  |  437|     74|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (139:9): [True: 74, False: 0]
  ------------------
  140|     74|        RAPIDJSON_ASSERT(!Base::level_stack_.template Top<typename Base::Level>()->inArray); // currently inside an Array, not Object
  ------------------
  |  |  437|     74|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (140:9): [True: 74, False: 0]
  ------------------
  141|     74|        RAPIDJSON_ASSERT(0 == Base::level_stack_.template Top<typename Base::Level>()->valueCount % 2); // Object has a Key without a Value
  ------------------
  |  |  437|     74|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (141:9): [True: 74, False: 0]
  ------------------
  142|       |       
  143|     74|        bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
  144|       |
  145|     74|        if (!empty) {
  ------------------
  |  Branch (145:13): [True: 74, False: 0]
  ------------------
  146|     74|            Base::os_->Put('\n');
  147|     74|            WriteIndent();
  148|     74|        }
  149|     74|        bool ret = Base::EndValue(Base::WriteEndObject());
  150|     74|        (void)ret;
  151|     74|        RAPIDJSON_ASSERT(ret == true);
  ------------------
  |  |  437|     74|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (151:9): [True: 74, False: 0]
  ------------------
  152|     74|        if (Base::level_stack_.Empty()) // end of json text
  ------------------
  |  Branch (152:13): [True: 4, False: 70]
  ------------------
  153|      4|            Base::Flush();
  154|     74|        return true;
  155|     74|    }
_ZN9rapidjson12PrettyWriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE10StartArrayEv:
  157|  15.4k|    bool StartArray() {
  158|  15.4k|        PrettyPrefix(kArrayType);
  159|  15.4k|        new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(true);
  160|  15.4k|        return Base::WriteStartArray();
  161|  15.4k|    }
_ZN9rapidjson12PrettyWriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE8EndArrayEj:
  163|  15.4k|    bool EndArray(SizeType memberCount = 0) {
  164|  15.4k|        (void)memberCount;
  165|  15.4k|        RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
  ------------------
  |  |  437|  15.4k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (165:9): [True: 15.4k, False: 0]
  ------------------
  166|  15.4k|        RAPIDJSON_ASSERT(Base::level_stack_.template Top<typename Base::Level>()->inArray);
  ------------------
  |  |  437|  15.4k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (166:9): [True: 15.4k, False: 0]
  ------------------
  167|  15.4k|        bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
  168|       |
  169|  15.4k|        if (!empty && !(formatOptions_ & kFormatSingleLineArray)) {
  ------------------
  |  Branch (169:13): [True: 15.4k, False: 14]
  |  Branch (169:23): [True: 15.4k, False: 0]
  ------------------
  170|  15.4k|            Base::os_->Put('\n');
  171|  15.4k|            WriteIndent();
  172|  15.4k|        }
  173|  15.4k|        bool ret = Base::EndValue(Base::WriteEndArray());
  174|  15.4k|        (void)ret;
  175|  15.4k|        RAPIDJSON_ASSERT(ret == true);
  ------------------
  |  |  437|  15.4k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (175:9): [True: 15.4k, False: 0]
  ------------------
  176|  15.4k|        if (Base::level_stack_.Empty()) // end of json text
  ------------------
  |  Branch (176:13): [True: 11, False: 15.4k]
  ------------------
  177|     11|            Base::Flush();
  178|  15.4k|        return true;
  179|  15.4k|    }
_ZN9rapidjson12PrettyWriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE6StringEPKcjb:
  110|  2.48M|    bool String(const Ch* str, SizeType length, bool copy = false) {
  111|  2.48M|        RAPIDJSON_ASSERT(str != 0);
  ------------------
  |  |  437|  2.48M|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (111:9): [True: 2.48M, False: 0]
  ------------------
  112|  2.48M|        (void)copy;
  113|  2.48M|        PrettyPrefix(kStringType);
  114|  2.48M|        return Base::EndValue(Base::WriteString(str, length));
  115|  2.48M|    }
_ZN9rapidjson12PrettyWriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE6DoubleEd:
  101|  7.71k|    bool Double(double d)       { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteDouble(d)); }
_ZN9rapidjson12PrettyWriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE3IntEi:
   97|  1.68M|    bool Int(int i)             { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt(i)); }
_ZN9rapidjson12PrettyWriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE4UintEj:
   98|      6|    bool Uint(unsigned u)       { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint(u)); }
_ZN9rapidjson12PrettyWriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE5Int64El:
   99|  5.90k|    bool Int64(int64_t i64)     { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt64(i64)); }
_ZN9rapidjson12PrettyWriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE6Uint64Em:
  100|     74|    bool Uint64(uint64_t u64)   { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint64(u64));  }

_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEEC2EPS3_m:
  548|    104|        stack_(stackAllocator, stackCapacity), parseResult_(), state_(IterativeParsingStartState) {}
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE5ParseILj0ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEENS_11ParseResultERT0_RT1_:
  559|     26|    ParseResult Parse(InputStream& is, Handler& handler) {
  560|     26|        if (parseFlags & kParseIterativeFlag)
  ------------------
  |  Branch (560:13): [Folded, False: 26]
  ------------------
  561|      0|            return IterativeParse<parseFlags>(is, handler);
  562|       |
  563|     26|        parseResult_.Clear();
  564|       |
  565|     26|        ClearStackOnExit scope(*this);
  566|       |
  567|     26|        SkipWhitespaceAndComments<parseFlags>(is);
  568|     26|        RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|     26|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|     26|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|     26|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|     26|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 0, False: 26]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|     26|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|     26|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|     26|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 26]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  569|       |
  570|     26|        if (RAPIDJSON_UNLIKELY(is.Peek() == '\0')) {
  ------------------
  |  |  505|     26|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 1, False: 25]
  |  |  ------------------
  ------------------
  571|      1|            RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentEmpty, is.Tell());
  ------------------
  |  |  101|      1|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  102|      1|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  ------------------
  |  |  |  |  437|      1|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  ------------------
  |  |  103|      1|    SetParseError(parseErrorCode, offset); \
  |  |  104|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (571:13): [True: 1, False: 0]
  ------------------
  572|      1|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|      2|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|      2|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|      1|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 1, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      2|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  573|      1|        }
  574|     25|        else {
  575|     25|            ParseValue<parseFlags>(is, handler);
  576|     25|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|     25|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|     25|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|     25|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|     25|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 15, False: 10]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|     25|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|     25|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|     25|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 10]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  577|       |
  578|     10|            if (!(parseFlags & kParseStopWhenDoneFlag)) {
  ------------------
  |  Branch (578:17): [True: 10, Folded]
  ------------------
  579|     10|                SkipWhitespaceAndComments<parseFlags>(is);
  580|     10|                RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|     10|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|     10|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|     10|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|     10|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 0, False: 10]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|     10|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|     10|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|     10|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 10]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  581|       |
  582|     10|                if (RAPIDJSON_UNLIKELY(is.Peek() != '\0')) {
  ------------------
  |  |  505|     10|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 1, False: 9]
  |  |  ------------------
  ------------------
  583|      1|                    RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentRootNotSingular, is.Tell());
  ------------------
  |  |  101|      1|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  102|      1|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  ------------------
  |  |  |  |  437|      1|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  ------------------
  |  |  103|      1|    SetParseError(parseErrorCode, offset); \
  |  |  104|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (583:21): [True: 1, False: 0]
  ------------------
  584|      1|                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|      2|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|      2|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|      1|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 1, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      2|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  585|      1|                }
  586|     10|            }
  587|     10|        }
  588|       |
  589|      9|        return parseResult_;
  590|     26|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE16ClearStackOnExitC2ERS4_:
  702|    104|        explicit ClearStackOnExit(GenericReader& r) : r_(r) {}
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE25SkipWhitespaceAndCommentsILj0ENS_19GenericStringStreamIS2_EEEEvRT0_:
  711|  3.95M|    void SkipWhitespaceAndComments(InputStream& is) {
  712|  3.95M|        SkipWhitespace(is);
  713|       |
  714|  3.95M|        if (parseFlags & kParseCommentsFlag) {
  ------------------
  |  Branch (714:13): [Folded, False: 3.95M]
  ------------------
  715|      0|            while (RAPIDJSON_UNLIKELY(Consume(is, '/'))) {
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  716|      0|                if (Consume(is, '*')) {
  ------------------
  |  Branch (716:21): [True: 0, False: 0]
  ------------------
  717|      0|                    while (true) {
  ------------------
  |  Branch (717:28): [True: 0, Folded]
  ------------------
  718|      0|                        if (RAPIDJSON_UNLIKELY(is.Peek() == '\0'))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  719|      0|                            RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (719:29): [True: 0, False: 0]
  ------------------
  720|      0|                        else if (Consume(is, '*')) {
  ------------------
  |  Branch (720:34): [True: 0, False: 0]
  ------------------
  721|      0|                            if (Consume(is, '/'))
  ------------------
  |  Branch (721:33): [True: 0, False: 0]
  ------------------
  722|      0|                                break;
  723|      0|                        }
  724|      0|                        else
  725|      0|                            is.Take();
  726|      0|                    }
  727|      0|                }
  728|      0|                else if (RAPIDJSON_LIKELY(Consume(is, '/')))
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  729|      0|                    while (is.Peek() != '\0' && is.Take() != '\n') {}
  ------------------
  |  Branch (729:28): [True: 0, False: 0]
  |  Branch (729:49): [True: 0, False: 0]
  ------------------
  730|      0|                else
  731|      0|                    RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (731:21): [True: 0, False: 0]
  ------------------
  732|       |
  733|      0|                SkipWhitespace(is);
  734|      0|            }
  735|      0|        }
  736|  3.95M|    }
_ZN9rapidjson14SkipWhitespaceINS_19GenericStringStreamINS_4UTF8IcEEEEEEvRT_:
  266|  21.5M|void SkipWhitespace(InputStream& is) {
  267|  21.5M|    internal::StreamLocalCopy<InputStream> copy(is);
  268|  21.5M|    InputStream& s(copy.s);
  269|       |
  270|  21.5M|    typename InputStream::Ch c;
  271|  21.5M|    while ((c = s.Peek()) == ' ' || c == '\n' || c == '\r' || c == '\t')
  ------------------
  |  Branch (271:12): [True: 45, False: 21.5M]
  |  Branch (271:37): [True: 0, False: 21.5M]
  |  Branch (271:50): [True: 136, False: 21.5M]
  |  Branch (271:63): [True: 15.0k, False: 21.5M]
  ------------------
  272|  15.2k|        s.Take();
  273|  21.5M|}
_ZN9rapidjson8internal15StreamLocalCopyINS_19GenericStringStreamINS_4UTF8IcEEEELi1EEC2ERS5_:
  233|  32.3M|    StreamLocalCopy(Stream& original) : s(original), original_(original) {}
_ZN9rapidjson8internal15StreamLocalCopyINS_19GenericStringStreamINS_4UTF8IcEEEELi1EED2Ev:
  234|  32.3M|    ~StreamLocalCopy() { original_ = s; }
_ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13HasParseErrorEv:
  682|  33.1M|    bool HasParseError() const { return parseResult_.IsError(); }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13SetParseErrorENS_14ParseErrorCodeEm:
  691|     60|    void SetParseError(ParseErrorCode code, size_t offset) { parseResult_.Set(code, offset); }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE10ParseValueILj0ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
 1752|  1.79M|    void ParseValue(InputStream& is, Handler& handler) {
 1753|  1.79M|        switch (is.Peek()) {
 1754|     34|            case 'n': ParseNull  <parseFlags>(is, handler); break;
  ------------------
  |  Branch (1754:13): [True: 34, False: 1.79M]
  ------------------
 1755|      0|            case 't': ParseTrue  <parseFlags>(is, handler); break;
  ------------------
  |  Branch (1755:13): [True: 0, False: 1.79M]
  ------------------
 1756|    202|            case 'f': ParseFalse <parseFlags>(is, handler); break;
  ------------------
  |  Branch (1756:13): [True: 202, False: 1.79M]
  ------------------
 1757|      6|            case '"': ParseString<parseFlags>(is, handler); break;
  ------------------
  |  Branch (1757:13): [True: 6, False: 1.79M]
  ------------------
 1758|  7.53k|            case '{': ParseObject<parseFlags>(is, handler); break;
  ------------------
  |  Branch (1758:13): [True: 7.53k, False: 1.78M]
  ------------------
 1759|  2.88k|            case '[': ParseArray <parseFlags>(is, handler); break;
  ------------------
  |  Branch (1759:13): [True: 2.88k, False: 1.78M]
  ------------------
 1760|  1.78M|            default :
  ------------------
  |  Branch (1760:13): [True: 1.78M, False: 10.6k]
  ------------------
 1761|  1.78M|                      ParseNumber<parseFlags>(is, handler);
 1762|  1.78M|                      break;
 1763|       |
 1764|  1.79M|        }
 1765|  1.79M|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE9ParseNullILj0ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  856|     34|    void ParseNull(InputStream& is, Handler& handler) {
  857|     34|        RAPIDJSON_ASSERT(is.Peek() == 'n');
  ------------------
  |  |  437|     34|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (857:9): [True: 34, False: 0]
  ------------------
  858|     34|        is.Take();
  859|       |
  860|     34|        if (RAPIDJSON_LIKELY(Consume(is, 'u') && Consume(is, 'l') && Consume(is, 'l'))) {
  ------------------
  |  |  492|    136|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 34, False: 0]
  |  |  |  Branch (492:49): [True: 34, False: 0]
  |  |  |  Branch (492:49): [True: 34, False: 0]
  |  |  |  Branch (492:49): [True: 34, False: 0]
  |  |  ------------------
  ------------------
  861|     34|            if (RAPIDJSON_UNLIKELY(!handler.Null()))
  ------------------
  |  |  505|     34|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 34]
  |  |  ------------------
  ------------------
  862|     34|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (862:17): [True: 0, False: 0]
  ------------------
  863|     34|        }
  864|      0|        else
  865|       |            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (865:13): [True: 0, False: 0]
  ------------------
  866|     34|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE7ConsumeINS_19GenericStringStreamIS2_EEEEbRT_NS8_2ChE:
  895|  14.0M|    RAPIDJSON_FORCEINLINE static bool Consume(InputStream& is, typename InputStream::Ch expect) {
  896|  14.0M|        if (RAPIDJSON_LIKELY(is.Peek() == expect)) {
  ------------------
  |  |  492|  14.0M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 10.0M, False: 4.01M]
  |  |  ------------------
  ------------------
  897|  10.0M|            is.Take();
  898|  10.0M|            return true;
  899|  10.0M|        }
  900|  4.01M|        else
  901|  4.01M|            return false;
  902|  14.0M|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE10ParseFalseILj0ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  882|    202|    void ParseFalse(InputStream& is, Handler& handler) {
  883|    202|        RAPIDJSON_ASSERT(is.Peek() == 'f');
  ------------------
  |  |  437|    202|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (883:9): [True: 202, False: 0]
  ------------------
  884|    202|        is.Take();
  885|       |
  886|    202|        if (RAPIDJSON_LIKELY(Consume(is, 'a') && Consume(is, 'l') && Consume(is, 's') && Consume(is, 'e'))) {
  ------------------
  |  |  492|  1.21k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 202, False: 0]
  |  |  |  Branch (492:49): [True: 202, False: 0]
  |  |  |  Branch (492:49): [True: 202, False: 0]
  |  |  |  Branch (492:49): [True: 202, False: 0]
  |  |  |  Branch (492:49): [True: 202, False: 0]
  |  |  ------------------
  ------------------
  887|    202|            if (RAPIDJSON_UNLIKELY(!handler.Bool(false)))
  ------------------
  |  |  505|    202|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 202]
  |  |  ------------------
  ------------------
  888|    202|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (888:17): [True: 0, False: 0]
  ------------------
  889|    202|        }
  890|      0|        else
  891|       |            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (891:13): [True: 0, False: 0]
  ------------------
  892|    202|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE11ParseStringILj0ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_b:
  959|   182k|    void ParseString(InputStream& is, Handler& handler, bool isKey = false) {
  960|   182k|        internal::StreamLocalCopy<InputStream> copy(is);
  961|   182k|        InputStream& s(copy.s);
  962|       |
  963|   182k|        RAPIDJSON_ASSERT(s.Peek() == '\"');
  ------------------
  |  |  437|   182k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (963:9): [True: 182k, False: 0]
  ------------------
  964|   182k|        s.Take();  // Skip '\"'
  965|       |
  966|   182k|        bool success = false;
  967|   182k|        if (parseFlags & kParseInsituFlag) {
  ------------------
  |  Branch (967:13): [Folded, False: 182k]
  ------------------
  968|      0|            typename InputStream::Ch *head = s.PutBegin();
  969|      0|            ParseStringToStream<parseFlags, SourceEncoding, SourceEncoding>(s, s);
  970|      0|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  971|      0|            size_t length = s.PutEnd(head) - 1;
  972|      0|            RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
  ------------------
  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (972:13): [True: 0, False: 0]
  ------------------
  973|      0|            const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
  974|      0|            success = (isKey ? handler.Key(str, SizeType(length), false) : handler.String(str, SizeType(length), false));
  ------------------
  |  Branch (974:24): [True: 0, False: 0]
  ------------------
  975|      0|        }
  976|   182k|        else {
  977|   182k|            StackStream<typename TargetEncoding::Ch> stackStream(stack_);
  978|   182k|            ParseStringToStream<parseFlags, SourceEncoding, TargetEncoding>(s, stackStream);
  979|   182k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   182k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   182k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   182k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   182k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   182k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   182k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   182k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  980|   182k|            SizeType length = static_cast<SizeType>(stackStream.Length()) - 1;
  981|   182k|            const typename TargetEncoding::Ch* const str = stackStream.Pop();
  982|   182k|            success = (isKey ? handler.Key(str, length, true) : handler.String(str, length, true));
  ------------------
  |  Branch (982:24): [True: 182k, False: 6]
  ------------------
  983|   182k|        }
  984|   182k|        if (RAPIDJSON_UNLIKELY(!success))
  ------------------
  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 182k]
  |  |  ------------------
  ------------------
  985|       |            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (985:13): [True: 0, False: 0]
  ------------------
  986|   182k|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE11StackStreamIcEC2ERNS_8internal5StackIS3_EE:
  932|  10.3M|        StackStream(internal::Stack<StackAllocator>& stack) : stack_(stack), length_(0) {}
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE19ParseStringToStreamILj0ES2_S2_NS_19GenericStringStreamIS2_EENS4_11StackStreamIcEEEEvRT2_RT3_:
  991|   182k|    RAPIDJSON_FORCEINLINE void ParseStringToStream(InputStream& is, OutputStream& os) {
  992|       |//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  994|   182k|        static const char escape[256] = {
  995|   182k|            Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '/',
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '/',
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
  996|   182k|            Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
  997|   182k|            0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0,
  998|   182k|            0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  999|   182k|            Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
 1000|   182k|        };
 1001|   182k|#undef Z16
 1002|       |//!@endcond
 1003|       |
 1004|   187k|        for (;;) {
 1005|       |            // Scan and copy string before "\\\"" or < 0x20. This is an optional optimzation.
 1006|   187k|            if (!(parseFlags & kParseValidateEncodingFlag))
  ------------------
  |  Branch (1006:17): [True: 187k, Folded]
  ------------------
 1007|   187k|                ScanCopyUnescapedString(is, os);
 1008|       |
 1009|   187k|            Ch c = is.Peek();
 1010|   187k|            if (RAPIDJSON_UNLIKELY(c == '\\')) {    // Escape
  ------------------
  |  |  505|   187k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 1, False: 187k]
  |  |  ------------------
  ------------------
 1011|      1|                size_t escapeOffset = is.Tell();    // For invalid escaping, report the initial '\\' as error offset
 1012|      1|                is.Take();
 1013|      1|                Ch e = is.Peek();
 1014|      1|                if ((sizeof(Ch) == 1 || unsigned(e) < 256) && RAPIDJSON_LIKELY(escape[static_cast<unsigned char>(e)])) {
  ------------------
  |  |  492|      1|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  |  Branch (1014:22): [True: 1, Folded]
  |  Branch (1014:41): [True: 0, False: 0]
  ------------------
 1015|      0|                    is.Take();
 1016|      0|                    os.Put(static_cast<typename TEncoding::Ch>(escape[static_cast<unsigned char>(e)]));
 1017|      0|                }
 1018|      1|                else if ((parseFlags & kParseEscapedApostropheFlag) && RAPIDJSON_LIKELY(e == '\'')) { // Allow escaped apostrophe
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1018:26): [Folded, False: 1]
  ------------------
 1019|      0|                    is.Take();
 1020|      0|                    os.Put('\'');
 1021|      0|                }
 1022|      1|                else if (RAPIDJSON_LIKELY(e == 'u')) {    // Unicode
  ------------------
  |  |  492|      1|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 1023|      1|                    is.Take();
 1024|      1|                    unsigned codepoint = ParseHex4(is, escapeOffset);
 1025|      1|                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|      1|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|      1|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|      1|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|      1|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 1]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 1]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1026|      1|                    if (RAPIDJSON_UNLIKELY(codepoint >= 0xD800 && codepoint <= 0xDFFF)) {
  ------------------
  |  |  505|      1|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 1]
  |  |  |  Branch (505:51): [True: 0, False: 1]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1027|       |                        // high surrogate, check if followed by valid low surrogate
 1028|      0|                        if (RAPIDJSON_LIKELY(codepoint <= 0xDBFF)) {
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1029|       |                            // Handle UTF-16 surrogate pair
 1030|      0|                            if (RAPIDJSON_UNLIKELY(!Consume(is, '\\') || !Consume(is, 'u')))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1031|      0|                                RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1031:33): [True: 0, False: 0]
  ------------------
 1032|      0|                            unsigned codepoint2 = ParseHex4(is, escapeOffset);
 1033|      0|                            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1034|      0|                            if (RAPIDJSON_UNLIKELY(codepoint2 < 0xDC00 || codepoint2 > 0xDFFF))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1035|      0|                                RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1035:33): [True: 0, False: 0]
  ------------------
 1036|      0|                            codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
 1037|      0|                        }
 1038|       |                        // single low surrogate
 1039|      0|                        else
 1040|      0|                        {
 1041|      0|                            RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1041:29): [True: 0, False: 0]
  ------------------
 1042|      0|                        }
 1043|      0|                    }
 1044|      1|                    TEncoding::Encode(os, codepoint);
 1045|      1|                }
 1046|      0|                else
 1047|      1|                    RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, escapeOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1047:21): [True: 0, False: 0]
  ------------------
 1048|      1|            }
 1049|   187k|            else if (RAPIDJSON_UNLIKELY(c == '"')) {    // Closing double quote
  ------------------
  |  |  505|   187k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 182k, False: 4.54k]
  |  |  ------------------
  ------------------
 1050|   182k|                is.Take();
 1051|   182k|                os.Put('\0');   // null-terminate the string
 1052|   182k|                return;
 1053|   182k|            }
 1054|  4.54k|            else if (RAPIDJSON_UNLIKELY(static_cast<unsigned>(c) < 0x20)) { // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
  ------------------
  |  |  505|  4.54k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 4.54k]
  |  |  ------------------
  ------------------
 1055|      0|                if (c == '\0')
  ------------------
  |  Branch (1055:21): [True: 0, False: 0]
  ------------------
 1056|      0|                    RAPIDJSON_PARSE_ERROR(kParseErrorStringMissQuotationMark, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1056:21): [True: 0, False: 0]
  ------------------
 1057|      0|                else
 1058|      0|                    RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1058:21): [True: 0, False: 0]
  ------------------
 1059|      0|            }
 1060|  4.54k|            else {
 1061|  4.54k|                size_t offset = is.Tell();
 1062|  4.54k|                if (RAPIDJSON_UNLIKELY((parseFlags & kParseValidateEncodingFlag ?
  ------------------
  |  |  505|  9.09k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 4.54k]
  |  |  |  Branch (505:51): [Folded, False: 4.54k]
  |  |  ------------------
  ------------------
 1063|  4.54k|                    !Transcoder<SEncoding, TEncoding>::Validate(is, os) :
 1064|  4.54k|                    !Transcoder<SEncoding, TEncoding>::Transcode(is, os))))
 1065|       |                    RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, offset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1065:21): [True: 0, False: 0]
  ------------------
 1066|  4.54k|            }
 1067|   187k|        }
 1068|   182k|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE23ScanCopyUnescapedStringINS_19GenericStringStreamIS2_EENS4_11StackStreamIcEEEEvRT_RT0_:
 1071|  1.26M|    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InputStream&, OutputStream&) {
 1072|       |            // Do nothing for generic version
 1073|  1.26M|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE11StackStreamIcE3PutEc:
  933|  51.6M|        RAPIDJSON_FORCEINLINE void Put(Ch c) {
  934|  51.6M|            *stack_.template Push<Ch>() = c;
  935|  51.6M|            ++length_;
  936|  51.6M|        }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE9ParseHex4INS_19GenericStringStreamIS2_EEEEjRT_m:
  906|  8.91k|    unsigned ParseHex4(InputStream& is, size_t escapeOffset) {
  907|  8.91k|        unsigned codepoint = 0;
  908|  44.5k|        for (int i = 0; i < 4; i++) {
  ------------------
  |  Branch (908:25): [True: 35.6k, False: 8.91k]
  ------------------
  909|  35.6k|            Ch c = is.Peek();
  910|  35.6k|            codepoint <<= 4;
  911|  35.6k|            codepoint += static_cast<unsigned>(c);
  912|  35.6k|            if (c >= '0' && c <= '9')
  ------------------
  |  Branch (912:17): [True: 35.6k, False: 0]
  |  Branch (912:29): [True: 8.50k, False: 27.1k]
  ------------------
  913|  8.50k|                codepoint -= '0';
  914|  27.1k|            else if (c >= 'A' && c <= 'F')
  ------------------
  |  Branch (914:22): [True: 27.1k, False: 0]
  |  Branch (914:34): [True: 16.0k, False: 11.0k]
  ------------------
  915|  16.0k|                codepoint -= 'A' - 10;
  916|  11.0k|            else if (c >= 'a' && c <= 'f')
  ------------------
  |  Branch (916:22): [True: 11.0k, False: 0]
  |  Branch (916:34): [True: 11.0k, False: 0]
  ------------------
  917|  11.0k|                codepoint -= 'a' - 10;
  918|      0|            else {
  919|      0|                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorStringUnicodeEscapeInvalidHex, escapeOffset);
  ------------------
  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  ------------------
  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  ------------------
  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (919:17): [True: 0, False: 0]
  ------------------
  920|      0|                RAPIDJSON_PARSE_ERROR_EARLY_RETURN(0);
  ------------------
  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  921|      0|            }
  922|  35.6k|            is.Take();
  923|  35.6k|        }
  924|  8.91k|        return codepoint;
  925|  8.91k|    }
_ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE11StackStreamIcE6LengthEv:
  943|  16.8M|        size_t Length() const { return length_; }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE11StackStreamIcE3PopEv:
  945|  10.3M|        Ch* Pop() {
  946|  10.3M|            return stack_.template Pop<Ch>(length_);
  947|  10.3M|        }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE11ParseObjectILj0ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  740|  7.53k|    void ParseObject(InputStream& is, Handler& handler) {
  741|  7.53k|        RAPIDJSON_ASSERT(is.Peek() == '{');
  ------------------
  |  |  437|  7.53k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (741:9): [True: 7.53k, False: 0]
  ------------------
  742|  7.53k|        is.Take();  // Skip '{'
  743|       |
  744|  7.53k|        if (RAPIDJSON_UNLIKELY(!handler.StartObject()))
  ------------------
  |  |  505|  7.53k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 7.53k]
  |  |  ------------------
  ------------------
  745|  7.53k|            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (745:13): [True: 0, False: 0]
  ------------------
  746|       |
  747|  7.53k|        SkipWhitespaceAndComments<parseFlags>(is);
  748|  7.53k|        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  7.53k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  7.53k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  7.53k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  7.53k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  7.53k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 7.53k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  7.53k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  7.53k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  7.53k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 7.53k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  749|       |
  750|  7.53k|        if (Consume(is, '}')) {
  ------------------
  |  Branch (750:13): [True: 3.76k, False: 3.77k]
  ------------------
  751|  3.76k|            if (RAPIDJSON_UNLIKELY(!handler.EndObject(0)))  // empty object
  ------------------
  |  |  505|  3.76k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 3.76k]
  |  |  ------------------
  ------------------
  752|  3.76k|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (752:17): [True: 0, False: 0]
  ------------------
  753|  3.76k|            return;
  754|  3.76k|        }
  755|       |
  756|   182k|        for (SizeType memberCount = 0;;) {
  757|   182k|            if (RAPIDJSON_UNLIKELY(is.Peek() != '"'))
  ------------------
  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 182k]
  |  |  ------------------
  ------------------
  758|   182k|                RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (758:17): [True: 0, False: 0]
  ------------------
  759|       |
  760|   182k|            ParseString<parseFlags>(is, handler, true);
  761|   182k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   182k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   182k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   182k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   182k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   182k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   182k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   182k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  762|       |
  763|   182k|            SkipWhitespaceAndComments<parseFlags>(is);
  764|   182k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   182k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   182k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   182k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   182k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   182k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   182k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   182k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  765|       |
  766|   182k|            if (RAPIDJSON_UNLIKELY(!Consume(is, ':')))
  ------------------
  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 182k]
  |  |  ------------------
  ------------------
  767|   182k|                RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (767:17): [True: 0, False: 0]
  ------------------
  768|       |
  769|   182k|            SkipWhitespaceAndComments<parseFlags>(is);
  770|   182k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   182k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   182k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   182k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   182k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   182k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   182k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   182k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  771|       |
  772|   182k|            ParseValue<parseFlags>(is, handler);
  773|   182k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   182k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   182k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   182k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   182k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 4, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   182k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   182k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   182k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  774|       |
  775|   182k|            SkipWhitespaceAndComments<parseFlags>(is);
  776|   182k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   182k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   182k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   182k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   182k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   182k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   182k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   182k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  777|       |
  778|   182k|            ++memberCount;
  779|       |
  780|   182k|            switch (is.Peek()) {
  781|   179k|                case ',':
  ------------------
  |  Branch (781:17): [True: 179k, False: 3.76k]
  ------------------
  782|   179k|                    is.Take();
  783|   179k|                    SkipWhitespaceAndComments<parseFlags>(is);
  784|   179k|                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   179k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   179k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   179k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   179k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   179k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 179k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   179k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   179k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   179k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 179k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  785|   179k|                    break;
  786|   179k|                case '}':
  ------------------
  |  Branch (786:17): [True: 3.76k, False: 179k]
  ------------------
  787|  3.76k|                    is.Take();
  788|  3.76k|                    if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
  ------------------
  |  |  505|  3.76k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 3.76k]
  |  |  ------------------
  ------------------
  789|  3.76k|                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (789:25): [True: 0, False: 0]
  ------------------
  790|  3.76k|                    return;
  791|  3.76k|                default:
  ------------------
  |  Branch (791:17): [True: 0, False: 182k]
  ------------------
  792|      0|                    RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); break; // This useless break is only for making warning and coverage happy
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (792:21): [True: 0, False: 0]
  ------------------
  793|   182k|            }
  794|       |
  795|   179k|            if (parseFlags & kParseTrailingCommasFlag) {
  ------------------
  |  Branch (795:17): [Folded, False: 179k]
  ------------------
  796|      0|                if (is.Peek() == '}') {
  ------------------
  |  Branch (796:21): [True: 0, False: 0]
  ------------------
  797|      0|                    if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  798|      0|                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (798:25): [True: 0, False: 0]
  ------------------
  799|      0|                    is.Take();
  800|      0|                    return;
  801|      0|                }
  802|      0|            }
  803|   179k|        }
  804|  3.77k|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE10ParseArrayILj0ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  808|  2.88k|    void ParseArray(InputStream& is, Handler& handler) {
  809|  2.88k|        RAPIDJSON_ASSERT(is.Peek() == '[');
  ------------------
  |  |  437|  2.88k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (809:9): [True: 2.88k, False: 0]
  ------------------
  810|  2.88k|        is.Take();  // Skip '['
  811|       |
  812|  2.88k|        if (RAPIDJSON_UNLIKELY(!handler.StartArray()))
  ------------------
  |  |  505|  2.88k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 2.88k]
  |  |  ------------------
  ------------------
  813|  2.88k|            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (813:13): [True: 0, False: 0]
  ------------------
  814|       |
  815|  2.88k|        SkipWhitespaceAndComments<parseFlags>(is);
  816|  2.88k|        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  2.88k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  2.88k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  2.88k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  2.88k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  2.88k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 2.88k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  2.88k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  2.88k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  2.88k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 2.88k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  817|       |
  818|  2.88k|        if (Consume(is, ']')) {
  ------------------
  |  Branch (818:13): [True: 2, False: 2.88k]
  ------------------
  819|      2|            if (RAPIDJSON_UNLIKELY(!handler.EndArray(0))) // empty array
  ------------------
  |  |  505|      2|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  820|      2|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (820:17): [True: 0, False: 0]
  ------------------
  821|      2|            return;
  822|      2|        }
  823|       |
  824|  1.60M|        for (SizeType elementCount = 0;;) {
  825|  1.60M|            ParseValue<parseFlags>(is, handler);
  826|  1.60M|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  1.60M|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  1.60M|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  1.60M|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  1.60M|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  1.60M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 1.94k, False: 1.60M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  1.60M|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  1.60M|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  1.60M|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 1.60M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  827|       |
  828|  1.60M|            ++elementCount;
  829|  1.60M|            SkipWhitespaceAndComments<parseFlags>(is);
  830|  1.60M|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  1.60M|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  1.60M|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  1.60M|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  1.60M|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  1.60M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 1.60M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  1.60M|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  1.60M|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  1.60M|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 1.60M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  831|       |
  832|  1.60M|            if (Consume(is, ',')) {
  ------------------
  |  Branch (832:17): [True: 1.60M, False: 945]
  ------------------
  833|  1.60M|                SkipWhitespaceAndComments<parseFlags>(is);
  834|  1.60M|                RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  1.60M|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  1.60M|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  1.60M|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  1.60M|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  1.60M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 1.60M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  1.60M|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  1.60M|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  1.60M|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 1.60M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  835|  1.60M|            }
  836|    945|            else if (Consume(is, ']')) {
  ------------------
  |  Branch (836:22): [True: 942, False: 3]
  ------------------
  837|    942|                if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
  ------------------
  |  |  505|    942|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 942]
  |  |  ------------------
  ------------------
  838|    942|                    RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (838:21): [True: 0, False: 0]
  ------------------
  839|    942|                return;
  840|    942|            }
  841|      3|            else
  842|    945|                RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
  ------------------
  |  |  120|      6|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      3|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      6|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      3|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      3|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      3|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      3|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      3|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      3|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      3|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      3|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 3]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      6|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      3|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      6|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      3|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      6|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      3|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 3, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      6|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      3|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      3|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      3|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      3|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      3|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (842:17): [True: 3, False: 0]
  ------------------
  843|       |
  844|  1.60M|            if (parseFlags & kParseTrailingCommasFlag) {
  ------------------
  |  Branch (844:17): [Folded, False: 1.60M]
  ------------------
  845|      0|                if (is.Peek() == ']') {
  ------------------
  |  Branch (845:21): [True: 0, False: 0]
  ------------------
  846|      0|                    if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  847|      0|                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (847:25): [True: 0, False: 0]
  ------------------
  848|      0|                    is.Take();
  849|      0|                    return;
  850|      0|                }
  851|      0|            }
  852|  1.60M|        }
  853|  2.88k|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE11ParseNumberILj0ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
 1468|  1.78M|    void ParseNumber(InputStream& is, Handler& handler) {
 1469|  1.78M|        typedef typename internal::SelectIf<internal::BoolType<(parseFlags & kParseNumbersAsStringsFlag) != 0>, typename TargetEncoding::Ch, char>::Type NumberCharacter;
 1470|       |
 1471|  1.78M|        internal::StreamLocalCopy<InputStream> copy(is);
 1472|  1.78M|        NumberStream<InputStream, NumberCharacter,
 1473|  1.78M|            ((parseFlags & kParseNumbersAsStringsFlag) != 0) ?
 1474|  1.78M|                ((parseFlags & kParseInsituFlag) == 0) :
 1475|  1.78M|                ((parseFlags & kParseFullPrecisionFlag) != 0),
 1476|  1.78M|            (parseFlags & kParseNumbersAsStringsFlag) != 0 &&
 1477|  1.78M|                (parseFlags & kParseInsituFlag) == 0> s(*this, copy.s);
 1478|       |
 1479|  1.78M|        size_t startOffset = s.Tell();
 1480|  1.78M|        double d = 0.0;
 1481|  1.78M|        bool useNanOrInf = false;
 1482|       |
 1483|       |        // Parse minus
 1484|  1.78M|        bool minus = Consume(s, '-');
 1485|       |
 1486|       |        // Parse int: zero / ( digit1-9 *DIGIT )
 1487|  1.78M|        unsigned i = 0;
 1488|  1.78M|        uint64_t i64 = 0;
 1489|  1.78M|        bool use64bit = false;
 1490|  1.78M|        int significandDigit = 0;
 1491|  1.78M|        if (RAPIDJSON_UNLIKELY(s.Peek() == '0')) {
  ------------------
  |  |  505|  1.78M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 75.0k, False: 1.70M]
  |  |  ------------------
  ------------------
 1492|  75.0k|            i = 0;
 1493|  75.0k|            s.TakePush();
 1494|  75.0k|        }
 1495|  1.70M|        else if (RAPIDJSON_LIKELY(s.Peek() >= '1' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  3.41M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 1.70M, False: 5]
  |  |  |  Branch (492:49): [True: 1.70M, False: 1]
  |  |  |  Branch (492:49): [True: 1.70M, False: 4]
  |  |  ------------------
  ------------------
 1496|  1.70M|            i = static_cast<unsigned>(s.TakePush() - '0');
 1497|       |
 1498|  1.70M|            if (minus)
  ------------------
  |  Branch (1498:17): [True: 1.55k, False: 1.70M]
  ------------------
 1499|  3.66k|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  5.83k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 2.16k, False: 1.50k]
  |  |  |  Branch (492:49): [True: 2.16k, False: 1.50k]
  |  |  |  Branch (492:49): [True: 2.16k, False: 0]
  |  |  ------------------
  ------------------
 1500|  2.16k|                    if (RAPIDJSON_UNLIKELY(i >= 214748364)) { // 2^31 = 2147483648
  ------------------
  |  |  505|  2.16k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 55, False: 2.11k]
  |  |  ------------------
  ------------------
 1501|     55|                        if (RAPIDJSON_LIKELY(i != 214748364 || s.Peek() > '8')) {
  ------------------
  |  |  492|     55|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 55, False: 0]
  |  |  |  Branch (492:49): [True: 55, False: 0]
  |  |  |  Branch (492:49): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1502|     55|                            i64 = i;
 1503|     55|                            use64bit = true;
 1504|     55|                            break;
 1505|     55|                        }
 1506|     55|                    }
 1507|  2.11k|                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1508|  2.11k|                    significandDigit++;
 1509|  2.11k|                }
 1510|  1.70M|            else
 1511|  1.76M|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  1.83M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 67.0k, False: 1.70M]
  |  |  |  Branch (492:49): [True: 70.0k, False: 1.69M]
  |  |  |  Branch (492:49): [True: 67.0k, False: 3.06k]
  |  |  ------------------
  ------------------
 1512|  67.0k|                    if (RAPIDJSON_UNLIKELY(i >= 429496729)) { // 2^32 - 1 = 4294967295
  ------------------
  |  |  505|  67.0k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 3.49k, False: 63.5k]
  |  |  ------------------
  ------------------
 1513|  3.49k|                        if (RAPIDJSON_LIKELY(i != 429496729 || s.Peek() > '5')) {
  ------------------
  |  |  492|  3.50k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 3.49k, False: 4]
  |  |  |  Branch (492:49): [True: 3.48k, False: 9]
  |  |  |  Branch (492:49): [True: 5, False: 4]
  |  |  ------------------
  ------------------
 1514|  3.49k|                            i64 = i;
 1515|  3.49k|                            use64bit = true;
 1516|  3.49k|                            break;
 1517|  3.49k|                        }
 1518|  3.49k|                    }
 1519|  63.5k|                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1520|  63.5k|                    significandDigit++;
 1521|  63.5k|                }
 1522|  1.70M|        }
 1523|       |        // Parse NaN or Infinity here
 1524|      5|        else if ((parseFlags & kParseNanAndInfFlag) && RAPIDJSON_LIKELY((s.Peek() == 'I' || s.Peek() == 'N'))) {
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  |  Branch (492:49): [True: 0, False: 0]
  |  |  |  Branch (492:49): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1524:18): [Folded, False: 5]
  ------------------
 1525|      0|            if (Consume(s, 'N')) {
  ------------------
  |  Branch (1525:17): [True: 0, False: 0]
  ------------------
 1526|      0|                if (Consume(s, 'a') && Consume(s, 'N')) {
  ------------------
  |  Branch (1526:21): [True: 0, False: 0]
  |  Branch (1526:40): [True: 0, False: 0]
  ------------------
 1527|      0|                    d = std::numeric_limits<double>::quiet_NaN();
 1528|      0|                    useNanOrInf = true;
 1529|      0|                }
 1530|      0|            }
 1531|      0|            else if (RAPIDJSON_LIKELY(Consume(s, 'I'))) {
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1532|      0|                if (Consume(s, 'n') && Consume(s, 'f')) {
  ------------------
  |  Branch (1532:21): [True: 0, False: 0]
  |  Branch (1532:40): [True: 0, False: 0]
  ------------------
 1533|      0|                    d = (minus ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity());
  ------------------
  |  Branch (1533:26): [True: 0, False: 0]
  ------------------
 1534|      0|                    useNanOrInf = true;
 1535|       |
 1536|      0|                    if (RAPIDJSON_UNLIKELY(s.Peek() == 'i' && !(Consume(s, 'i') && Consume(s, 'n')
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1537|      0|                                                                && Consume(s, 'i') && Consume(s, 't') && Consume(s, 'y')))) {
 1538|      0|                        RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1538:25): [True: 0, False: 0]
  ------------------
 1539|      0|                    }
 1540|      0|                }
 1541|      0|            }
 1542|       |
 1543|      0|            if (RAPIDJSON_UNLIKELY(!useNanOrInf)) {
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1544|      0|                RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1544:17): [True: 0, False: 0]
  ------------------
 1545|      0|            }
 1546|      0|        }
 1547|      5|        else
 1548|      5|            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
  ------------------
  |  |  120|     10|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      5|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|     10|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      5|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      5|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      5|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      5|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      5|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      5|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      5|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      5|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|     10|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      5|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|     10|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      5|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|     10|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      5|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 5, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|     10|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      5|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      5|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      5|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      5|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      5|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1548:13): [True: 5, False: 0]
  ------------------
 1549|       |
 1550|       |        // Parse 64bit int
 1551|  1.78M|        bool useDouble = false;
 1552|  1.78M|        if (use64bit) {
  ------------------
  |  Branch (1552:13): [True: 3.54k, False: 1.77M]
  ------------------
 1553|  3.54k|            if (minus)
  ------------------
  |  Branch (1553:17): [True: 55, False: 3.49k]
  ------------------
 1554|    149|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|    245|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 96, False: 53]
  |  |  |  Branch (492:49): [True: 96, False: 53]
  |  |  |  Branch (492:49): [True: 96, False: 0]
  |  |  ------------------
  ------------------
 1555|     96|                     if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC))) // 2^63 = 9223372036854775808
  ------------------
  |  |  505|     96|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 2, False: 94]
  |  |  ------------------
  ------------------
 1556|      2|                        if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC) || s.Peek() > '8')) {
  ------------------
  |  |  492|      2|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 2, False: 0]
  |  |  |  Branch (492:49): [True: 2, False: 0]
  |  |  |  Branch (492:49): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1557|      2|                            d = static_cast<double>(i64);
 1558|      2|                            useDouble = true;
 1559|      2|                            break;
 1560|      2|                        }
 1561|     94|                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1562|     94|                    significandDigit++;
 1563|     94|                }
 1564|  3.49k|            else
 1565|  32.4k|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  62.9k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 30.4k, False: 1.92k]
  |  |  |  Branch (492:49): [True: 30.5k, False: 1.87k]
  |  |  |  Branch (492:49): [True: 30.4k, False: 48]
  |  |  ------------------
  ------------------
 1566|  30.4k|                    if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999))) // 2^64 - 1 = 18446744073709551615
  ------------------
  |  |  505|  30.4k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 1.56k, False: 28.9k]
  |  |  ------------------
  ------------------
 1567|  1.56k|                        if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || s.Peek() > '5')) {
  ------------------
  |  |  492|  1.57k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 1.56k, False: 4]
  |  |  |  Branch (492:49): [True: 1.56k, False: 4]
  |  |  |  Branch (492:49): [True: 0, False: 4]
  |  |  ------------------
  ------------------
 1568|  1.56k|                            d = static_cast<double>(i64);
 1569|  1.56k|                            useDouble = true;
 1570|  1.56k|                            break;
 1571|  1.56k|                        }
 1572|  28.9k|                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1573|  28.9k|                    significandDigit++;
 1574|  28.9k|                }
 1575|  3.54k|        }
 1576|       |
 1577|       |        // Force double for big integer
 1578|  1.78M|        if (useDouble) {
  ------------------
  |  Branch (1578:13): [True: 1.56k, False: 1.77M]
  ------------------
 1579|  1.92M|            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  3.85M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 1.92M, False: 1.56k]
  |  |  |  Branch (492:49): [True: 1.92M, False: 1.55k]
  |  |  |  Branch (492:49): [True: 1.92M, False: 10]
  |  |  ------------------
  ------------------
 1580|  1.92M|                d = d * 10 + (s.TakePush() - '0');
 1581|  1.92M|            }
 1582|  1.56k|        }
 1583|       |
 1584|       |        // Parse frac = decimal-point 1*DIGIT
 1585|  1.78M|        int expFrac = 0;
 1586|  1.78M|        size_t decimalPosition;
 1587|  1.78M|        if (!useNanOrInf && Consume(s, '.')) {
  ------------------
  |  Branch (1587:13): [True: 1.78M, False: 0]
  |  Branch (1587:29): [True: 10.8k, False: 1.76M]
  ------------------
 1588|  10.8k|            decimalPosition = s.Length();
 1589|       |
 1590|  10.8k|            if (RAPIDJSON_UNLIKELY(!(s.Peek() >= '0' && s.Peek() <= '9')))
  ------------------
  |  |  505|  21.7k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 10.8k]
  |  |  |  Branch (505:51): [True: 10.8k, False: 0]
  |  |  |  Branch (505:51): [True: 10.8k, False: 0]
  |  |  ------------------
  ------------------
 1591|  10.8k|                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1591:17): [True: 0, False: 0]
  ------------------
 1592|       |
 1593|  10.8k|            if (!useDouble) {
  ------------------
  |  Branch (1593:17): [True: 10.6k, False: 188]
  ------------------
 1594|  10.6k|#if RAPIDJSON_64BIT
 1595|       |                // Use i64 to store significand in 64-bit architecture
 1596|  10.6k|                if (!use64bit)
  ------------------
  |  Branch (1596:21): [True: 10.6k, False: 62]
  ------------------
 1597|  10.6k|                    i64 = i;
 1598|       |
 1599|   417k|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|   823k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 406k, False: 10.6k]
  |  |  |  Branch (492:49): [True: 406k, False: 10.5k]
  |  |  |  Branch (492:49): [True: 406k, False: 107]
  |  |  ------------------
  ------------------
 1600|   406k|                    if (i64 > RAPIDJSON_UINT64_C2(0x1FFFFF, 0xFFFFFFFF)) // 2^53 - 1 for fast path
  ------------------
  |  |  320|   406k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  |  Branch (1600:25): [True: 21, False: 406k]
  ------------------
 1601|     21|                        break;
 1602|   406k|                    else {
 1603|   406k|                        i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1604|   406k|                        --expFrac;
 1605|   406k|                        if (i64 != 0)
  ------------------
  |  Branch (1605:29): [True: 10.8k, False: 395k]
  ------------------
 1606|  10.8k|                            significandDigit++;
 1607|   406k|                    }
 1608|   406k|                }
 1609|       |
 1610|  10.6k|                d = static_cast<double>(i64);
 1611|       |#else
 1612|       |                // Use double to store significand in 32-bit architecture
 1613|       |                d = static_cast<double>(use64bit ? i64 : i);
 1614|       |#endif
 1615|  10.6k|                useDouble = true;
 1616|  10.6k|            }
 1617|       |
 1618|  7.18M|            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  14.3M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 7.17M, False: 10.8k]
  |  |  |  Branch (492:49): [True: 7.17M, False: 10.5k]
  |  |  |  Branch (492:49): [True: 7.17M, False: 305]
  |  |  ------------------
  ------------------
 1619|  7.17M|                if (significandDigit < 17) {
  ------------------
  |  Branch (1619:21): [True: 14, False: 7.17M]
  ------------------
 1620|     14|                    d = d * 10.0 + (s.TakePush() - '0');
 1621|     14|                    --expFrac;
 1622|     14|                    if (RAPIDJSON_LIKELY(d > 0.0))
  ------------------
  |  |  492|     14|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 14, False: 0]
  |  |  ------------------
  ------------------
 1623|     14|                        significandDigit++;
 1624|     14|                }
 1625|  7.17M|                else
 1626|  7.17M|                    s.TakePush();
 1627|  7.17M|            }
 1628|  10.8k|        }
 1629|  1.76M|        else
 1630|  1.76M|            decimalPosition = s.Length(); // decimal position at the end of integer.
 1631|       |
 1632|       |        // Parse exp = e [ minus / plus ] 1*DIGIT
 1633|  1.78M|        int exp = 0;
 1634|  1.78M|        if (!useNanOrInf && (Consume(s, 'e') || Consume(s, 'E'))) {
  ------------------
  |  Branch (1634:13): [True: 1.78M, False: 0]
  |  Branch (1634:30): [True: 436, False: 1.78M]
  |  Branch (1634:49): [True: 2.98k, False: 1.77M]
  ------------------
 1635|  3.42k|            if (!useDouble) {
  ------------------
  |  Branch (1635:17): [True: 3.10k, False: 313]
  ------------------
 1636|  3.10k|                d = static_cast<double>(use64bit ? i64 : i);
  ------------------
  |  Branch (1636:41): [True: 48, False: 3.06k]
  ------------------
 1637|  3.10k|                useDouble = true;
 1638|  3.10k|            }
 1639|       |
 1640|  3.42k|            bool expMinus = false;
 1641|  3.42k|            if (Consume(s, '+'))
  ------------------
  |  Branch (1641:17): [True: 0, False: 3.42k]
  ------------------
 1642|      0|                ;
 1643|  3.42k|            else if (Consume(s, '-'))
  ------------------
  |  Branch (1643:22): [True: 432, False: 2.99k]
  ------------------
 1644|    432|                expMinus = true;
 1645|       |
 1646|  3.42k|            if (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  6.84k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 3.42k, False: 0]
  |  |  |  Branch (492:49): [True: 3.42k, False: 0]
  |  |  |  Branch (492:49): [True: 3.42k, False: 0]
  |  |  ------------------
  ------------------
 1647|  3.42k|                exp = static_cast<int>(s.Take() - '0');
 1648|  3.42k|                if (expMinus) {
  ------------------
  |  Branch (1648:21): [True: 432, False: 2.99k]
  ------------------
 1649|       |                    // (exp + expFrac) must not underflow int => we're detecting when -exp gets
 1650|       |                    // dangerously close to INT_MIN (a pessimistic next digit 9 would push it into
 1651|       |                    // underflow territory):
 1652|       |                    //
 1653|       |                    //        -(exp * 10 + 9) + expFrac >= INT_MIN
 1654|       |                    //   <=>  exp <= (expFrac - INT_MIN - 9) / 10
 1655|    432|                    RAPIDJSON_ASSERT(expFrac <= 0);
  ------------------
  |  |  437|    432|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (1655:21): [True: 432, False: 0]
  ------------------
 1656|    432|                    int maxExp = (expFrac + 2147483639) / 10;
 1657|       |
 1658|   854k|                    while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  1.70M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 854k, False: 432]
  |  |  |  Branch (492:49): [True: 854k, False: 431]
  |  |  |  Branch (492:49): [True: 854k, False: 1]
  |  |  ------------------
  ------------------
 1659|   854k|                        exp = exp * 10 + static_cast<int>(s.Take() - '0');
 1660|   854k|                        if (RAPIDJSON_UNLIKELY(exp > maxExp)) {
  ------------------
  |  |  505|   854k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 5, False: 854k]
  |  |  ------------------
  ------------------
 1661|     13|                            while (RAPIDJSON_UNLIKELY(s.Peek() >= '0' && s.Peek() <= '9'))  // Consume the rest of exponent
  ------------------
  |  |  505|     21|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 8, False: 5]
  |  |  |  Branch (505:51): [True: 8, False: 5]
  |  |  |  Branch (505:51): [True: 8, False: 0]
  |  |  ------------------
  ------------------
 1662|      8|                                s.Take();
 1663|      5|                        }
 1664|   854k|                    }
 1665|    432|                }
 1666|  2.99k|                else {  // positive exp
 1667|  2.99k|                    int maxExp = 308 - expFrac;
 1668|   486k|                    while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|   970k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 483k, False: 2.98k]
  |  |  |  Branch (492:49): [True: 483k, False: 2.98k]
  |  |  |  Branch (492:49): [True: 483k, False: 0]
  |  |  ------------------
  ------------------
 1669|   483k|                        exp = exp * 10 + static_cast<int>(s.Take() - '0');
 1670|   483k|                        if (RAPIDJSON_UNLIKELY(exp > maxExp))
  ------------------
  |  |  505|   483k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 1, False: 483k]
  |  |  ------------------
  ------------------
 1671|   483k|                            RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
  ------------------
  |  |  120|      2|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      2|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      1|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      1|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      1|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      1|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 1]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      2|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      1|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      2|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      2|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      1|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 1, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      2|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1671:29): [True: 1, False: 0]
  ------------------
 1672|   483k|                    }
 1673|  2.99k|                }
 1674|  3.42k|            }
 1675|      0|            else
 1676|  3.42k|                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissExponent, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1676:17): [True: 0, False: 0]
  ------------------
 1677|       |
 1678|  3.42k|            if (expMinus)
  ------------------
  |  Branch (1678:17): [True: 432, False: 2.98k]
  ------------------
 1679|    432|                exp = -exp;
 1680|  3.42k|        }
 1681|       |
 1682|       |        // Finish parsing, call event according to the type of number.
 1683|  1.78M|        bool cont = true;
 1684|       |
 1685|  1.78M|        if (parseFlags & kParseNumbersAsStringsFlag) {
  ------------------
  |  Branch (1685:13): [Folded, False: 1.78M]
  ------------------
 1686|      0|            if (parseFlags & kParseInsituFlag) {
  ------------------
  |  Branch (1686:17): [Folded, False: 0]
  ------------------
 1687|      0|                s.Pop();  // Pop stack no matter if it will be used or not.
 1688|      0|                typename InputStream::Ch* head = is.PutBegin();
 1689|      0|                const size_t length = s.Tell() - startOffset;
 1690|      0|                RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
  ------------------
  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (1690:17): [True: 0, False: 0]
  ------------------
 1691|       |                // unable to insert the \0 character here, it will erase the comma after this number
 1692|      0|                const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
 1693|      0|                cont = handler.RawNumber(str, SizeType(length), false);
 1694|      0|            }
 1695|      0|            else {
 1696|      0|                SizeType numCharsToCopy = static_cast<SizeType>(s.Length());
 1697|      0|                GenericStringStream<UTF8<NumberCharacter> > srcStream(s.Pop());
 1698|      0|                StackStream<typename TargetEncoding::Ch> dstStream(stack_);
 1699|      0|                while (numCharsToCopy--) {
  ------------------
  |  Branch (1699:24): [True: 0, False: 0]
  ------------------
 1700|      0|                    Transcoder<UTF8<typename TargetEncoding::Ch>, TargetEncoding>::Transcode(srcStream, dstStream);
 1701|      0|                }
 1702|      0|                dstStream.Put('\0');
 1703|      0|                const typename TargetEncoding::Ch* str = dstStream.Pop();
 1704|      0|                const SizeType length = static_cast<SizeType>(dstStream.Length()) - 1;
 1705|      0|                cont = handler.RawNumber(str, SizeType(length), true);
 1706|      0|            }
 1707|      0|        }
 1708|  1.78M|        else {
 1709|  1.78M|           size_t length = s.Length();
 1710|  1.78M|           const NumberCharacter* decimal = s.Pop();  // Pop stack no matter if it will be used or not.
 1711|       |
 1712|  1.78M|           if (useDouble) {
  ------------------
  |  Branch (1712:16): [True: 15.3k, False: 1.76M]
  ------------------
 1713|  15.3k|               int p = exp + expFrac;
 1714|  15.3k|               if (parseFlags & kParseFullPrecisionFlag)
  ------------------
  |  Branch (1714:20): [Folded, False: 15.3k]
  ------------------
 1715|      0|                   d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp);
 1716|  15.3k|               else
 1717|  15.3k|                   d = internal::StrtodNormalPrecision(d, p);
 1718|       |
 1719|       |               // Use > max, instead of == inf, to fix bogus warning -Wfloat-equal
 1720|  15.3k|               if (d > (std::numeric_limits<double>::max)()) {
  ------------------
  |  Branch (1720:20): [True: 6, False: 15.3k]
  ------------------
 1721|       |                   // Overflow
 1722|       |                   // TODO: internal::StrtodX should report overflow (or underflow)
 1723|      6|                   RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
  ------------------
  |  |  120|      6|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      6|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      6|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      6|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      6|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      6|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      6|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      6|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      6|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      6|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      6|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 6]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      6|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      6|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|     12|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      6|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|     12|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      6|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 6, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|     12|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      6|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      6|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      6|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      6|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      6|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1723:20): [True: 6, False: 0]
  ------------------
 1724|      6|               }
 1725|       |
 1726|  15.3k|               cont = handler.Double(minus ? -d : d);
  ------------------
  |  Branch (1726:38): [True: 3, False: 15.3k]
  ------------------
 1727|  15.3k|           }
 1728|  1.76M|           else if (useNanOrInf) {
  ------------------
  |  Branch (1728:21): [True: 0, False: 1.76M]
  ------------------
 1729|      0|               cont = handler.Double(d);
 1730|      0|           }
 1731|  1.76M|           else {
 1732|  1.76M|               if (use64bit) {
  ------------------
  |  Branch (1732:20): [True: 1.87k, False: 1.76M]
  ------------------
 1733|  1.87k|                   if (minus)
  ------------------
  |  Branch (1733:24): [True: 53, False: 1.81k]
  ------------------
 1734|     53|                       cont = handler.Int64(static_cast<int64_t>(~i64 + 1));
 1735|  1.81k|                   else
 1736|  1.81k|                       cont = handler.Uint64(i64);
 1737|  1.87k|               }
 1738|  1.76M|               else {
 1739|  1.76M|                   if (minus)
  ------------------
  |  Branch (1739:24): [True: 1.68k, False: 1.76M]
  ------------------
 1740|  1.68k|                       cont = handler.Int(static_cast<int32_t>(~i + 1));
 1741|  1.76M|                   else
 1742|  1.76M|                       cont = handler.Uint(i);
 1743|  1.76M|               }
 1744|  1.76M|           }
 1745|  1.78M|        }
 1746|  1.78M|        if (RAPIDJSON_UNLIKELY(!cont))
  ------------------
  |  |  505|  1.78M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 1.78M]
  |  |  ------------------
  ------------------
 1747|       |            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, startOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1747:13): [True: 0, False: 0]
  ------------------
 1748|  1.78M|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE12NumberStreamINS_19GenericStringStreamIS2_EEcLb0ELb0EEC2ERS4_RS7_:
 1415|  9.96M|        NumberStream(GenericReader& reader, InputStream& s) : is(s) { (void)reader;  }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE12NumberStreamINS_19GenericStringStreamIS2_EEcLb0ELb0EE4TellEv:
 1422|  9.96M|        size_t Tell() { return is.Tell(); }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE7ConsumeINS4_12NumberStreamINS_19GenericStringStreamIS2_EEcLb0ELb0EEEEEbRT_NSA_2ChE:
  895|  14.2M|    RAPIDJSON_FORCEINLINE static bool Consume(InputStream& is, typename InputStream::Ch expect) {
  896|  14.2M|        if (RAPIDJSON_LIKELY(is.Peek() == expect)) {
  ------------------
  |  |  492|  14.2M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 32.9k, False: 14.2M]
  |  |  ------------------
  ------------------
  897|  32.9k|            is.Take();
  898|  32.9k|            return true;
  899|  32.9k|        }
  900|  14.2M|        else
  901|  14.2M|            return false;
  902|  14.2M|    }
_ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE12NumberStreamINS_19GenericStringStreamIS2_EEcLb0ELb0EE4PeekEv:
 1417|   167M|        RAPIDJSON_FORCEINLINE Ch Peek() const { return is.Peek(); }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE12NumberStreamINS_19GenericStringStreamIS2_EEcLb0ELb0EE8TakePushEv:
 1418|  22.7M|        RAPIDJSON_FORCEINLINE Ch TakePush() { return is.Take(); }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE12NumberStreamINS_19GenericStringStreamIS2_EEcLb0ELb0EE6LengthEv:
 1423|  7.12M|        size_t Length() { return 0; }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE12NumberStreamINS_19GenericStringStreamIS2_EEcLb0ELb0EE4TakeEv:
 1419|  4.08M|        RAPIDJSON_FORCEINLINE Ch Take() { return is.Take(); }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE12NumberStreamINS_19GenericStringStreamIS2_EEcLb0ELb0EE3PopEv:
 1424|  3.56M|        const StackCharacter* Pop() { return 0; }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE16ClearStackOnExitD2Ev:
  703|    104|        ~ClearStackOnExit() { r_.ClearStack(); }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE10ClearStackEv:
  698|    104|    void ClearStack() { stack_.Clear(); }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE5ParseILj16ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEENS_11ParseResultERT0_RT1_:
  559|     26|    ParseResult Parse(InputStream& is, Handler& handler) {
  560|     26|        if (parseFlags & kParseIterativeFlag)
  ------------------
  |  Branch (560:13): [Folded, False: 26]
  ------------------
  561|      0|            return IterativeParse<parseFlags>(is, handler);
  562|       |
  563|     26|        parseResult_.Clear();
  564|       |
  565|     26|        ClearStackOnExit scope(*this);
  566|       |
  567|     26|        SkipWhitespaceAndComments<parseFlags>(is);
  568|     26|        RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|     26|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|     26|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|     26|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|     26|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 0, False: 26]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|     26|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|     26|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|     26|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 26]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  569|       |
  570|     26|        if (RAPIDJSON_UNLIKELY(is.Peek() == '\0')) {
  ------------------
  |  |  505|     26|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 1, False: 25]
  |  |  ------------------
  ------------------
  571|      1|            RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentEmpty, is.Tell());
  ------------------
  |  |  101|      1|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  102|      1|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  ------------------
  |  |  |  |  437|      1|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  ------------------
  |  |  103|      1|    SetParseError(parseErrorCode, offset); \
  |  |  104|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (571:13): [True: 1, False: 0]
  ------------------
  572|      1|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|      2|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|      2|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|      1|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 1, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      2|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  573|      1|        }
  574|     25|        else {
  575|     25|            ParseValue<parseFlags>(is, handler);
  576|     25|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|     25|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|     25|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|     25|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|     25|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 12, False: 13]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|     25|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|     25|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|     25|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 13]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  577|       |
  578|     13|            if (!(parseFlags & kParseStopWhenDoneFlag)) {
  ------------------
  |  Branch (578:17): [True: 13, Folded]
  ------------------
  579|     13|                SkipWhitespaceAndComments<parseFlags>(is);
  580|     13|                RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|     13|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|     13|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|     13|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|     13|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 0, False: 13]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|     13|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|     13|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|     13|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 13]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  581|       |
  582|     13|                if (RAPIDJSON_UNLIKELY(is.Peek() != '\0')) {
  ------------------
  |  |  505|     13|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 1, False: 12]
  |  |  ------------------
  ------------------
  583|      1|                    RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentRootNotSingular, is.Tell());
  ------------------
  |  |  101|      1|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  102|      1|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  ------------------
  |  |  |  |  437|      1|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  ------------------
  |  |  103|      1|    SetParseError(parseErrorCode, offset); \
  |  |  104|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (583:21): [True: 1, False: 0]
  ------------------
  584|      1|                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|      2|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|      2|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|      1|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 1, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      2|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  585|      1|                }
  586|     13|            }
  587|     13|        }
  588|       |
  589|     12|        return parseResult_;
  590|     26|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE25SkipWhitespaceAndCommentsILj16ENS_19GenericStringStreamIS2_EEEEvRT0_:
  711|  6.77M|    void SkipWhitespaceAndComments(InputStream& is) {
  712|  6.77M|        SkipWhitespace(is);
  713|       |
  714|  6.77M|        if (parseFlags & kParseCommentsFlag) {
  ------------------
  |  Branch (714:13): [Folded, False: 6.77M]
  ------------------
  715|      0|            while (RAPIDJSON_UNLIKELY(Consume(is, '/'))) {
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  716|      0|                if (Consume(is, '*')) {
  ------------------
  |  Branch (716:21): [True: 0, False: 0]
  ------------------
  717|      0|                    while (true) {
  ------------------
  |  Branch (717:28): [True: 0, Folded]
  ------------------
  718|      0|                        if (RAPIDJSON_UNLIKELY(is.Peek() == '\0'))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  719|      0|                            RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (719:29): [True: 0, False: 0]
  ------------------
  720|      0|                        else if (Consume(is, '*')) {
  ------------------
  |  Branch (720:34): [True: 0, False: 0]
  ------------------
  721|      0|                            if (Consume(is, '/'))
  ------------------
  |  Branch (721:33): [True: 0, False: 0]
  ------------------
  722|      0|                                break;
  723|      0|                        }
  724|      0|                        else
  725|      0|                            is.Take();
  726|      0|                    }
  727|      0|                }
  728|      0|                else if (RAPIDJSON_LIKELY(Consume(is, '/')))
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  729|      0|                    while (is.Peek() != '\0' && is.Take() != '\n') {}
  ------------------
  |  Branch (729:28): [True: 0, False: 0]
  |  Branch (729:49): [True: 0, False: 0]
  ------------------
  730|      0|                else
  731|      0|                    RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (731:21): [True: 0, False: 0]
  ------------------
  732|       |
  733|      0|                SkipWhitespace(is);
  734|      0|            }
  735|      0|        }
  736|  6.77M|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE10ParseValueILj16ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
 1752|  3.19M|    void ParseValue(InputStream& is, Handler& handler) {
 1753|  3.19M|        switch (is.Peek()) {
 1754|     38|            case 'n': ParseNull  <parseFlags>(is, handler); break;
  ------------------
  |  Branch (1754:13): [True: 38, False: 3.19M]
  ------------------
 1755|      5|            case 't': ParseTrue  <parseFlags>(is, handler); break;
  ------------------
  |  Branch (1755:13): [True: 5, False: 3.19M]
  ------------------
 1756|    309|            case 'f': ParseFalse <parseFlags>(is, handler); break;
  ------------------
  |  Branch (1756:13): [True: 309, False: 3.19M]
  ------------------
 1757|      9|            case '"': ParseString<parseFlags>(is, handler); break;
  ------------------
  |  Branch (1757:13): [True: 9, False: 3.19M]
  ------------------
 1758|  7.55k|            case '{': ParseObject<parseFlags>(is, handler); break;
  ------------------
  |  Branch (1758:13): [True: 7.55k, False: 3.18M]
  ------------------
 1759|  8.80k|            case '[': ParseArray <parseFlags>(is, handler); break;
  ------------------
  |  Branch (1759:13): [True: 8.80k, False: 3.18M]
  ------------------
 1760|  3.17M|            default :
  ------------------
  |  Branch (1760:13): [True: 3.17M, False: 16.7k]
  ------------------
 1761|  3.17M|                      ParseNumber<parseFlags>(is, handler);
 1762|  3.17M|                      break;
 1763|       |
 1764|  3.19M|        }
 1765|  3.19M|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE9ParseNullILj16ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  856|     38|    void ParseNull(InputStream& is, Handler& handler) {
  857|     38|        RAPIDJSON_ASSERT(is.Peek() == 'n');
  ------------------
  |  |  437|     38|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (857:9): [True: 38, False: 0]
  ------------------
  858|     38|        is.Take();
  859|       |
  860|     38|        if (RAPIDJSON_LIKELY(Consume(is, 'u') && Consume(is, 'l') && Consume(is, 'l'))) {
  ------------------
  |  |  492|    152|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 38, False: 0]
  |  |  |  Branch (492:49): [True: 38, False: 0]
  |  |  |  Branch (492:49): [True: 38, False: 0]
  |  |  |  Branch (492:49): [True: 38, False: 0]
  |  |  ------------------
  ------------------
  861|     38|            if (RAPIDJSON_UNLIKELY(!handler.Null()))
  ------------------
  |  |  505|     38|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 38]
  |  |  ------------------
  ------------------
  862|     38|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (862:17): [True: 0, False: 0]
  ------------------
  863|     38|        }
  864|      0|        else
  865|       |            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (865:13): [True: 0, False: 0]
  ------------------
  866|     38|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE9ParseTrueILj16ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  869|      5|    void ParseTrue(InputStream& is, Handler& handler) {
  870|      5|        RAPIDJSON_ASSERT(is.Peek() == 't');
  ------------------
  |  |  437|      5|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (870:9): [True: 5, False: 0]
  ------------------
  871|      5|        is.Take();
  872|       |
  873|      5|        if (RAPIDJSON_LIKELY(Consume(is, 'r') && Consume(is, 'u') && Consume(is, 'e'))) {
  ------------------
  |  |  492|     20|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 5, False: 0]
  |  |  |  Branch (492:49): [True: 5, False: 0]
  |  |  |  Branch (492:49): [True: 5, False: 0]
  |  |  |  Branch (492:49): [True: 5, False: 0]
  |  |  ------------------
  ------------------
  874|      5|            if (RAPIDJSON_UNLIKELY(!handler.Bool(true)))
  ------------------
  |  |  505|      5|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 5]
  |  |  ------------------
  ------------------
  875|      5|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (875:17): [True: 0, False: 0]
  ------------------
  876|      5|        }
  877|      0|        else
  878|       |            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (878:13): [True: 0, False: 0]
  ------------------
  879|      5|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE10ParseFalseILj16ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  882|    309|    void ParseFalse(InputStream& is, Handler& handler) {
  883|    309|        RAPIDJSON_ASSERT(is.Peek() == 'f');
  ------------------
  |  |  437|    309|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (883:9): [True: 309, False: 0]
  ------------------
  884|    309|        is.Take();
  885|       |
  886|    309|        if (RAPIDJSON_LIKELY(Consume(is, 'a') && Consume(is, 'l') && Consume(is, 's') && Consume(is, 'e'))) {
  ------------------
  |  |  492|  1.85k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 309, False: 0]
  |  |  |  Branch (492:49): [True: 309, False: 0]
  |  |  |  Branch (492:49): [True: 309, False: 0]
  |  |  |  Branch (492:49): [True: 309, False: 0]
  |  |  |  Branch (492:49): [True: 309, False: 0]
  |  |  ------------------
  ------------------
  887|    309|            if (RAPIDJSON_UNLIKELY(!handler.Bool(false)))
  ------------------
  |  |  505|    309|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 309]
  |  |  ------------------
  ------------------
  888|    309|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (888:17): [True: 0, False: 0]
  ------------------
  889|    309|        }
  890|      0|        else
  891|       |            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (891:13): [True: 0, False: 0]
  ------------------
  892|    309|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE11ParseStringILj16ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_b:
  959|   195k|    void ParseString(InputStream& is, Handler& handler, bool isKey = false) {
  960|   195k|        internal::StreamLocalCopy<InputStream> copy(is);
  961|   195k|        InputStream& s(copy.s);
  962|       |
  963|   195k|        RAPIDJSON_ASSERT(s.Peek() == '\"');
  ------------------
  |  |  437|   195k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (963:9): [True: 195k, False: 0]
  ------------------
  964|   195k|        s.Take();  // Skip '\"'
  965|       |
  966|   195k|        bool success = false;
  967|   195k|        if (parseFlags & kParseInsituFlag) {
  ------------------
  |  Branch (967:13): [Folded, False: 195k]
  ------------------
  968|      0|            typename InputStream::Ch *head = s.PutBegin();
  969|      0|            ParseStringToStream<parseFlags, SourceEncoding, SourceEncoding>(s, s);
  970|      0|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  971|      0|            size_t length = s.PutEnd(head) - 1;
  972|      0|            RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
  ------------------
  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (972:13): [True: 0, False: 0]
  ------------------
  973|      0|            const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
  974|      0|            success = (isKey ? handler.Key(str, SizeType(length), false) : handler.String(str, SizeType(length), false));
  ------------------
  |  Branch (974:24): [True: 0, False: 0]
  ------------------
  975|      0|        }
  976|   195k|        else {
  977|   195k|            StackStream<typename TargetEncoding::Ch> stackStream(stack_);
  978|   195k|            ParseStringToStream<parseFlags, SourceEncoding, TargetEncoding>(s, stackStream);
  979|   195k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   195k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   195k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   195k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   195k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   195k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 195k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   195k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   195k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   195k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 195k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  980|   195k|            SizeType length = static_cast<SizeType>(stackStream.Length()) - 1;
  981|   195k|            const typename TargetEncoding::Ch* const str = stackStream.Pop();
  982|   195k|            success = (isKey ? handler.Key(str, length, true) : handler.String(str, length, true));
  ------------------
  |  Branch (982:24): [True: 195k, False: 9]
  ------------------
  983|   195k|        }
  984|   195k|        if (RAPIDJSON_UNLIKELY(!success))
  ------------------
  |  |  505|   195k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 195k]
  |  |  ------------------
  ------------------
  985|       |            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (985:13): [True: 0, False: 0]
  ------------------
  986|   195k|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE19ParseStringToStreamILj16ES2_S2_NS_19GenericStringStreamIS2_EENS4_11StackStreamIcEEEEvRT2_RT3_:
  991|   195k|    RAPIDJSON_FORCEINLINE void ParseStringToStream(InputStream& is, OutputStream& os) {
  992|       |//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
  993|   195k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  994|   195k|        static const char escape[256] = {
  995|   195k|            Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '/',
  ------------------
  |  |  993|   195k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '/',
  ------------------
  |  |  993|   195k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
  996|   195k|            Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
  ------------------
  |  |  993|   195k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
  ------------------
  |  |  993|   195k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
  997|   195k|            0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0,
  998|   195k|            0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  999|   195k|            Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   195k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   195k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   195k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   195k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   195k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   195k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   195k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   195k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
 1000|   195k|        };
 1001|   195k|#undef Z16
 1002|       |//!@endcond
 1003|       |
 1004|   441k|        for (;;) {
 1005|       |            // Scan and copy string before "\\\"" or < 0x20. This is an optional optimzation.
 1006|   441k|            if (!(parseFlags & kParseValidateEncodingFlag))
  ------------------
  |  Branch (1006:17): [True: 441k, Folded]
  ------------------
 1007|   441k|                ScanCopyUnescapedString(is, os);
 1008|       |
 1009|   441k|            Ch c = is.Peek();
 1010|   441k|            if (RAPIDJSON_UNLIKELY(c == '\\')) {    // Escape
  ------------------
  |  |  505|   441k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 3.51k, False: 438k]
  |  |  ------------------
  ------------------
 1011|  3.51k|                size_t escapeOffset = is.Tell();    // For invalid escaping, report the initial '\\' as error offset
 1012|  3.51k|                is.Take();
 1013|  3.51k|                Ch e = is.Peek();
 1014|  3.51k|                if ((sizeof(Ch) == 1 || unsigned(e) < 256) && RAPIDJSON_LIKELY(escape[static_cast<unsigned char>(e)])) {
  ------------------
  |  |  492|  3.51k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 1.21k, False: 2.29k]
  |  |  ------------------
  ------------------
  |  Branch (1014:22): [True: 3.51k, Folded]
  |  Branch (1014:41): [True: 0, False: 0]
  ------------------
 1015|  1.21k|                    is.Take();
 1016|  1.21k|                    os.Put(static_cast<typename TEncoding::Ch>(escape[static_cast<unsigned char>(e)]));
 1017|  1.21k|                }
 1018|  2.29k|                else if ((parseFlags & kParseEscapedApostropheFlag) && RAPIDJSON_LIKELY(e == '\'')) { // Allow escaped apostrophe
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1018:26): [Folded, False: 2.29k]
  ------------------
 1019|      0|                    is.Take();
 1020|      0|                    os.Put('\'');
 1021|      0|                }
 1022|  2.29k|                else if (RAPIDJSON_LIKELY(e == 'u')) {    // Unicode
  ------------------
  |  |  492|  2.29k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 2.29k, False: 0]
  |  |  ------------------
  ------------------
 1023|  2.29k|                    is.Take();
 1024|  2.29k|                    unsigned codepoint = ParseHex4(is, escapeOffset);
 1025|  2.29k|                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  2.29k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  2.29k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  2.29k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  2.29k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  2.29k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 2.29k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  2.29k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  2.29k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  2.29k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 2.29k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1026|  2.29k|                    if (RAPIDJSON_UNLIKELY(codepoint >= 0xD800 && codepoint <= 0xDFFF)) {
  ------------------
  |  |  505|  4.58k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 2.08k, False: 204]
  |  |  |  Branch (505:51): [True: 2.29k, False: 1]
  |  |  |  Branch (505:51): [True: 2.08k, False: 203]
  |  |  ------------------
  ------------------
 1027|       |                        // high surrogate, check if followed by valid low surrogate
 1028|  2.08k|                        if (RAPIDJSON_LIKELY(codepoint <= 0xDBFF)) {
  ------------------
  |  |  492|  2.08k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 2.08k, False: 0]
  |  |  ------------------
  ------------------
 1029|       |                            // Handle UTF-16 surrogate pair
 1030|  2.08k|                            if (RAPIDJSON_UNLIKELY(!Consume(is, '\\') || !Consume(is, 'u')))
  ------------------
  |  |  505|  4.17k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 2.08k]
  |  |  |  Branch (505:51): [True: 0, False: 2.08k]
  |  |  |  Branch (505:51): [True: 0, False: 2.08k]
  |  |  ------------------
  ------------------
 1031|  2.08k|                                RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1031:33): [True: 0, False: 0]
  ------------------
 1032|  2.08k|                            unsigned codepoint2 = ParseHex4(is, escapeOffset);
 1033|  2.08k|                            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  2.08k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  2.08k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  2.08k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  2.08k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  2.08k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 2.08k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  2.08k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  2.08k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  2.08k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 2.08k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1034|  2.08k|                            if (RAPIDJSON_UNLIKELY(codepoint2 < 0xDC00 || codepoint2 > 0xDFFF))
  ------------------
  |  |  505|  4.17k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 2.08k]
  |  |  |  Branch (505:51): [True: 0, False: 2.08k]
  |  |  |  Branch (505:51): [True: 0, False: 2.08k]
  |  |  ------------------
  ------------------
 1035|  2.08k|                                RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1035:33): [True: 0, False: 0]
  ------------------
 1036|  2.08k|                            codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
 1037|  2.08k|                        }
 1038|       |                        // single low surrogate
 1039|      0|                        else
 1040|      0|                        {
 1041|      0|                            RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1041:29): [True: 0, False: 0]
  ------------------
 1042|      0|                        }
 1043|  2.08k|                    }
 1044|  2.29k|                    TEncoding::Encode(os, codepoint);
 1045|  2.29k|                }
 1046|      0|                else
 1047|  2.29k|                    RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, escapeOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1047:21): [True: 0, False: 0]
  ------------------
 1048|  3.51k|            }
 1049|   438k|            else if (RAPIDJSON_UNLIKELY(c == '"')) {    // Closing double quote
  ------------------
  |  |  505|   438k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 195k, False: 242k]
  |  |  ------------------
  ------------------
 1050|   195k|                is.Take();
 1051|   195k|                os.Put('\0');   // null-terminate the string
 1052|   195k|                return;
 1053|   195k|            }
 1054|   242k|            else if (RAPIDJSON_UNLIKELY(static_cast<unsigned>(c) < 0x20)) { // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
  ------------------
  |  |  505|   242k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 242k]
  |  |  ------------------
  ------------------
 1055|      0|                if (c == '\0')
  ------------------
  |  Branch (1055:21): [True: 0, False: 0]
  ------------------
 1056|      0|                    RAPIDJSON_PARSE_ERROR(kParseErrorStringMissQuotationMark, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1056:21): [True: 0, False: 0]
  ------------------
 1057|      0|                else
 1058|      0|                    RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1058:21): [True: 0, False: 0]
  ------------------
 1059|      0|            }
 1060|   242k|            else {
 1061|   242k|                size_t offset = is.Tell();
 1062|   242k|                if (RAPIDJSON_UNLIKELY((parseFlags & kParseValidateEncodingFlag ?
  ------------------
  |  |  505|   485k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 242k]
  |  |  |  Branch (505:51): [Folded, False: 242k]
  |  |  ------------------
  ------------------
 1063|   242k|                    !Transcoder<SEncoding, TEncoding>::Validate(is, os) :
 1064|   242k|                    !Transcoder<SEncoding, TEncoding>::Transcode(is, os))))
 1065|       |                    RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, offset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1065:21): [True: 0, False: 0]
  ------------------
 1066|   242k|            }
 1067|   441k|        }
 1068|   195k|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE11ParseObjectILj16ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  740|  7.55k|    void ParseObject(InputStream& is, Handler& handler) {
  741|  7.55k|        RAPIDJSON_ASSERT(is.Peek() == '{');
  ------------------
  |  |  437|  7.55k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (741:9): [True: 7.55k, False: 0]
  ------------------
  742|  7.55k|        is.Take();  // Skip '{'
  743|       |
  744|  7.55k|        if (RAPIDJSON_UNLIKELY(!handler.StartObject()))
  ------------------
  |  |  505|  7.55k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 7.55k]
  |  |  ------------------
  ------------------
  745|  7.55k|            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (745:13): [True: 0, False: 0]
  ------------------
  746|       |
  747|  7.55k|        SkipWhitespaceAndComments<parseFlags>(is);
  748|  7.55k|        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  7.55k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  7.55k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  7.55k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  7.55k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  7.55k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 7.55k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  7.55k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  7.55k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  7.55k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 7.55k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  749|       |
  750|  7.55k|        if (Consume(is, '}')) {
  ------------------
  |  Branch (750:13): [True: 3.76k, False: 3.79k]
  ------------------
  751|  3.76k|            if (RAPIDJSON_UNLIKELY(!handler.EndObject(0)))  // empty object
  ------------------
  |  |  505|  3.76k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 3.76k]
  |  |  ------------------
  ------------------
  752|  3.76k|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (752:17): [True: 0, False: 0]
  ------------------
  753|  3.76k|            return;
  754|  3.76k|        }
  755|       |
  756|   195k|        for (SizeType memberCount = 0;;) {
  757|   195k|            if (RAPIDJSON_UNLIKELY(is.Peek() != '"'))
  ------------------
  |  |  505|   195k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 195k]
  |  |  ------------------
  ------------------
  758|   195k|                RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (758:17): [True: 0, False: 0]
  ------------------
  759|       |
  760|   195k|            ParseString<parseFlags>(is, handler, true);
  761|   195k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   195k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   195k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   195k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   195k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   195k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 195k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   195k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   195k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   195k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 195k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  762|       |
  763|   195k|            SkipWhitespaceAndComments<parseFlags>(is);
  764|   195k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   195k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   195k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   195k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   195k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   195k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 195k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   195k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   195k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   195k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 195k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  765|       |
  766|   195k|            if (RAPIDJSON_UNLIKELY(!Consume(is, ':')))
  ------------------
  |  |  505|   195k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 195k]
  |  |  ------------------
  ------------------
  767|   195k|                RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (767:17): [True: 0, False: 0]
  ------------------
  768|       |
  769|   195k|            SkipWhitespaceAndComments<parseFlags>(is);
  770|   195k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   195k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   195k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   195k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   195k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   195k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 195k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   195k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   195k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   195k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 195k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  771|       |
  772|   195k|            ParseValue<parseFlags>(is, handler);
  773|   195k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   195k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   195k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   195k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   195k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   195k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 195k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   195k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   195k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   195k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 195k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  774|       |
  775|   195k|            SkipWhitespaceAndComments<parseFlags>(is);
  776|   195k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   195k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   195k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   195k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   195k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   195k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 195k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   195k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   195k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   195k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 195k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  777|       |
  778|   195k|            ++memberCount;
  779|       |
  780|   195k|            switch (is.Peek()) {
  781|   191k|                case ',':
  ------------------
  |  Branch (781:17): [True: 191k, False: 3.79k]
  ------------------
  782|   191k|                    is.Take();
  783|   191k|                    SkipWhitespaceAndComments<parseFlags>(is);
  784|   191k|                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   191k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   191k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   191k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   191k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   191k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 191k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   191k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   191k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   191k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 191k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  785|   191k|                    break;
  786|   191k|                case '}':
  ------------------
  |  Branch (786:17): [True: 3.79k, False: 191k]
  ------------------
  787|  3.79k|                    is.Take();
  788|  3.79k|                    if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
  ------------------
  |  |  505|  3.79k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 3.79k]
  |  |  ------------------
  ------------------
  789|  3.79k|                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (789:25): [True: 0, False: 0]
  ------------------
  790|  3.79k|                    return;
  791|  3.79k|                default:
  ------------------
  |  Branch (791:17): [True: 0, False: 195k]
  ------------------
  792|      0|                    RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); break; // This useless break is only for making warning and coverage happy
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (792:21): [True: 0, False: 0]
  ------------------
  793|   195k|            }
  794|       |
  795|   191k|            if (parseFlags & kParseTrailingCommasFlag) {
  ------------------
  |  Branch (795:17): [Folded, False: 191k]
  ------------------
  796|      0|                if (is.Peek() == '}') {
  ------------------
  |  Branch (796:21): [True: 0, False: 0]
  ------------------
  797|      0|                    if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  798|      0|                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (798:25): [True: 0, False: 0]
  ------------------
  799|      0|                    is.Take();
  800|      0|                    return;
  801|      0|                }
  802|      0|            }
  803|   191k|        }
  804|  3.79k|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE10ParseArrayILj16ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  808|  8.80k|    void ParseArray(InputStream& is, Handler& handler) {
  809|  8.80k|        RAPIDJSON_ASSERT(is.Peek() == '[');
  ------------------
  |  |  437|  8.80k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (809:9): [True: 8.80k, False: 0]
  ------------------
  810|  8.80k|        is.Take();  // Skip '['
  811|       |
  812|  8.80k|        if (RAPIDJSON_UNLIKELY(!handler.StartArray()))
  ------------------
  |  |  505|  8.80k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 8.80k]
  |  |  ------------------
  ------------------
  813|  8.80k|            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (813:13): [True: 0, False: 0]
  ------------------
  814|       |
  815|  8.80k|        SkipWhitespaceAndComments<parseFlags>(is);
  816|  8.80k|        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  8.80k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  8.80k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  8.80k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  8.80k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  8.80k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 8.80k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  8.80k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  8.80k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  8.80k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 8.80k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  817|       |
  818|  8.80k|        if (Consume(is, ']')) {
  ------------------
  |  Branch (818:13): [True: 8, False: 8.79k]
  ------------------
  819|      8|            if (RAPIDJSON_UNLIKELY(!handler.EndArray(0))) // empty array
  ------------------
  |  |  505|      8|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 8]
  |  |  ------------------
  ------------------
  820|      8|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (820:17): [True: 0, False: 0]
  ------------------
  821|      8|            return;
  822|      8|        }
  823|       |
  824|  2.99M|        for (SizeType elementCount = 0;;) {
  825|  2.99M|            ParseValue<parseFlags>(is, handler);
  826|  2.99M|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  2.99M|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  2.99M|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  2.99M|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  2.99M|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  2.99M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 1.18k, False: 2.99M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  2.99M|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  2.99M|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  2.99M|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 2.99M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  827|       |
  828|  2.99M|            ++elementCount;
  829|  2.99M|            SkipWhitespaceAndComments<parseFlags>(is);
  830|  2.99M|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  2.99M|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  2.99M|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  2.99M|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  2.99M|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  2.99M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 2.99M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  2.99M|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  2.99M|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  2.99M|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 2.99M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  831|       |
  832|  2.99M|            if (Consume(is, ',')) {
  ------------------
  |  Branch (832:17): [True: 2.98M, False: 7.61k]
  ------------------
  833|  2.98M|                SkipWhitespaceAndComments<parseFlags>(is);
  834|  2.98M|                RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  2.98M|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  2.98M|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  2.98M|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  2.98M|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  2.98M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 2.98M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  2.98M|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  2.98M|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  2.98M|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 2.98M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  835|  2.98M|            }
  836|  7.61k|            else if (Consume(is, ']')) {
  ------------------
  |  Branch (836:22): [True: 7.61k, False: 3]
  ------------------
  837|  7.61k|                if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
  ------------------
  |  |  505|  7.61k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 7.61k]
  |  |  ------------------
  ------------------
  838|  7.61k|                    RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (838:21): [True: 0, False: 0]
  ------------------
  839|  7.61k|                return;
  840|  7.61k|            }
  841|      3|            else
  842|  7.61k|                RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
  ------------------
  |  |  120|      6|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      3|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      6|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      3|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      3|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      3|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      3|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      3|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      3|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      3|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      3|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 3]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      6|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      3|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      6|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      3|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      6|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      3|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 3, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      6|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      3|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      3|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      3|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      3|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      3|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (842:17): [True: 3, False: 0]
  ------------------
  843|       |
  844|  2.98M|            if (parseFlags & kParseTrailingCommasFlag) {
  ------------------
  |  Branch (844:17): [Folded, False: 2.98M]
  ------------------
  845|      0|                if (is.Peek() == ']') {
  ------------------
  |  Branch (845:21): [True: 0, False: 0]
  ------------------
  846|      0|                    if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  847|      0|                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (847:25): [True: 0, False: 0]
  ------------------
  848|      0|                    is.Take();
  849|      0|                    return;
  850|      0|                }
  851|      0|            }
  852|  2.98M|        }
  853|  8.79k|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE11ParseNumberILj16ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
 1468|  3.17M|    void ParseNumber(InputStream& is, Handler& handler) {
 1469|  3.17M|        typedef typename internal::SelectIf<internal::BoolType<(parseFlags & kParseNumbersAsStringsFlag) != 0>, typename TargetEncoding::Ch, char>::Type NumberCharacter;
 1470|       |
 1471|  3.17M|        internal::StreamLocalCopy<InputStream> copy(is);
 1472|  3.17M|        NumberStream<InputStream, NumberCharacter,
 1473|  3.17M|            ((parseFlags & kParseNumbersAsStringsFlag) != 0) ?
 1474|  3.17M|                ((parseFlags & kParseInsituFlag) == 0) :
 1475|  3.17M|                ((parseFlags & kParseFullPrecisionFlag) != 0),
 1476|  3.17M|            (parseFlags & kParseNumbersAsStringsFlag) != 0 &&
 1477|  3.17M|                (parseFlags & kParseInsituFlag) == 0> s(*this, copy.s);
 1478|       |
 1479|  3.17M|        size_t startOffset = s.Tell();
 1480|  3.17M|        double d = 0.0;
 1481|  3.17M|        bool useNanOrInf = false;
 1482|       |
 1483|       |        // Parse minus
 1484|  3.17M|        bool minus = Consume(s, '-');
 1485|       |
 1486|       |        // Parse int: zero / ( digit1-9 *DIGIT )
 1487|  3.17M|        unsigned i = 0;
 1488|  3.17M|        uint64_t i64 = 0;
 1489|  3.17M|        bool use64bit = false;
 1490|  3.17M|        int significandDigit = 0;
 1491|  3.17M|        if (RAPIDJSON_UNLIKELY(s.Peek() == '0')) {
  ------------------
  |  |  505|  3.17M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 77.5k, False: 3.09M]
  |  |  ------------------
  ------------------
 1492|  77.5k|            i = 0;
 1493|  77.5k|            s.TakePush();
 1494|  77.5k|        }
 1495|  3.09M|        else if (RAPIDJSON_LIKELY(s.Peek() >= '1' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  6.19M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 3.09M, False: 5]
  |  |  |  Branch (492:49): [True: 3.09M, False: 1]
  |  |  |  Branch (492:49): [True: 3.09M, False: 4]
  |  |  ------------------
  ------------------
 1496|  3.09M|            i = static_cast<unsigned>(s.TakePush() - '0');
 1497|       |
 1498|  3.09M|            if (minus)
  ------------------
  |  Branch (1498:17): [True: 1.85k, False: 3.09M]
  ------------------
 1499|  5.04k|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  8.32k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 3.28k, False: 1.76k]
  |  |  |  Branch (492:49): [True: 3.28k, False: 1.76k]
  |  |  |  Branch (492:49): [True: 3.28k, False: 1]
  |  |  ------------------
  ------------------
 1500|  3.28k|                    if (RAPIDJSON_UNLIKELY(i >= 214748364)) { // 2^31 = 2147483648
  ------------------
  |  |  505|  3.28k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 87, False: 3.19k]
  |  |  ------------------
  ------------------
 1501|     87|                        if (RAPIDJSON_LIKELY(i != 214748364 || s.Peek() > '8')) {
  ------------------
  |  |  492|     87|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 87, False: 0]
  |  |  |  Branch (492:49): [True: 87, False: 0]
  |  |  |  Branch (492:49): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1502|     87|                            i64 = i;
 1503|     87|                            use64bit = true;
 1504|     87|                            break;
 1505|     87|                        }
 1506|     87|                    }
 1507|  3.19k|                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1508|  3.19k|                    significandDigit++;
 1509|  3.19k|                }
 1510|  3.09M|            else
 1511|  3.23M|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  3.38M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 144k, False: 3.08M]
  |  |  |  Branch (492:49): [True: 151k, False: 3.07M]
  |  |  |  Branch (492:49): [True: 144k, False: 7.24k]
  |  |  ------------------
  ------------------
 1512|   144k|                    if (RAPIDJSON_UNLIKELY(i >= 429496729)) { // 2^32 - 1 = 4294967295
  ------------------
  |  |  505|   144k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 10.5k, False: 133k]
  |  |  ------------------
  ------------------
 1513|  10.5k|                        if (RAPIDJSON_LIKELY(i != 429496729 || s.Peek() > '5')) {
  ------------------
  |  |  492|  11.0k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 10.0k, False: 470]
  |  |  |  Branch (492:49): [True: 10.0k, False: 475]
  |  |  |  Branch (492:49): [True: 5, False: 470]
  |  |  ------------------
  ------------------
 1514|  10.0k|                            i64 = i;
 1515|  10.0k|                            use64bit = true;
 1516|  10.0k|                            break;
 1517|  10.0k|                        }
 1518|  10.5k|                    }
 1519|   134k|                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1520|   134k|                    significandDigit++;
 1521|   134k|                }
 1522|  3.09M|        }
 1523|       |        // Parse NaN or Infinity here
 1524|      5|        else if ((parseFlags & kParseNanAndInfFlag) && RAPIDJSON_LIKELY((s.Peek() == 'I' || s.Peek() == 'N'))) {
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  |  Branch (492:49): [True: 0, False: 0]
  |  |  |  Branch (492:49): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1524:18): [Folded, False: 5]
  ------------------
 1525|      0|            if (Consume(s, 'N')) {
  ------------------
  |  Branch (1525:17): [True: 0, False: 0]
  ------------------
 1526|      0|                if (Consume(s, 'a') && Consume(s, 'N')) {
  ------------------
  |  Branch (1526:21): [True: 0, False: 0]
  |  Branch (1526:40): [True: 0, False: 0]
  ------------------
 1527|      0|                    d = std::numeric_limits<double>::quiet_NaN();
 1528|      0|                    useNanOrInf = true;
 1529|      0|                }
 1530|      0|            }
 1531|      0|            else if (RAPIDJSON_LIKELY(Consume(s, 'I'))) {
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1532|      0|                if (Consume(s, 'n') && Consume(s, 'f')) {
  ------------------
  |  Branch (1532:21): [True: 0, False: 0]
  |  Branch (1532:40): [True: 0, False: 0]
  ------------------
 1533|      0|                    d = (minus ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity());
  ------------------
  |  Branch (1533:26): [True: 0, False: 0]
  ------------------
 1534|      0|                    useNanOrInf = true;
 1535|       |
 1536|      0|                    if (RAPIDJSON_UNLIKELY(s.Peek() == 'i' && !(Consume(s, 'i') && Consume(s, 'n')
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1537|      0|                                                                && Consume(s, 'i') && Consume(s, 't') && Consume(s, 'y')))) {
 1538|      0|                        RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1538:25): [True: 0, False: 0]
  ------------------
 1539|      0|                    }
 1540|      0|                }
 1541|      0|            }
 1542|       |
 1543|      0|            if (RAPIDJSON_UNLIKELY(!useNanOrInf)) {
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1544|      0|                RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1544:17): [True: 0, False: 0]
  ------------------
 1545|      0|            }
 1546|      0|        }
 1547|      5|        else
 1548|      5|            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
  ------------------
  |  |  120|     10|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      5|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|     10|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      5|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      5|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      5|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      5|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      5|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      5|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      5|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      5|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|     10|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      5|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|     10|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      5|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|     10|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      5|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 5, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|     10|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      5|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      5|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      5|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      5|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      5|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1548:13): [True: 5, False: 0]
  ------------------
 1549|       |
 1550|       |        // Parse 64bit int
 1551|  3.17M|        bool useDouble = false;
 1552|  3.17M|        if (use64bit) {
  ------------------
  |  Branch (1552:13): [True: 10.1k, False: 3.16M]
  ------------------
 1553|  10.1k|            if (minus)
  ------------------
  |  Branch (1553:17): [True: 87, False: 10.0k]
  ------------------
 1554|    248|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|    414|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 166, False: 82]
  |  |  |  Branch (492:49): [True: 166, False: 82]
  |  |  |  Branch (492:49): [True: 166, False: 0]
  |  |  ------------------
  ------------------
 1555|    166|                     if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC))) // 2^63 = 9223372036854775808
  ------------------
  |  |  505|    166|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 5, False: 161]
  |  |  ------------------
  ------------------
 1556|      5|                        if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC) || s.Peek() > '8')) {
  ------------------
  |  |  492|      5|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 5, False: 0]
  |  |  |  Branch (492:49): [True: 5, False: 0]
  |  |  |  Branch (492:49): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1557|      5|                            d = static_cast<double>(i64);
 1558|      5|                            useDouble = true;
 1559|      5|                            break;
 1560|      5|                        }
 1561|    161|                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1562|    161|                    significandDigit++;
 1563|    161|                }
 1564|  10.0k|            else
 1565|  82.2k|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|   157k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 74.6k, False: 7.65k]
  |  |  |  Branch (492:49): [True: 74.7k, False: 7.56k]
  |  |  |  Branch (492:49): [True: 74.6k, False: 88]
  |  |  ------------------
  ------------------
 1566|  74.6k|                    if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999))) // 2^64 - 1 = 18446744073709551615
  ------------------
  |  |  505|  74.6k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 2.41k, False: 72.2k]
  |  |  ------------------
  ------------------
 1567|  2.41k|                        if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || s.Peek() > '5')) {
  ------------------
  |  |  492|  2.42k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 2.41k, False: 4]
  |  |  |  Branch (492:49): [True: 2.41k, False: 4]
  |  |  |  Branch (492:49): [True: 0, False: 4]
  |  |  ------------------
  ------------------
 1568|  2.41k|                            d = static_cast<double>(i64);
 1569|  2.41k|                            useDouble = true;
 1570|  2.41k|                            break;
 1571|  2.41k|                        }
 1572|  72.2k|                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1573|  72.2k|                    significandDigit++;
 1574|  72.2k|                }
 1575|  10.1k|        }
 1576|       |
 1577|       |        // Force double for big integer
 1578|  3.17M|        if (useDouble) {
  ------------------
  |  Branch (1578:13): [True: 2.42k, False: 3.17M]
  ------------------
 1579|  1.94M|            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  3.89M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 1.94M, False: 2.42k]
  |  |  |  Branch (492:49): [True: 1.94M, False: 2.38k]
  |  |  |  Branch (492:49): [True: 1.94M, False: 35]
  |  |  ------------------
  ------------------
 1580|  1.94M|                d = d * 10 + (s.TakePush() - '0');
 1581|  1.94M|            }
 1582|  2.42k|        }
 1583|       |
 1584|       |        // Parse frac = decimal-point 1*DIGIT
 1585|  3.17M|        int expFrac = 0;
 1586|  3.17M|        size_t decimalPosition;
 1587|  3.17M|        if (!useNanOrInf && Consume(s, '.')) {
  ------------------
  |  Branch (1587:13): [True: 3.17M, False: 0]
  |  Branch (1587:29): [True: 12.0k, False: 3.16M]
  ------------------
 1588|  12.0k|            decimalPosition = s.Length();
 1589|       |
 1590|  12.0k|            if (RAPIDJSON_UNLIKELY(!(s.Peek() >= '0' && s.Peek() <= '9')))
  ------------------
  |  |  505|  24.0k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 12.0k]
  |  |  |  Branch (505:51): [True: 12.0k, False: 0]
  |  |  |  Branch (505:51): [True: 12.0k, False: 0]
  |  |  ------------------
  ------------------
 1591|  12.0k|                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1591:17): [True: 0, False: 0]
  ------------------
 1592|       |
 1593|  12.0k|            if (!useDouble) {
  ------------------
  |  Branch (1593:17): [True: 11.5k, False: 452]
  ------------------
 1594|  11.5k|#if RAPIDJSON_64BIT
 1595|       |                // Use i64 to store significand in 64-bit architecture
 1596|  11.5k|                if (!use64bit)
  ------------------
  |  Branch (1596:21): [True: 11.3k, False: 161]
  ------------------
 1597|  11.3k|                    i64 = i;
 1598|       |
 1599|   419k|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|   827k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 407k, False: 11.5k]
  |  |  |  Branch (492:49): [True: 408k, False: 11.2k]
  |  |  |  Branch (492:49): [True: 407k, False: 266]
  |  |  ------------------
  ------------------
 1600|   407k|                    if (i64 > RAPIDJSON_UINT64_C2(0x1FFFFF, 0xFFFFFFFF)) // 2^53 - 1 for fast path
  ------------------
  |  |  320|   407k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  |  Branch (1600:25): [True: 28, False: 407k]
  ------------------
 1601|     28|                        break;
 1602|   407k|                    else {
 1603|   407k|                        i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1604|   407k|                        --expFrac;
 1605|   407k|                        if (i64 != 0)
  ------------------
  |  Branch (1605:29): [True: 11.9k, False: 395k]
  ------------------
 1606|  11.9k|                            significandDigit++;
 1607|   407k|                    }
 1608|   407k|                }
 1609|       |
 1610|  11.5k|                d = static_cast<double>(i64);
 1611|       |#else
 1612|       |                // Use double to store significand in 32-bit architecture
 1613|       |                d = static_cast<double>(use64bit ? i64 : i);
 1614|       |#endif
 1615|  11.5k|                useDouble = true;
 1616|  11.5k|            }
 1617|       |
 1618|  7.18M|            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  14.3M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 7.17M, False: 12.0k]
  |  |  |  Branch (492:49): [True: 7.17M, False: 11.2k]
  |  |  |  Branch (492:49): [True: 7.17M, False: 735]
  |  |  ------------------
  ------------------
 1619|  7.17M|                if (significandDigit < 17) {
  ------------------
  |  Branch (1619:21): [True: 21, False: 7.17M]
  ------------------
 1620|     21|                    d = d * 10.0 + (s.TakePush() - '0');
 1621|     21|                    --expFrac;
 1622|     21|                    if (RAPIDJSON_LIKELY(d > 0.0))
  ------------------
  |  |  492|     21|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 21, False: 0]
  |  |  ------------------
  ------------------
 1623|     21|                        significandDigit++;
 1624|     21|                }
 1625|  7.17M|                else
 1626|  7.17M|                    s.TakePush();
 1627|  7.17M|            }
 1628|  12.0k|        }
 1629|  3.16M|        else
 1630|  3.16M|            decimalPosition = s.Length(); // decimal position at the end of integer.
 1631|       |
 1632|       |        // Parse exp = e [ minus / plus ] 1*DIGIT
 1633|  3.17M|        int exp = 0;
 1634|  3.17M|        if (!useNanOrInf && (Consume(s, 'e') || Consume(s, 'E'))) {
  ------------------
  |  Branch (1634:13): [True: 3.17M, False: 0]
  |  Branch (1634:30): [True: 635, False: 3.17M]
  |  Branch (1634:49): [True: 7.42k, False: 3.16M]
  ------------------
 1635|  8.06k|            if (!useDouble) {
  ------------------
  |  Branch (1635:17): [True: 7.29k, False: 768]
  ------------------
 1636|  7.29k|                d = static_cast<double>(use64bit ? i64 : i);
  ------------------
  |  Branch (1636:41): [True: 88, False: 7.20k]
  ------------------
 1637|  7.29k|                useDouble = true;
 1638|  7.29k|            }
 1639|       |
 1640|  8.06k|            bool expMinus = false;
 1641|  8.06k|            if (Consume(s, '+'))
  ------------------
  |  Branch (1641:17): [True: 0, False: 8.06k]
  ------------------
 1642|      0|                ;
 1643|  8.06k|            else if (Consume(s, '-'))
  ------------------
  |  Branch (1643:22): [True: 600, False: 7.46k]
  ------------------
 1644|    600|                expMinus = true;
 1645|       |
 1646|  8.06k|            if (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  16.1k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 8.06k, False: 0]
  |  |  |  Branch (492:49): [True: 8.06k, False: 0]
  |  |  |  Branch (492:49): [True: 8.06k, False: 0]
  |  |  ------------------
  ------------------
 1647|  8.06k|                exp = static_cast<int>(s.Take() - '0');
 1648|  8.06k|                if (expMinus) {
  ------------------
  |  Branch (1648:21): [True: 600, False: 7.46k]
  ------------------
 1649|       |                    // (exp + expFrac) must not underflow int => we're detecting when -exp gets
 1650|       |                    // dangerously close to INT_MIN (a pessimistic next digit 9 would push it into
 1651|       |                    // underflow territory):
 1652|       |                    //
 1653|       |                    //        -(exp * 10 + 9) + expFrac >= INT_MIN
 1654|       |                    //   <=>  exp <= (expFrac - INT_MIN - 9) / 10
 1655|    600|                    RAPIDJSON_ASSERT(expFrac <= 0);
  ------------------
  |  |  437|    600|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (1655:21): [True: 600, False: 0]
  ------------------
 1656|    600|                    int maxExp = (expFrac + 2147483639) / 10;
 1657|       |
 1658|   855k|                    while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  1.70M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 854k, False: 600]
  |  |  |  Branch (492:49): [True: 854k, False: 599]
  |  |  |  Branch (492:49): [True: 854k, False: 1]
  |  |  ------------------
  ------------------
 1659|   854k|                        exp = exp * 10 + static_cast<int>(s.Take() - '0');
 1660|   854k|                        if (RAPIDJSON_UNLIKELY(exp > maxExp)) {
  ------------------
  |  |  505|   854k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 5, False: 854k]
  |  |  ------------------
  ------------------
 1661|     13|                            while (RAPIDJSON_UNLIKELY(s.Peek() >= '0' && s.Peek() <= '9'))  // Consume the rest of exponent
  ------------------
  |  |  505|     21|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 8, False: 5]
  |  |  |  Branch (505:51): [True: 8, False: 5]
  |  |  |  Branch (505:51): [True: 8, False: 0]
  |  |  ------------------
  ------------------
 1662|      8|                                s.Take();
 1663|      5|                        }
 1664|   854k|                    }
 1665|    600|                }
 1666|  7.46k|                else {  // positive exp
 1667|  7.46k|                    int maxExp = 308 - expFrac;
 1668|   491k|                    while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|   976k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 484k, False: 7.46k]
  |  |  |  Branch (492:49): [True: 484k, False: 7.46k]
  |  |  |  Branch (492:49): [True: 484k, False: 0]
  |  |  ------------------
  ------------------
 1669|   484k|                        exp = exp * 10 + static_cast<int>(s.Take() - '0');
 1670|   484k|                        if (RAPIDJSON_UNLIKELY(exp > maxExp))
  ------------------
  |  |  505|   484k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 1, False: 484k]
  |  |  ------------------
  ------------------
 1671|   484k|                            RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
  ------------------
  |  |  120|      2|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      2|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      1|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      1|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      1|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      1|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 1]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      2|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      1|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      2|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      2|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      1|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 1, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      2|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1671:29): [True: 1, False: 0]
  ------------------
 1672|   484k|                    }
 1673|  7.46k|                }
 1674|  8.06k|            }
 1675|      0|            else
 1676|  8.06k|                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissExponent, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1676:17): [True: 0, False: 0]
  ------------------
 1677|       |
 1678|  8.06k|            if (expMinus)
  ------------------
  |  Branch (1678:17): [True: 600, False: 7.46k]
  ------------------
 1679|    600|                exp = -exp;
 1680|  8.06k|        }
 1681|       |
 1682|       |        // Finish parsing, call event according to the type of number.
 1683|  3.17M|        bool cont = true;
 1684|       |
 1685|  3.17M|        if (parseFlags & kParseNumbersAsStringsFlag) {
  ------------------
  |  Branch (1685:13): [Folded, False: 3.17M]
  ------------------
 1686|      0|            if (parseFlags & kParseInsituFlag) {
  ------------------
  |  Branch (1686:17): [Folded, False: 0]
  ------------------
 1687|      0|                s.Pop();  // Pop stack no matter if it will be used or not.
 1688|      0|                typename InputStream::Ch* head = is.PutBegin();
 1689|      0|                const size_t length = s.Tell() - startOffset;
 1690|      0|                RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
  ------------------
  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (1690:17): [True: 0, False: 0]
  ------------------
 1691|       |                // unable to insert the \0 character here, it will erase the comma after this number
 1692|      0|                const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
 1693|      0|                cont = handler.RawNumber(str, SizeType(length), false);
 1694|      0|            }
 1695|      0|            else {
 1696|      0|                SizeType numCharsToCopy = static_cast<SizeType>(s.Length());
 1697|      0|                GenericStringStream<UTF8<NumberCharacter> > srcStream(s.Pop());
 1698|      0|                StackStream<typename TargetEncoding::Ch> dstStream(stack_);
 1699|      0|                while (numCharsToCopy--) {
  ------------------
  |  Branch (1699:24): [True: 0, False: 0]
  ------------------
 1700|      0|                    Transcoder<UTF8<typename TargetEncoding::Ch>, TargetEncoding>::Transcode(srcStream, dstStream);
 1701|      0|                }
 1702|      0|                dstStream.Put('\0');
 1703|      0|                const typename TargetEncoding::Ch* str = dstStream.Pop();
 1704|      0|                const SizeType length = static_cast<SizeType>(dstStream.Length()) - 1;
 1705|      0|                cont = handler.RawNumber(str, SizeType(length), true);
 1706|      0|            }
 1707|      0|        }
 1708|  3.17M|        else {
 1709|  3.17M|           size_t length = s.Length();
 1710|  3.17M|           const NumberCharacter* decimal = s.Pop();  // Pop stack no matter if it will be used or not.
 1711|       |
 1712|  3.17M|           if (useDouble) {
  ------------------
  |  Branch (1712:16): [True: 21.2k, False: 3.15M]
  ------------------
 1713|  21.2k|               int p = exp + expFrac;
 1714|  21.2k|               if (parseFlags & kParseFullPrecisionFlag)
  ------------------
  |  Branch (1714:20): [True: 21.2k, Folded]
  ------------------
 1715|  21.2k|                   d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp);
 1716|      0|               else
 1717|      0|                   d = internal::StrtodNormalPrecision(d, p);
 1718|       |
 1719|       |               // Use > max, instead of == inf, to fix bogus warning -Wfloat-equal
 1720|  21.2k|               if (d > (std::numeric_limits<double>::max)()) {
  ------------------
  |  Branch (1720:20): [True: 3, False: 21.2k]
  ------------------
 1721|       |                   // Overflow
 1722|       |                   // TODO: internal::StrtodX should report overflow (or underflow)
 1723|      3|                   RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
  ------------------
  |  |  120|      3|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      3|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      3|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      3|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      3|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      3|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      3|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      3|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      3|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      3|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      3|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 3]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      3|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      3|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      6|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      3|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      6|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      3|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 3, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      6|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      3|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      3|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      3|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      3|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      3|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1723:20): [True: 3, False: 0]
  ------------------
 1724|      3|               }
 1725|       |
 1726|  21.2k|               cont = handler.Double(minus ? -d : d);
  ------------------
  |  Branch (1726:38): [True: 6, False: 21.2k]
  ------------------
 1727|  21.2k|           }
 1728|  3.15M|           else if (useNanOrInf) {
  ------------------
  |  Branch (1728:21): [True: 0, False: 3.15M]
  ------------------
 1729|      0|               cont = handler.Double(d);
 1730|      0|           }
 1731|  3.15M|           else {
 1732|  3.15M|               if (use64bit) {
  ------------------
  |  Branch (1732:20): [True: 7.48k, False: 3.14M]
  ------------------
 1733|  7.48k|                   if (minus)
  ------------------
  |  Branch (1733:24): [True: 82, False: 7.40k]
  ------------------
 1734|     82|                       cont = handler.Int64(static_cast<int64_t>(~i64 + 1));
 1735|  7.40k|                   else
 1736|  7.40k|                       cont = handler.Uint64(i64);
 1737|  7.48k|               }
 1738|  3.14M|               else {
 1739|  3.14M|                   if (minus)
  ------------------
  |  Branch (1739:24): [True: 2.04k, False: 3.14M]
  ------------------
 1740|  2.04k|                       cont = handler.Int(static_cast<int32_t>(~i + 1));
 1741|  3.14M|                   else
 1742|  3.14M|                       cont = handler.Uint(i);
 1743|  3.14M|               }
 1744|  3.15M|           }
 1745|  3.17M|        }
 1746|  3.17M|        if (RAPIDJSON_UNLIKELY(!cont))
  ------------------
  |  |  505|  3.17M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 3.17M]
  |  |  ------------------
  ------------------
 1747|       |            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, startOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1747:13): [True: 0, False: 0]
  ------------------
 1748|  3.17M|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE12NumberStreamINS_19GenericStringStreamIS2_EEcLb1ELb0EEC2ERS4_RS7_:
 1436|  6.40M|        NumberStream(GenericReader& reader, InputStream& s) : Base(reader, s), stackStream(reader.stack_) {}
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE7ConsumeINS4_12NumberStreamINS_19GenericStringStreamIS2_EEcLb1ELb0EEEEEbRT_NSA_2ChE:
  895|  12.7M|    RAPIDJSON_FORCEINLINE static bool Consume(InputStream& is, typename InputStream::Ch expect) {
  896|  12.7M|        if (RAPIDJSON_LIKELY(is.Peek() == expect)) {
  ------------------
  |  |  492|  12.7M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 22.7k, False: 12.6M]
  |  |  ------------------
  ------------------
  897|  22.7k|            is.Take();
  898|  22.7k|            return true;
  899|  22.7k|        }
  900|  12.6M|        else
  901|  12.6M|            return false;
  902|  12.7M|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE12NumberStreamINS_19GenericStringStreamIS2_EEcLb1ELb0EE8TakePushEv:
 1438|  27.2M|        RAPIDJSON_FORCEINLINE Ch TakePush() {
 1439|  27.2M|            stackStream.Put(static_cast<StackCharacter>(Base::is.Peek()));
 1440|  27.2M|            return Base::is.Take();
 1441|  27.2M|        }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE12NumberStreamINS_19GenericStringStreamIS2_EEcLb1ELb0EE6LengthEv:
 1447|  12.8M|        size_t Length() { return stackStream.Length(); }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE12NumberStreamINS_19GenericStringStreamIS2_EEcLb1ELb0EE3PopEv:
 1449|  6.40M|        const StackCharacter* Pop() {
 1450|  6.40M|            stackStream.Put('\0');
 1451|  6.40M|            return stackStream.Pop();
 1452|  6.40M|        }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE5ParseILj64ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEENS_11ParseResultERT0_RT1_:
  559|     26|    ParseResult Parse(InputStream& is, Handler& handler) {
  560|     26|        if (parseFlags & kParseIterativeFlag)
  ------------------
  |  Branch (560:13): [Folded, False: 26]
  ------------------
  561|      0|            return IterativeParse<parseFlags>(is, handler);
  562|       |
  563|     26|        parseResult_.Clear();
  564|       |
  565|     26|        ClearStackOnExit scope(*this);
  566|       |
  567|     26|        SkipWhitespaceAndComments<parseFlags>(is);
  568|     26|        RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|     26|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|     26|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|     26|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|     26|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 0, False: 26]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|     26|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|     26|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|     26|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 26]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  569|       |
  570|     26|        if (RAPIDJSON_UNLIKELY(is.Peek() == '\0')) {
  ------------------
  |  |  505|     26|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 1, False: 25]
  |  |  ------------------
  ------------------
  571|      1|            RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentEmpty, is.Tell());
  ------------------
  |  |  101|      1|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  102|      1|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  ------------------
  |  |  |  |  437|      1|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  ------------------
  |  |  103|      1|    SetParseError(parseErrorCode, offset); \
  |  |  104|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (571:13): [True: 1, False: 0]
  ------------------
  572|      1|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|      2|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|      2|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|      1|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 1, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      2|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  573|      1|        }
  574|     25|        else {
  575|     25|            ParseValue<parseFlags>(is, handler);
  576|     25|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|     25|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|     25|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|     25|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|     25|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 9, False: 16]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|     25|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|     25|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|     25|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 16]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  577|       |
  578|     16|            if (!(parseFlags & kParseStopWhenDoneFlag)) {
  ------------------
  |  Branch (578:17): [True: 16, Folded]
  ------------------
  579|     16|                SkipWhitespaceAndComments<parseFlags>(is);
  580|     16|                RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|     16|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|     16|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|     16|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|     16|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 0, False: 16]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|     16|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|     16|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|     16|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 16]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  581|       |
  582|     16|                if (RAPIDJSON_UNLIKELY(is.Peek() != '\0')) {
  ------------------
  |  |  505|     16|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 2, False: 14]
  |  |  ------------------
  ------------------
  583|      2|                    RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentRootNotSingular, is.Tell());
  ------------------
  |  |  101|      2|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      2|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  102|      2|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  ------------------
  |  |  |  |  437|      2|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  ------------------
  |  |  103|      2|    SetParseError(parseErrorCode, offset); \
  |  |  104|      2|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      2|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      2|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (583:21): [True: 2, False: 0]
  ------------------
  584|      2|                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|      4|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      2|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|      4|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|      2|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      4|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      2|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      2|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  585|      2|                }
  586|     16|            }
  587|     16|        }
  588|       |
  589|     14|        return parseResult_;
  590|     26|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE25SkipWhitespaceAndCommentsILj64ENS_19GenericStringStreamIS2_EEEEvRT0_:
  711|  6.89M|    void SkipWhitespaceAndComments(InputStream& is) {
  712|  6.89M|        SkipWhitespace(is);
  713|       |
  714|  6.89M|        if (parseFlags & kParseCommentsFlag) {
  ------------------
  |  Branch (714:13): [Folded, False: 6.89M]
  ------------------
  715|      0|            while (RAPIDJSON_UNLIKELY(Consume(is, '/'))) {
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  716|      0|                if (Consume(is, '*')) {
  ------------------
  |  Branch (716:21): [True: 0, False: 0]
  ------------------
  717|      0|                    while (true) {
  ------------------
  |  Branch (717:28): [True: 0, Folded]
  ------------------
  718|      0|                        if (RAPIDJSON_UNLIKELY(is.Peek() == '\0'))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  719|      0|                            RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (719:29): [True: 0, False: 0]
  ------------------
  720|      0|                        else if (Consume(is, '*')) {
  ------------------
  |  Branch (720:34): [True: 0, False: 0]
  ------------------
  721|      0|                            if (Consume(is, '/'))
  ------------------
  |  Branch (721:33): [True: 0, False: 0]
  ------------------
  722|      0|                                break;
  723|      0|                        }
  724|      0|                        else
  725|      0|                            is.Take();
  726|      0|                    }
  727|      0|                }
  728|      0|                else if (RAPIDJSON_LIKELY(Consume(is, '/')))
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  729|      0|                    while (is.Peek() != '\0' && is.Take() != '\n') {}
  ------------------
  |  Branch (729:28): [True: 0, False: 0]
  |  Branch (729:49): [True: 0, False: 0]
  ------------------
  730|      0|                else
  731|      0|                    RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (731:21): [True: 0, False: 0]
  ------------------
  732|       |
  733|      0|                SkipWhitespace(is);
  734|      0|            }
  735|      0|        }
  736|  6.89M|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE10ParseValueILj64ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
 1752|  3.24M|    void ParseValue(InputStream& is, Handler& handler) {
 1753|  3.24M|        switch (is.Peek()) {
 1754|     39|            case 'n': ParseNull  <parseFlags>(is, handler); break;
  ------------------
  |  Branch (1754:13): [True: 39, False: 3.24M]
  ------------------
 1755|      6|            case 't': ParseTrue  <parseFlags>(is, handler); break;
  ------------------
  |  Branch (1755:13): [True: 6, False: 3.24M]
  ------------------
 1756|    309|            case 'f': ParseFalse <parseFlags>(is, handler); break;
  ------------------
  |  Branch (1756:13): [True: 309, False: 3.24M]
  ------------------
 1757|      9|            case '"': ParseString<parseFlags>(is, handler); break;
  ------------------
  |  Branch (1757:13): [True: 9, False: 3.24M]
  ------------------
 1758|  7.55k|            case '{': ParseObject<parseFlags>(is, handler); break;
  ------------------
  |  Branch (1758:13): [True: 7.55k, False: 3.24M]
  ------------------
 1759|  10.6k|            case '[': ParseArray <parseFlags>(is, handler); break;
  ------------------
  |  Branch (1759:13): [True: 10.6k, False: 3.23M]
  ------------------
 1760|  3.23M|            default :
  ------------------
  |  Branch (1760:13): [True: 3.23M, False: 18.5k]
  ------------------
 1761|  3.23M|                      ParseNumber<parseFlags>(is, handler);
 1762|  3.23M|                      break;
 1763|       |
 1764|  3.24M|        }
 1765|  3.24M|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE9ParseNullILj64ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  856|     39|    void ParseNull(InputStream& is, Handler& handler) {
  857|     39|        RAPIDJSON_ASSERT(is.Peek() == 'n');
  ------------------
  |  |  437|     39|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (857:9): [True: 39, False: 0]
  ------------------
  858|     39|        is.Take();
  859|       |
  860|     39|        if (RAPIDJSON_LIKELY(Consume(is, 'u') && Consume(is, 'l') && Consume(is, 'l'))) {
  ------------------
  |  |  492|    156|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 39, False: 0]
  |  |  |  Branch (492:49): [True: 39, False: 0]
  |  |  |  Branch (492:49): [True: 39, False: 0]
  |  |  |  Branch (492:49): [True: 39, False: 0]
  |  |  ------------------
  ------------------
  861|     39|            if (RAPIDJSON_UNLIKELY(!handler.Null()))
  ------------------
  |  |  505|     39|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 39]
  |  |  ------------------
  ------------------
  862|     39|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (862:17): [True: 0, False: 0]
  ------------------
  863|     39|        }
  864|      0|        else
  865|       |            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (865:13): [True: 0, False: 0]
  ------------------
  866|     39|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE9ParseTrueILj64ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  869|      6|    void ParseTrue(InputStream& is, Handler& handler) {
  870|      6|        RAPIDJSON_ASSERT(is.Peek() == 't');
  ------------------
  |  |  437|      6|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (870:9): [True: 6, False: 0]
  ------------------
  871|      6|        is.Take();
  872|       |
  873|      6|        if (RAPIDJSON_LIKELY(Consume(is, 'r') && Consume(is, 'u') && Consume(is, 'e'))) {
  ------------------
  |  |  492|     24|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 6, False: 0]
  |  |  |  Branch (492:49): [True: 6, False: 0]
  |  |  |  Branch (492:49): [True: 6, False: 0]
  |  |  |  Branch (492:49): [True: 6, False: 0]
  |  |  ------------------
  ------------------
  874|      6|            if (RAPIDJSON_UNLIKELY(!handler.Bool(true)))
  ------------------
  |  |  505|      6|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 6]
  |  |  ------------------
  ------------------
  875|      6|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (875:17): [True: 0, False: 0]
  ------------------
  876|      6|        }
  877|      0|        else
  878|       |            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (878:13): [True: 0, False: 0]
  ------------------
  879|      6|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE10ParseFalseILj64ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  882|    309|    void ParseFalse(InputStream& is, Handler& handler) {
  883|    309|        RAPIDJSON_ASSERT(is.Peek() == 'f');
  ------------------
  |  |  437|    309|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (883:9): [True: 309, False: 0]
  ------------------
  884|    309|        is.Take();
  885|       |
  886|    309|        if (RAPIDJSON_LIKELY(Consume(is, 'a') && Consume(is, 'l') && Consume(is, 's') && Consume(is, 'e'))) {
  ------------------
  |  |  492|  1.85k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 309, False: 0]
  |  |  |  Branch (492:49): [True: 309, False: 0]
  |  |  |  Branch (492:49): [True: 309, False: 0]
  |  |  |  Branch (492:49): [True: 309, False: 0]
  |  |  |  Branch (492:49): [True: 309, False: 0]
  |  |  ------------------
  ------------------
  887|    309|            if (RAPIDJSON_UNLIKELY(!handler.Bool(false)))
  ------------------
  |  |  505|    309|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 309]
  |  |  ------------------
  ------------------
  888|    309|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (888:17): [True: 0, False: 0]
  ------------------
  889|    309|        }
  890|      0|        else
  891|       |            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (891:13): [True: 0, False: 0]
  ------------------
  892|    309|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE11ParseStringILj64ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_b:
  959|   196k|    void ParseString(InputStream& is, Handler& handler, bool isKey = false) {
  960|   196k|        internal::StreamLocalCopy<InputStream> copy(is);
  961|   196k|        InputStream& s(copy.s);
  962|       |
  963|   196k|        RAPIDJSON_ASSERT(s.Peek() == '\"');
  ------------------
  |  |  437|   196k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (963:9): [True: 196k, False: 0]
  ------------------
  964|   196k|        s.Take();  // Skip '\"'
  965|       |
  966|   196k|        bool success = false;
  967|   196k|        if (parseFlags & kParseInsituFlag) {
  ------------------
  |  Branch (967:13): [Folded, False: 196k]
  ------------------
  968|      0|            typename InputStream::Ch *head = s.PutBegin();
  969|      0|            ParseStringToStream<parseFlags, SourceEncoding, SourceEncoding>(s, s);
  970|      0|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  971|      0|            size_t length = s.PutEnd(head) - 1;
  972|      0|            RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
  ------------------
  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (972:13): [True: 0, False: 0]
  ------------------
  973|      0|            const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
  974|      0|            success = (isKey ? handler.Key(str, SizeType(length), false) : handler.String(str, SizeType(length), false));
  ------------------
  |  Branch (974:24): [True: 0, False: 0]
  ------------------
  975|      0|        }
  976|   196k|        else {
  977|   196k|            StackStream<typename TargetEncoding::Ch> stackStream(stack_);
  978|   196k|            ParseStringToStream<parseFlags, SourceEncoding, TargetEncoding>(s, stackStream);
  979|   196k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   196k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   196k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   196k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   196k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   196k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 196k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   196k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   196k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   196k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 196k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  980|   196k|            SizeType length = static_cast<SizeType>(stackStream.Length()) - 1;
  981|   196k|            const typename TargetEncoding::Ch* const str = stackStream.Pop();
  982|   196k|            success = (isKey ? handler.Key(str, length, true) : handler.String(str, length, true));
  ------------------
  |  Branch (982:24): [True: 196k, False: 9]
  ------------------
  983|   196k|        }
  984|   196k|        if (RAPIDJSON_UNLIKELY(!success))
  ------------------
  |  |  505|   196k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 196k]
  |  |  ------------------
  ------------------
  985|       |            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (985:13): [True: 0, False: 0]
  ------------------
  986|   196k|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE19ParseStringToStreamILj64ES2_S2_NS_19GenericStringStreamIS2_EENS4_11StackStreamIcEEEEvRT2_RT3_:
  991|   196k|    RAPIDJSON_FORCEINLINE void ParseStringToStream(InputStream& is, OutputStream& os) {
  992|       |//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
  993|   196k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  994|   196k|        static const char escape[256] = {
  995|   196k|            Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '/',
  ------------------
  |  |  993|   196k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '/',
  ------------------
  |  |  993|   196k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
  996|   196k|            Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
  ------------------
  |  |  993|   196k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
  ------------------
  |  |  993|   196k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
  997|   196k|            0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0,
  998|   196k|            0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  999|   196k|            Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   196k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   196k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   196k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   196k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   196k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   196k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   196k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   196k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
 1000|   196k|        };
 1001|   196k|#undef Z16
 1002|       |//!@endcond
 1003|       |
 1004|   450k|        for (;;) {
 1005|       |            // Scan and copy string before "\\\"" or < 0x20. This is an optional optimzation.
 1006|   450k|            if (!(parseFlags & kParseValidateEncodingFlag))
  ------------------
  |  Branch (1006:17): [True: 450k, Folded]
  ------------------
 1007|   450k|                ScanCopyUnescapedString(is, os);
 1008|       |
 1009|   450k|            Ch c = is.Peek();
 1010|   450k|            if (RAPIDJSON_UNLIKELY(c == '\\')) {    // Escape
  ------------------
  |  |  505|   450k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 3.63k, False: 446k]
  |  |  ------------------
  ------------------
 1011|  3.63k|                size_t escapeOffset = is.Tell();    // For invalid escaping, report the initial '\\' as error offset
 1012|  3.63k|                is.Take();
 1013|  3.63k|                Ch e = is.Peek();
 1014|  3.63k|                if ((sizeof(Ch) == 1 || unsigned(e) < 256) && RAPIDJSON_LIKELY(escape[static_cast<unsigned char>(e)])) {
  ------------------
  |  |  492|  3.63k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 1.26k, False: 2.37k]
  |  |  ------------------
  ------------------
  |  Branch (1014:22): [True: 3.63k, Folded]
  |  Branch (1014:41): [True: 0, False: 0]
  ------------------
 1015|  1.26k|                    is.Take();
 1016|  1.26k|                    os.Put(static_cast<typename TEncoding::Ch>(escape[static_cast<unsigned char>(e)]));
 1017|  1.26k|                }
 1018|  2.37k|                else if ((parseFlags & kParseEscapedApostropheFlag) && RAPIDJSON_LIKELY(e == '\'')) { // Allow escaped apostrophe
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1018:26): [Folded, False: 2.37k]
  ------------------
 1019|      0|                    is.Take();
 1020|      0|                    os.Put('\'');
 1021|      0|                }
 1022|  2.37k|                else if (RAPIDJSON_LIKELY(e == 'u')) {    // Unicode
  ------------------
  |  |  492|  2.37k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 2.37k, False: 0]
  |  |  ------------------
  ------------------
 1023|  2.37k|                    is.Take();
 1024|  2.37k|                    unsigned codepoint = ParseHex4(is, escapeOffset);
 1025|  2.37k|                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  2.37k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  2.37k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  2.37k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  2.37k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  2.37k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 2.37k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  2.37k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  2.37k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  2.37k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 2.37k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1026|  2.37k|                    if (RAPIDJSON_UNLIKELY(codepoint >= 0xD800 && codepoint <= 0xDFFF)) {
  ------------------
  |  |  505|  4.74k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 2.16k, False: 211]
  |  |  |  Branch (505:51): [True: 2.37k, False: 1]
  |  |  |  Branch (505:51): [True: 2.16k, False: 210]
  |  |  ------------------
  ------------------
 1027|       |                        // high surrogate, check if followed by valid low surrogate
 1028|  2.16k|                        if (RAPIDJSON_LIKELY(codepoint <= 0xDBFF)) {
  ------------------
  |  |  492|  2.16k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 2.16k, False: 0]
  |  |  ------------------
  ------------------
 1029|       |                            // Handle UTF-16 surrogate pair
 1030|  2.16k|                            if (RAPIDJSON_UNLIKELY(!Consume(is, '\\') || !Consume(is, 'u')))
  ------------------
  |  |  505|  4.32k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 2.16k]
  |  |  |  Branch (505:51): [True: 0, False: 2.16k]
  |  |  |  Branch (505:51): [True: 0, False: 2.16k]
  |  |  ------------------
  ------------------
 1031|  2.16k|                                RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1031:33): [True: 0, False: 0]
  ------------------
 1032|  2.16k|                            unsigned codepoint2 = ParseHex4(is, escapeOffset);
 1033|  2.16k|                            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  2.16k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  2.16k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  2.16k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  2.16k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  2.16k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 2.16k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  2.16k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  2.16k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  2.16k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 2.16k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1034|  2.16k|                            if (RAPIDJSON_UNLIKELY(codepoint2 < 0xDC00 || codepoint2 > 0xDFFF))
  ------------------
  |  |  505|  4.32k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 2.16k]
  |  |  |  Branch (505:51): [True: 0, False: 2.16k]
  |  |  |  Branch (505:51): [True: 0, False: 2.16k]
  |  |  ------------------
  ------------------
 1035|  2.16k|                                RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1035:33): [True: 0, False: 0]
  ------------------
 1036|  2.16k|                            codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
 1037|  2.16k|                        }
 1038|       |                        // single low surrogate
 1039|      0|                        else
 1040|      0|                        {
 1041|      0|                            RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1041:29): [True: 0, False: 0]
  ------------------
 1042|      0|                        }
 1043|  2.16k|                    }
 1044|  2.37k|                    TEncoding::Encode(os, codepoint);
 1045|  2.37k|                }
 1046|      0|                else
 1047|  2.37k|                    RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, escapeOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1047:21): [True: 0, False: 0]
  ------------------
 1048|  3.63k|            }
 1049|   446k|            else if (RAPIDJSON_UNLIKELY(c == '"')) {    // Closing double quote
  ------------------
  |  |  505|   446k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 196k, False: 250k]
  |  |  ------------------
  ------------------
 1050|   196k|                is.Take();
 1051|   196k|                os.Put('\0');   // null-terminate the string
 1052|   196k|                return;
 1053|   196k|            }
 1054|   250k|            else if (RAPIDJSON_UNLIKELY(static_cast<unsigned>(c) < 0x20)) { // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
  ------------------
  |  |  505|   250k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 250k]
  |  |  ------------------
  ------------------
 1055|      0|                if (c == '\0')
  ------------------
  |  Branch (1055:21): [True: 0, False: 0]
  ------------------
 1056|      0|                    RAPIDJSON_PARSE_ERROR(kParseErrorStringMissQuotationMark, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1056:21): [True: 0, False: 0]
  ------------------
 1057|      0|                else
 1058|      0|                    RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1058:21): [True: 0, False: 0]
  ------------------
 1059|      0|            }
 1060|   250k|            else {
 1061|   250k|                size_t offset = is.Tell();
 1062|   250k|                if (RAPIDJSON_UNLIKELY((parseFlags & kParseValidateEncodingFlag ?
  ------------------
  |  |  505|   501k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 250k]
  |  |  |  Branch (505:51): [Folded, False: 250k]
  |  |  ------------------
  ------------------
 1063|   250k|                    !Transcoder<SEncoding, TEncoding>::Validate(is, os) :
 1064|   250k|                    !Transcoder<SEncoding, TEncoding>::Transcode(is, os))))
 1065|       |                    RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, offset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1065:21): [True: 0, False: 0]
  ------------------
 1066|   250k|            }
 1067|   450k|        }
 1068|   196k|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE11ParseObjectILj64ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  740|  7.55k|    void ParseObject(InputStream& is, Handler& handler) {
  741|  7.55k|        RAPIDJSON_ASSERT(is.Peek() == '{');
  ------------------
  |  |  437|  7.55k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (741:9): [True: 7.55k, False: 0]
  ------------------
  742|  7.55k|        is.Take();  // Skip '{'
  743|       |
  744|  7.55k|        if (RAPIDJSON_UNLIKELY(!handler.StartObject()))
  ------------------
  |  |  505|  7.55k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 7.55k]
  |  |  ------------------
  ------------------
  745|  7.55k|            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (745:13): [True: 0, False: 0]
  ------------------
  746|       |
  747|  7.55k|        SkipWhitespaceAndComments<parseFlags>(is);
  748|  7.55k|        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  7.55k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  7.55k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  7.55k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  7.55k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  7.55k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 7.55k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  7.55k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  7.55k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  7.55k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 7.55k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  749|       |
  750|  7.55k|        if (Consume(is, '}')) {
  ------------------
  |  Branch (750:13): [True: 3.76k, False: 3.79k]
  ------------------
  751|  3.76k|            if (RAPIDJSON_UNLIKELY(!handler.EndObject(0)))  // empty object
  ------------------
  |  |  505|  3.76k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 3.76k]
  |  |  ------------------
  ------------------
  752|  3.76k|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (752:17): [True: 0, False: 0]
  ------------------
  753|  3.76k|            return;
  754|  3.76k|        }
  755|       |
  756|   196k|        for (SizeType memberCount = 0;;) {
  757|   196k|            if (RAPIDJSON_UNLIKELY(is.Peek() != '"'))
  ------------------
  |  |  505|   196k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 196k]
  |  |  ------------------
  ------------------
  758|   196k|                RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (758:17): [True: 0, False: 0]
  ------------------
  759|       |
  760|   196k|            ParseString<parseFlags>(is, handler, true);
  761|   196k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   196k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   196k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   196k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   196k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   196k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 196k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   196k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   196k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   196k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 196k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  762|       |
  763|   196k|            SkipWhitespaceAndComments<parseFlags>(is);
  764|   196k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   196k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   196k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   196k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   196k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   196k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 196k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   196k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   196k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   196k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 196k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  765|       |
  766|   196k|            if (RAPIDJSON_UNLIKELY(!Consume(is, ':')))
  ------------------
  |  |  505|   196k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 196k]
  |  |  ------------------
  ------------------
  767|   196k|                RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (767:17): [True: 0, False: 0]
  ------------------
  768|       |
  769|   196k|            SkipWhitespaceAndComments<parseFlags>(is);
  770|   196k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   196k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   196k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   196k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   196k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   196k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 196k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   196k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   196k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   196k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 196k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  771|       |
  772|   196k|            ParseValue<parseFlags>(is, handler);
  773|   196k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   196k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   196k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   196k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   196k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   196k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 196k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   196k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   196k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   196k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 196k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  774|       |
  775|   196k|            SkipWhitespaceAndComments<parseFlags>(is);
  776|   196k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   196k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   196k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   196k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   196k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   196k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 196k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   196k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   196k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   196k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 196k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  777|       |
  778|   196k|            ++memberCount;
  779|       |
  780|   196k|            switch (is.Peek()) {
  781|   192k|                case ',':
  ------------------
  |  Branch (781:17): [True: 192k, False: 3.79k]
  ------------------
  782|   192k|                    is.Take();
  783|   192k|                    SkipWhitespaceAndComments<parseFlags>(is);
  784|   192k|                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   192k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   192k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   192k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   192k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   192k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 192k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   192k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   192k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   192k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 192k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  785|   192k|                    break;
  786|   192k|                case '}':
  ------------------
  |  Branch (786:17): [True: 3.79k, False: 192k]
  ------------------
  787|  3.79k|                    is.Take();
  788|  3.79k|                    if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
  ------------------
  |  |  505|  3.79k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 3.79k]
  |  |  ------------------
  ------------------
  789|  3.79k|                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (789:25): [True: 0, False: 0]
  ------------------
  790|  3.79k|                    return;
  791|  3.79k|                default:
  ------------------
  |  Branch (791:17): [True: 0, False: 196k]
  ------------------
  792|      0|                    RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); break; // This useless break is only for making warning and coverage happy
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (792:21): [True: 0, False: 0]
  ------------------
  793|   196k|            }
  794|       |
  795|   192k|            if (parseFlags & kParseTrailingCommasFlag) {
  ------------------
  |  Branch (795:17): [Folded, False: 192k]
  ------------------
  796|      0|                if (is.Peek() == '}') {
  ------------------
  |  Branch (796:21): [True: 0, False: 0]
  ------------------
  797|      0|                    if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  798|      0|                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (798:25): [True: 0, False: 0]
  ------------------
  799|      0|                    is.Take();
  800|      0|                    return;
  801|      0|                }
  802|      0|            }
  803|   192k|        }
  804|  3.79k|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE10ParseArrayILj64ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  808|  10.6k|    void ParseArray(InputStream& is, Handler& handler) {
  809|  10.6k|        RAPIDJSON_ASSERT(is.Peek() == '[');
  ------------------
  |  |  437|  10.6k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (809:9): [True: 10.6k, False: 0]
  ------------------
  810|  10.6k|        is.Take();  // Skip '['
  811|       |
  812|  10.6k|        if (RAPIDJSON_UNLIKELY(!handler.StartArray()))
  ------------------
  |  |  505|  10.6k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 10.6k]
  |  |  ------------------
  ------------------
  813|  10.6k|            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (813:13): [True: 0, False: 0]
  ------------------
  814|       |
  815|  10.6k|        SkipWhitespaceAndComments<parseFlags>(is);
  816|  10.6k|        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  10.6k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  10.6k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  10.6k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  10.6k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  10.6k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 10.6k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  10.6k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  10.6k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  10.6k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 10.6k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  817|       |
  818|  10.6k|        if (Consume(is, ']')) {
  ------------------
  |  Branch (818:13): [True: 10, False: 10.6k]
  ------------------
  819|     10|            if (RAPIDJSON_UNLIKELY(!handler.EndArray(0))) // empty array
  ------------------
  |  |  505|     10|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 10]
  |  |  ------------------
  ------------------
  820|     10|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (820:17): [True: 0, False: 0]
  ------------------
  821|     10|            return;
  822|     10|        }
  823|       |
  824|  3.05M|        for (SizeType elementCount = 0;;) {
  825|  3.05M|            ParseValue<parseFlags>(is, handler);
  826|  3.05M|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  3.05M|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  3.05M|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  3.05M|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  3.05M|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  3.05M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 926, False: 3.05M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  3.05M|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  3.05M|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  3.05M|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 3.05M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  827|       |
  828|  3.05M|            ++elementCount;
  829|  3.05M|            SkipWhitespaceAndComments<parseFlags>(is);
  830|  3.05M|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  3.05M|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  3.05M|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  3.05M|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  3.05M|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  3.05M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 3.05M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  3.05M|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  3.05M|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  3.05M|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 3.05M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  831|       |
  832|  3.05M|            if (Consume(is, ',')) {
  ------------------
  |  Branch (832:17): [True: 3.04M, False: 9.67k]
  ------------------
  833|  3.04M|                SkipWhitespaceAndComments<parseFlags>(is);
  834|  3.04M|                RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  3.04M|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  3.04M|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  3.04M|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  3.04M|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  3.04M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 3.04M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  3.04M|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  3.04M|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  3.04M|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 3.04M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  835|  3.04M|            }
  836|  9.67k|            else if (Consume(is, ']')) {
  ------------------
  |  Branch (836:22): [True: 9.67k, False: 3]
  ------------------
  837|  9.67k|                if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
  ------------------
  |  |  505|  9.67k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 9.67k]
  |  |  ------------------
  ------------------
  838|  9.67k|                    RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (838:21): [True: 0, False: 0]
  ------------------
  839|  9.67k|                return;
  840|  9.67k|            }
  841|      3|            else
  842|  9.67k|                RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
  ------------------
  |  |  120|      6|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      3|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      6|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      3|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      3|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      3|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      3|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      3|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      3|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      3|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      3|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 3]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      6|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      3|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      6|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      3|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      6|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      3|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 3, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      6|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      3|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      3|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      3|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      3|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      3|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (842:17): [True: 3, False: 0]
  ------------------
  843|       |
  844|  3.04M|            if (parseFlags & kParseTrailingCommasFlag) {
  ------------------
  |  Branch (844:17): [Folded, False: 3.04M]
  ------------------
  845|      0|                if (is.Peek() == ']') {
  ------------------
  |  Branch (845:21): [True: 0, False: 0]
  ------------------
  846|      0|                    if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  847|      0|                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (847:25): [True: 0, False: 0]
  ------------------
  848|      0|                    is.Take();
  849|      0|                    return;
  850|      0|                }
  851|      0|            }
  852|  3.04M|        }
  853|  10.6k|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE11ParseNumberILj64ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
 1468|  3.23M|    void ParseNumber(InputStream& is, Handler& handler) {
 1469|  3.23M|        typedef typename internal::SelectIf<internal::BoolType<(parseFlags & kParseNumbersAsStringsFlag) != 0>, typename TargetEncoding::Ch, char>::Type NumberCharacter;
 1470|       |
 1471|  3.23M|        internal::StreamLocalCopy<InputStream> copy(is);
 1472|  3.23M|        NumberStream<InputStream, NumberCharacter,
 1473|  3.23M|            ((parseFlags & kParseNumbersAsStringsFlag) != 0) ?
 1474|  3.23M|                ((parseFlags & kParseInsituFlag) == 0) :
 1475|  3.23M|                ((parseFlags & kParseFullPrecisionFlag) != 0),
 1476|  3.23M|            (parseFlags & kParseNumbersAsStringsFlag) != 0 &&
 1477|  3.23M|                (parseFlags & kParseInsituFlag) == 0> s(*this, copy.s);
 1478|       |
 1479|  3.23M|        size_t startOffset = s.Tell();
 1480|  3.23M|        double d = 0.0;
 1481|  3.23M|        bool useNanOrInf = false;
 1482|       |
 1483|       |        // Parse minus
 1484|  3.23M|        bool minus = Consume(s, '-');
 1485|       |
 1486|       |        // Parse int: zero / ( digit1-9 *DIGIT )
 1487|  3.23M|        unsigned i = 0;
 1488|  3.23M|        uint64_t i64 = 0;
 1489|  3.23M|        bool use64bit = false;
 1490|  3.23M|        int significandDigit = 0;
 1491|  3.23M|        if (RAPIDJSON_UNLIKELY(s.Peek() == '0')) {
  ------------------
  |  |  505|  3.23M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 77.5k, False: 3.15M]
  |  |  ------------------
  ------------------
 1492|  77.5k|            i = 0;
 1493|  77.5k|            s.TakePush();
 1494|  77.5k|        }
 1495|  3.15M|        else if (RAPIDJSON_LIKELY(s.Peek() >= '1' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  6.30M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 3.15M, False: 5]
  |  |  |  Branch (492:49): [True: 3.15M, False: 1]
  |  |  |  Branch (492:49): [True: 3.15M, False: 4]
  |  |  ------------------
  ------------------
 1496|  3.15M|            i = static_cast<unsigned>(s.TakePush() - '0');
 1497|       |
 1498|  3.15M|            if (minus)
  ------------------
  |  Branch (1498:17): [True: 1.85k, False: 3.15M]
  ------------------
 1499|  5.06k|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  8.35k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 3.29k, False: 1.76k]
  |  |  |  Branch (492:49): [True: 3.29k, False: 1.76k]
  |  |  |  Branch (492:49): [True: 3.29k, False: 1]
  |  |  ------------------
  ------------------
 1500|  3.29k|                    if (RAPIDJSON_UNLIKELY(i >= 214748364)) { // 2^31 = 2147483648
  ------------------
  |  |  505|  3.29k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 88, False: 3.20k]
  |  |  ------------------
  ------------------
 1501|     88|                        if (RAPIDJSON_LIKELY(i != 214748364 || s.Peek() > '8')) {
  ------------------
  |  |  492|     88|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 88, False: 0]
  |  |  |  Branch (492:49): [True: 88, False: 0]
  |  |  |  Branch (492:49): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1502|     88|                            i64 = i;
 1503|     88|                            use64bit = true;
 1504|     88|                            break;
 1505|     88|                        }
 1506|     88|                    }
 1507|  3.20k|                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1508|  3.20k|                    significandDigit++;
 1509|  3.20k|                }
 1510|  3.15M|            else
 1511|  3.28M|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  3.43M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 144k, False: 3.14M]
  |  |  |  Branch (492:49): [True: 151k, False: 3.13M]
  |  |  |  Branch (492:49): [True: 144k, False: 7.25k]
  |  |  ------------------
  ------------------
 1512|   144k|                    if (RAPIDJSON_UNLIKELY(i >= 429496729)) { // 2^32 - 1 = 4294967295
  ------------------
  |  |  505|   144k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 10.5k, False: 133k]
  |  |  ------------------
  ------------------
 1513|  10.5k|                        if (RAPIDJSON_LIKELY(i != 429496729 || s.Peek() > '5')) {
  ------------------
  |  |  492|  11.0k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 10.0k, False: 470]
  |  |  |  Branch (492:49): [True: 10.0k, False: 475]
  |  |  |  Branch (492:49): [True: 5, False: 470]
  |  |  ------------------
  ------------------
 1514|  10.0k|                            i64 = i;
 1515|  10.0k|                            use64bit = true;
 1516|  10.0k|                            break;
 1517|  10.0k|                        }
 1518|  10.5k|                    }
 1519|   134k|                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1520|   134k|                    significandDigit++;
 1521|   134k|                }
 1522|  3.15M|        }
 1523|       |        // Parse NaN or Infinity here
 1524|      5|        else if ((parseFlags & kParseNanAndInfFlag) && RAPIDJSON_LIKELY((s.Peek() == 'I' || s.Peek() == 'N'))) {
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  |  Branch (492:49): [True: 0, False: 0]
  |  |  |  Branch (492:49): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1524:18): [Folded, False: 5]
  ------------------
 1525|      0|            if (Consume(s, 'N')) {
  ------------------
  |  Branch (1525:17): [True: 0, False: 0]
  ------------------
 1526|      0|                if (Consume(s, 'a') && Consume(s, 'N')) {
  ------------------
  |  Branch (1526:21): [True: 0, False: 0]
  |  Branch (1526:40): [True: 0, False: 0]
  ------------------
 1527|      0|                    d = std::numeric_limits<double>::quiet_NaN();
 1528|      0|                    useNanOrInf = true;
 1529|      0|                }
 1530|      0|            }
 1531|      0|            else if (RAPIDJSON_LIKELY(Consume(s, 'I'))) {
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1532|      0|                if (Consume(s, 'n') && Consume(s, 'f')) {
  ------------------
  |  Branch (1532:21): [True: 0, False: 0]
  |  Branch (1532:40): [True: 0, False: 0]
  ------------------
 1533|      0|                    d = (minus ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity());
  ------------------
  |  Branch (1533:26): [True: 0, False: 0]
  ------------------
 1534|      0|                    useNanOrInf = true;
 1535|       |
 1536|      0|                    if (RAPIDJSON_UNLIKELY(s.Peek() == 'i' && !(Consume(s, 'i') && Consume(s, 'n')
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1537|      0|                                                                && Consume(s, 'i') && Consume(s, 't') && Consume(s, 'y')))) {
 1538|      0|                        RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1538:25): [True: 0, False: 0]
  ------------------
 1539|      0|                    }
 1540|      0|                }
 1541|      0|            }
 1542|       |
 1543|      0|            if (RAPIDJSON_UNLIKELY(!useNanOrInf)) {
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1544|      0|                RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1544:17): [True: 0, False: 0]
  ------------------
 1545|      0|            }
 1546|      0|        }
 1547|      5|        else
 1548|      5|            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
  ------------------
  |  |  120|     10|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      5|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|     10|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      5|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      5|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      5|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      5|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      5|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      5|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      5|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      5|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|     10|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      5|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|     10|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      5|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|     10|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      5|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 5, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|     10|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      5|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      5|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      5|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      5|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      5|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1548:13): [True: 5, False: 0]
  ------------------
 1549|       |
 1550|       |        // Parse 64bit int
 1551|  3.23M|        bool useDouble = false;
 1552|  3.23M|        if (use64bit) {
  ------------------
  |  Branch (1552:13): [True: 10.1k, False: 3.22M]
  ------------------
 1553|  10.1k|            if (minus)
  ------------------
  |  Branch (1553:17): [True: 88, False: 10.0k]
  ------------------
 1554|    258|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|    434|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 176, False: 82]
  |  |  |  Branch (492:49): [True: 176, False: 82]
  |  |  |  Branch (492:49): [True: 176, False: 0]
  |  |  ------------------
  ------------------
 1555|    176|                     if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC))) // 2^63 = 9223372036854775808
  ------------------
  |  |  505|    176|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 6, False: 170]
  |  |  ------------------
  ------------------
 1556|      6|                        if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC) || s.Peek() > '8')) {
  ------------------
  |  |  492|      6|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 6, False: 0]
  |  |  |  Branch (492:49): [True: 6, False: 0]
  |  |  |  Branch (492:49): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1557|      6|                            d = static_cast<double>(i64);
 1558|      6|                            useDouble = true;
 1559|      6|                            break;
 1560|      6|                        }
 1561|    170|                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1562|    170|                    significandDigit++;
 1563|    170|                }
 1564|  10.0k|            else
 1565|  82.3k|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|   157k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 74.6k, False: 7.65k]
  |  |  |  Branch (492:49): [True: 74.7k, False: 7.56k]
  |  |  |  Branch (492:49): [True: 74.6k, False: 88]
  |  |  ------------------
  ------------------
 1566|  74.6k|                    if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999))) // 2^64 - 1 = 18446744073709551615
  ------------------
  |  |  505|  74.6k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 2.42k, False: 72.2k]
  |  |  ------------------
  ------------------
 1567|  2.42k|                        if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || s.Peek() > '5')) {
  ------------------
  |  |  492|  2.42k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 2.41k, False: 4]
  |  |  |  Branch (492:49): [True: 2.41k, False: 4]
  |  |  |  Branch (492:49): [True: 0, False: 4]
  |  |  ------------------
  ------------------
 1568|  2.41k|                            d = static_cast<double>(i64);
 1569|  2.41k|                            useDouble = true;
 1570|  2.41k|                            break;
 1571|  2.41k|                        }
 1572|  72.2k|                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1573|  72.2k|                    significandDigit++;
 1574|  72.2k|                }
 1575|  10.1k|        }
 1576|       |
 1577|       |        // Force double for big integer
 1578|  3.23M|        if (useDouble) {
  ------------------
  |  Branch (1578:13): [True: 2.42k, False: 3.22M]
  ------------------
 1579|  1.94M|            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  3.89M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 1.94M, False: 2.42k]
  |  |  |  Branch (492:49): [True: 1.94M, False: 2.38k]
  |  |  |  Branch (492:49): [True: 1.94M, False: 36]
  |  |  ------------------
  ------------------
 1580|  1.94M|                d = d * 10 + (s.TakePush() - '0');
 1581|  1.94M|            }
 1582|  2.42k|        }
 1583|       |
 1584|       |        // Parse frac = decimal-point 1*DIGIT
 1585|  3.23M|        int expFrac = 0;
 1586|  3.23M|        size_t decimalPosition;
 1587|  3.23M|        if (!useNanOrInf && Consume(s, '.')) {
  ------------------
  |  Branch (1587:13): [True: 3.23M, False: 0]
  |  Branch (1587:29): [True: 12.0k, False: 3.21M]
  ------------------
 1588|  12.0k|            decimalPosition = s.Length();
 1589|       |
 1590|  12.0k|            if (RAPIDJSON_UNLIKELY(!(s.Peek() >= '0' && s.Peek() <= '9')))
  ------------------
  |  |  505|  24.0k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 12.0k]
  |  |  |  Branch (505:51): [True: 12.0k, False: 0]
  |  |  |  Branch (505:51): [True: 12.0k, False: 0]
  |  |  ------------------
  ------------------
 1591|  12.0k|                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1591:17): [True: 0, False: 0]
  ------------------
 1592|       |
 1593|  12.0k|            if (!useDouble) {
  ------------------
  |  Branch (1593:17): [True: 11.5k, False: 452]
  ------------------
 1594|  11.5k|#if RAPIDJSON_64BIT
 1595|       |                // Use i64 to store significand in 64-bit architecture
 1596|  11.5k|                if (!use64bit)
  ------------------
  |  Branch (1596:21): [True: 11.4k, False: 161]
  ------------------
 1597|  11.4k|                    i64 = i;
 1598|       |
 1599|   419k|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|   827k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 407k, False: 11.5k]
  |  |  |  Branch (492:49): [True: 408k, False: 11.2k]
  |  |  |  Branch (492:49): [True: 407k, False: 267]
  |  |  ------------------
  ------------------
 1600|   407k|                    if (i64 > RAPIDJSON_UINT64_C2(0x1FFFFF, 0xFFFFFFFF)) // 2^53 - 1 for fast path
  ------------------
  |  |  320|   407k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  |  Branch (1600:25): [True: 28, False: 407k]
  ------------------
 1601|     28|                        break;
 1602|   407k|                    else {
 1603|   407k|                        i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1604|   407k|                        --expFrac;
 1605|   407k|                        if (i64 != 0)
  ------------------
  |  Branch (1605:29): [True: 12.0k, False: 395k]
  ------------------
 1606|  12.0k|                            significandDigit++;
 1607|   407k|                    }
 1608|   407k|                }
 1609|       |
 1610|  11.5k|                d = static_cast<double>(i64);
 1611|       |#else
 1612|       |                // Use double to store significand in 32-bit architecture
 1613|       |                d = static_cast<double>(use64bit ? i64 : i);
 1614|       |#endif
 1615|  11.5k|                useDouble = true;
 1616|  11.5k|            }
 1617|       |
 1618|  7.18M|            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  14.3M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 7.17M, False: 12.0k]
  |  |  |  Branch (492:49): [True: 7.17M, False: 11.2k]
  |  |  |  Branch (492:49): [True: 7.17M, False: 736]
  |  |  ------------------
  ------------------
 1619|  7.17M|                if (significandDigit < 17) {
  ------------------
  |  Branch (1619:21): [True: 21, False: 7.17M]
  ------------------
 1620|     21|                    d = d * 10.0 + (s.TakePush() - '0');
 1621|     21|                    --expFrac;
 1622|     21|                    if (RAPIDJSON_LIKELY(d > 0.0))
  ------------------
  |  |  492|     21|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 21, False: 0]
  |  |  ------------------
  ------------------
 1623|     21|                        significandDigit++;
 1624|     21|                }
 1625|  7.17M|                else
 1626|  7.17M|                    s.TakePush();
 1627|  7.17M|            }
 1628|  12.0k|        }
 1629|  3.21M|        else
 1630|  3.21M|            decimalPosition = s.Length(); // decimal position at the end of integer.
 1631|       |
 1632|       |        // Parse exp = e [ minus / plus ] 1*DIGIT
 1633|  3.23M|        int exp = 0;
 1634|  3.23M|        if (!useNanOrInf && (Consume(s, 'e') || Consume(s, 'E'))) {
  ------------------
  |  Branch (1634:13): [True: 3.23M, False: 0]
  |  Branch (1634:30): [True: 647, False: 3.23M]
  |  Branch (1634:49): [True: 7.42k, False: 3.22M]
  ------------------
 1635|  8.07k|            if (!useDouble) {
  ------------------
  |  Branch (1635:17): [True: 7.30k, False: 770]
  ------------------
 1636|  7.30k|                d = static_cast<double>(use64bit ? i64 : i);
  ------------------
  |  Branch (1636:41): [True: 88, False: 7.21k]
  ------------------
 1637|  7.30k|                useDouble = true;
 1638|  7.30k|            }
 1639|       |
 1640|  8.07k|            bool expMinus = false;
 1641|  8.07k|            if (Consume(s, '+'))
  ------------------
  |  Branch (1641:17): [True: 0, False: 8.07k]
  ------------------
 1642|      0|                ;
 1643|  8.07k|            else if (Consume(s, '-'))
  ------------------
  |  Branch (1643:22): [True: 603, False: 7.47k]
  ------------------
 1644|    603|                expMinus = true;
 1645|       |
 1646|  8.07k|            if (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  16.1k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 8.07k, False: 0]
  |  |  |  Branch (492:49): [True: 8.07k, False: 0]
  |  |  |  Branch (492:49): [True: 8.07k, False: 0]
  |  |  ------------------
  ------------------
 1647|  8.07k|                exp = static_cast<int>(s.Take() - '0');
 1648|  8.07k|                if (expMinus) {
  ------------------
  |  Branch (1648:21): [True: 603, False: 7.47k]
  ------------------
 1649|       |                    // (exp + expFrac) must not underflow int => we're detecting when -exp gets
 1650|       |                    // dangerously close to INT_MIN (a pessimistic next digit 9 would push it into
 1651|       |                    // underflow territory):
 1652|       |                    //
 1653|       |                    //        -(exp * 10 + 9) + expFrac >= INT_MIN
 1654|       |                    //   <=>  exp <= (expFrac - INT_MIN - 9) / 10
 1655|    603|                    RAPIDJSON_ASSERT(expFrac <= 0);
  ------------------
  |  |  437|    603|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (1655:21): [True: 603, False: 0]
  ------------------
 1656|    603|                    int maxExp = (expFrac + 2147483639) / 10;
 1657|       |
 1658|   855k|                    while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  1.70M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 854k, False: 603]
  |  |  |  Branch (492:49): [True: 854k, False: 602]
  |  |  |  Branch (492:49): [True: 854k, False: 1]
  |  |  ------------------
  ------------------
 1659|   854k|                        exp = exp * 10 + static_cast<int>(s.Take() - '0');
 1660|   854k|                        if (RAPIDJSON_UNLIKELY(exp > maxExp)) {
  ------------------
  |  |  505|   854k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 5, False: 854k]
  |  |  ------------------
  ------------------
 1661|     13|                            while (RAPIDJSON_UNLIKELY(s.Peek() >= '0' && s.Peek() <= '9'))  // Consume the rest of exponent
  ------------------
  |  |  505|     21|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 8, False: 5]
  |  |  |  Branch (505:51): [True: 8, False: 5]
  |  |  |  Branch (505:51): [True: 8, False: 0]
  |  |  ------------------
  ------------------
 1662|      8|                                s.Take();
 1663|      5|                        }
 1664|   854k|                    }
 1665|    603|                }
 1666|  7.47k|                else {  // positive exp
 1667|  7.47k|                    int maxExp = 308 - expFrac;
 1668|   491k|                    while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|   976k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 484k, False: 7.47k]
  |  |  |  Branch (492:49): [True: 484k, False: 7.47k]
  |  |  |  Branch (492:49): [True: 484k, False: 0]
  |  |  ------------------
  ------------------
 1669|   484k|                        exp = exp * 10 + static_cast<int>(s.Take() - '0');
 1670|   484k|                        if (RAPIDJSON_UNLIKELY(exp > maxExp))
  ------------------
  |  |  505|   484k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 1, False: 484k]
  |  |  ------------------
  ------------------
 1671|   484k|                            RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
  ------------------
  |  |  120|      2|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      2|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      1|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      1|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      1|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      1|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 1]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      2|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      1|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      2|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      2|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      1|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 1, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      2|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1671:29): [True: 1, False: 0]
  ------------------
 1672|   484k|                    }
 1673|  7.47k|                }
 1674|  8.07k|            }
 1675|      0|            else
 1676|  8.07k|                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissExponent, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1676:17): [True: 0, False: 0]
  ------------------
 1677|       |
 1678|  8.07k|            if (expMinus)
  ------------------
  |  Branch (1678:17): [True: 603, False: 7.47k]
  ------------------
 1679|    603|                exp = -exp;
 1680|  8.07k|        }
 1681|       |
 1682|       |        // Finish parsing, call event according to the type of number.
 1683|  3.23M|        bool cont = true;
 1684|       |
 1685|  3.23M|        if (parseFlags & kParseNumbersAsStringsFlag) {
  ------------------
  |  Branch (1685:13): [True: 3.23M, Folded]
  ------------------
 1686|  3.23M|            if (parseFlags & kParseInsituFlag) {
  ------------------
  |  Branch (1686:17): [Folded, False: 3.23M]
  ------------------
 1687|      0|                s.Pop();  // Pop stack no matter if it will be used or not.
 1688|      0|                typename InputStream::Ch* head = is.PutBegin();
 1689|      0|                const size_t length = s.Tell() - startOffset;
 1690|      0|                RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
  ------------------
  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (1690:17): [True: 0, False: 0]
  ------------------
 1691|       |                // unable to insert the \0 character here, it will erase the comma after this number
 1692|      0|                const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
 1693|      0|                cont = handler.RawNumber(str, SizeType(length), false);
 1694|      0|            }
 1695|  3.23M|            else {
 1696|  3.23M|                SizeType numCharsToCopy = static_cast<SizeType>(s.Length());
 1697|  3.23M|                GenericStringStream<UTF8<NumberCharacter> > srcStream(s.Pop());
 1698|  3.23M|                StackStream<typename TargetEncoding::Ch> dstStream(stack_);
 1699|  16.6M|                while (numCharsToCopy--) {
  ------------------
  |  Branch (1699:24): [True: 13.4M, False: 3.23M]
  ------------------
 1700|  13.4M|                    Transcoder<UTF8<typename TargetEncoding::Ch>, TargetEncoding>::Transcode(srcStream, dstStream);
 1701|  13.4M|                }
 1702|  3.23M|                dstStream.Put('\0');
 1703|  3.23M|                const typename TargetEncoding::Ch* str = dstStream.Pop();
 1704|  3.23M|                const SizeType length = static_cast<SizeType>(dstStream.Length()) - 1;
 1705|  3.23M|                cont = handler.RawNumber(str, SizeType(length), true);
 1706|  3.23M|            }
 1707|  3.23M|        }
 1708|      0|        else {
 1709|      0|           size_t length = s.Length();
 1710|      0|           const NumberCharacter* decimal = s.Pop();  // Pop stack no matter if it will be used or not.
 1711|       |
 1712|      0|           if (useDouble) {
  ------------------
  |  Branch (1712:16): [True: 0, False: 0]
  ------------------
 1713|      0|               int p = exp + expFrac;
 1714|      0|               if (parseFlags & kParseFullPrecisionFlag)
  ------------------
  |  Branch (1714:20): [Folded, False: 0]
  ------------------
 1715|      0|                   d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp);
 1716|      0|               else
 1717|      0|                   d = internal::StrtodNormalPrecision(d, p);
 1718|       |
 1719|       |               // Use > max, instead of == inf, to fix bogus warning -Wfloat-equal
 1720|      0|               if (d > (std::numeric_limits<double>::max)()) {
  ------------------
  |  Branch (1720:20): [True: 0, False: 0]
  ------------------
 1721|       |                   // Overflow
 1722|       |                   // TODO: internal::StrtodX should report overflow (or underflow)
 1723|      0|                   RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1723:20): [True: 0, False: 0]
  ------------------
 1724|      0|               }
 1725|       |
 1726|      0|               cont = handler.Double(minus ? -d : d);
  ------------------
  |  Branch (1726:38): [True: 0, False: 0]
  ------------------
 1727|      0|           }
 1728|      0|           else if (useNanOrInf) {
  ------------------
  |  Branch (1728:21): [True: 0, False: 0]
  ------------------
 1729|      0|               cont = handler.Double(d);
 1730|      0|           }
 1731|      0|           else {
 1732|      0|               if (use64bit) {
  ------------------
  |  Branch (1732:20): [True: 0, False: 0]
  ------------------
 1733|      0|                   if (minus)
  ------------------
  |  Branch (1733:24): [True: 0, False: 0]
  ------------------
 1734|      0|                       cont = handler.Int64(static_cast<int64_t>(~i64 + 1));
 1735|      0|                   else
 1736|      0|                       cont = handler.Uint64(i64);
 1737|      0|               }
 1738|      0|               else {
 1739|      0|                   if (minus)
  ------------------
  |  Branch (1739:24): [True: 0, False: 0]
  ------------------
 1740|      0|                       cont = handler.Int(static_cast<int32_t>(~i + 1));
 1741|      0|                   else
 1742|      0|                       cont = handler.Uint(i);
 1743|      0|               }
 1744|      0|           }
 1745|      0|        }
 1746|  3.23M|        if (RAPIDJSON_UNLIKELY(!cont))
  ------------------
  |  |  505|  3.23M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 3.23M]
  |  |  ------------------
  ------------------
 1747|       |            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, startOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1747:13): [True: 0, False: 0]
  ------------------
 1748|  3.23M|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE12NumberStreamINS_19GenericStringStreamIS2_EEcLb1ELb1EEC2ERS4_RS7_:
 1462|  3.23M|        NumberStream(GenericReader& reader, InputStream& s) : Base(reader, s) {}
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE7ConsumeINS4_12NumberStreamINS_19GenericStringStreamIS2_EEcLb1ELb1EEEEEbRT_NSA_2ChE:
  895|  12.9M|    RAPIDJSON_FORCEINLINE static bool Consume(InputStream& is, typename InputStream::Ch expect) {
  896|  12.9M|        if (RAPIDJSON_LIKELY(is.Peek() == expect)) {
  ------------------
  |  |  492|  12.9M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 22.8k, False: 12.9M]
  |  |  ------------------
  ------------------
  897|  22.8k|            is.Take();
  898|  22.8k|            return true;
  899|  22.8k|        }
  900|  12.9M|        else
  901|  12.9M|            return false;
  902|  12.9M|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE12NumberStreamINS_19GenericStringStreamIS2_EEcLb1ELb1EE4TakeEv:
 1464|  1.37M|        RAPIDJSON_FORCEINLINE Ch Take() { return Base::TakePush(); }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE5ParseILj32ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEENS_11ParseResultERT0_RT1_:
  559|     26|    ParseResult Parse(InputStream& is, Handler& handler) {
  560|     26|        if (parseFlags & kParseIterativeFlag)
  ------------------
  |  Branch (560:13): [Folded, False: 26]
  ------------------
  561|      0|            return IterativeParse<parseFlags>(is, handler);
  562|       |
  563|     26|        parseResult_.Clear();
  564|       |
  565|     26|        ClearStackOnExit scope(*this);
  566|       |
  567|     26|        SkipWhitespaceAndComments<parseFlags>(is);
  568|     26|        RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|     26|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|     26|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|     26|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|     26|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 0, False: 26]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|     26|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|     26|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|     26|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 26]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  569|       |
  570|     26|        if (RAPIDJSON_UNLIKELY(is.Peek() == '\0')) {
  ------------------
  |  |  505|     26|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 1, False: 25]
  |  |  ------------------
  ------------------
  571|      1|            RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentEmpty, is.Tell());
  ------------------
  |  |  101|      1|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  102|      1|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  ------------------
  |  |  |  |  437|      1|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  ------------------
  |  |  103|      1|    SetParseError(parseErrorCode, offset); \
  |  |  104|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (571:13): [True: 1, False: 0]
  ------------------
  572|      1|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|      2|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|      2|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|      1|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 1, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      2|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  573|      1|        }
  574|     25|        else {
  575|     25|            ParseValue<parseFlags>(is, handler);
  576|     25|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|     25|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|     25|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|     25|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|     25|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 15, False: 10]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|     25|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|     25|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|     25|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 10]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  577|       |
  578|     10|            if (!(parseFlags & kParseStopWhenDoneFlag)) {
  ------------------
  |  Branch (578:17): [True: 10, Folded]
  ------------------
  579|     10|                SkipWhitespaceAndComments<parseFlags>(is);
  580|     10|                RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|     10|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|     10|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|     10|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|     10|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 0, False: 10]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|     10|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|     10|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|     10|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 10]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  581|       |
  582|     10|                if (RAPIDJSON_UNLIKELY(is.Peek() != '\0')) {
  ------------------
  |  |  505|     10|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 1, False: 9]
  |  |  ------------------
  ------------------
  583|      1|                    RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentRootNotSingular, is.Tell());
  ------------------
  |  |  101|      1|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  102|      1|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  ------------------
  |  |  |  |  437|      1|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  ------------------
  |  |  103|      1|    SetParseError(parseErrorCode, offset); \
  |  |  104|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (583:21): [True: 1, False: 0]
  ------------------
  584|      1|                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
  ------------------
  |  |   61|      2|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |   62|      2|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  ------------------
  |  |  |  |  505|      1|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (505:31): [True: 1, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      2|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  585|      1|                }
  586|     10|            }
  587|     10|        }
  588|       |
  589|      9|        return parseResult_;
  590|     26|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE25SkipWhitespaceAndCommentsILj32ENS_19GenericStringStreamIS2_EEEEvRT0_:
  711|  3.95M|    void SkipWhitespaceAndComments(InputStream& is) {
  712|  3.95M|        SkipWhitespace(is);
  713|       |
  714|  3.95M|        if (parseFlags & kParseCommentsFlag) {
  ------------------
  |  Branch (714:13): [True: 3.95M, Folded]
  ------------------
  715|  3.95M|            while (RAPIDJSON_UNLIKELY(Consume(is, '/'))) {
  ------------------
  |  |  505|  3.95M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 3.95M]
  |  |  ------------------
  ------------------
  716|      0|                if (Consume(is, '*')) {
  ------------------
  |  Branch (716:21): [True: 0, False: 0]
  ------------------
  717|      0|                    while (true) {
  ------------------
  |  Branch (717:28): [True: 0, Folded]
  ------------------
  718|      0|                        if (RAPIDJSON_UNLIKELY(is.Peek() == '\0'))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  719|      0|                            RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (719:29): [True: 0, False: 0]
  ------------------
  720|      0|                        else if (Consume(is, '*')) {
  ------------------
  |  Branch (720:34): [True: 0, False: 0]
  ------------------
  721|      0|                            if (Consume(is, '/'))
  ------------------
  |  Branch (721:33): [True: 0, False: 0]
  ------------------
  722|      0|                                break;
  723|      0|                        }
  724|      0|                        else
  725|      0|                            is.Take();
  726|      0|                    }
  727|      0|                }
  728|      0|                else if (RAPIDJSON_LIKELY(Consume(is, '/')))
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  729|      0|                    while (is.Peek() != '\0' && is.Take() != '\n') {}
  ------------------
  |  Branch (729:28): [True: 0, False: 0]
  |  Branch (729:49): [True: 0, False: 0]
  ------------------
  730|      0|                else
  731|      0|                    RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (731:21): [True: 0, False: 0]
  ------------------
  732|       |
  733|      0|                SkipWhitespace(is);
  734|      0|            }
  735|  3.95M|        }
  736|  3.95M|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE10ParseValueILj32ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
 1752|  1.79M|    void ParseValue(InputStream& is, Handler& handler) {
 1753|  1.79M|        switch (is.Peek()) {
 1754|     34|            case 'n': ParseNull  <parseFlags>(is, handler); break;
  ------------------
  |  Branch (1754:13): [True: 34, False: 1.79M]
  ------------------
 1755|      0|            case 't': ParseTrue  <parseFlags>(is, handler); break;
  ------------------
  |  Branch (1755:13): [True: 0, False: 1.79M]
  ------------------
 1756|    202|            case 'f': ParseFalse <parseFlags>(is, handler); break;
  ------------------
  |  Branch (1756:13): [True: 202, False: 1.79M]
  ------------------
 1757|      6|            case '"': ParseString<parseFlags>(is, handler); break;
  ------------------
  |  Branch (1757:13): [True: 6, False: 1.79M]
  ------------------
 1758|  7.53k|            case '{': ParseObject<parseFlags>(is, handler); break;
  ------------------
  |  Branch (1758:13): [True: 7.53k, False: 1.78M]
  ------------------
 1759|  2.88k|            case '[': ParseArray <parseFlags>(is, handler); break;
  ------------------
  |  Branch (1759:13): [True: 2.88k, False: 1.78M]
  ------------------
 1760|  1.78M|            default :
  ------------------
  |  Branch (1760:13): [True: 1.78M, False: 10.6k]
  ------------------
 1761|  1.78M|                      ParseNumber<parseFlags>(is, handler);
 1762|  1.78M|                      break;
 1763|       |
 1764|  1.79M|        }
 1765|  1.79M|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE9ParseNullILj32ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  856|     34|    void ParseNull(InputStream& is, Handler& handler) {
  857|     34|        RAPIDJSON_ASSERT(is.Peek() == 'n');
  ------------------
  |  |  437|     34|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (857:9): [True: 34, False: 0]
  ------------------
  858|     34|        is.Take();
  859|       |
  860|     34|        if (RAPIDJSON_LIKELY(Consume(is, 'u') && Consume(is, 'l') && Consume(is, 'l'))) {
  ------------------
  |  |  492|    136|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 34, False: 0]
  |  |  |  Branch (492:49): [True: 34, False: 0]
  |  |  |  Branch (492:49): [True: 34, False: 0]
  |  |  |  Branch (492:49): [True: 34, False: 0]
  |  |  ------------------
  ------------------
  861|     34|            if (RAPIDJSON_UNLIKELY(!handler.Null()))
  ------------------
  |  |  505|     34|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 34]
  |  |  ------------------
  ------------------
  862|     34|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (862:17): [True: 0, False: 0]
  ------------------
  863|     34|        }
  864|      0|        else
  865|       |            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (865:13): [True: 0, False: 0]
  ------------------
  866|     34|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE10ParseFalseILj32ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  882|    202|    void ParseFalse(InputStream& is, Handler& handler) {
  883|    202|        RAPIDJSON_ASSERT(is.Peek() == 'f');
  ------------------
  |  |  437|    202|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (883:9): [True: 202, False: 0]
  ------------------
  884|    202|        is.Take();
  885|       |
  886|    202|        if (RAPIDJSON_LIKELY(Consume(is, 'a') && Consume(is, 'l') && Consume(is, 's') && Consume(is, 'e'))) {
  ------------------
  |  |  492|  1.21k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 202, False: 0]
  |  |  |  Branch (492:49): [True: 202, False: 0]
  |  |  |  Branch (492:49): [True: 202, False: 0]
  |  |  |  Branch (492:49): [True: 202, False: 0]
  |  |  |  Branch (492:49): [True: 202, False: 0]
  |  |  ------------------
  ------------------
  887|    202|            if (RAPIDJSON_UNLIKELY(!handler.Bool(false)))
  ------------------
  |  |  505|    202|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 202]
  |  |  ------------------
  ------------------
  888|    202|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (888:17): [True: 0, False: 0]
  ------------------
  889|    202|        }
  890|      0|        else
  891|       |            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (891:13): [True: 0, False: 0]
  ------------------
  892|    202|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE11ParseStringILj32ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_b:
  959|   182k|    void ParseString(InputStream& is, Handler& handler, bool isKey = false) {
  960|   182k|        internal::StreamLocalCopy<InputStream> copy(is);
  961|   182k|        InputStream& s(copy.s);
  962|       |
  963|   182k|        RAPIDJSON_ASSERT(s.Peek() == '\"');
  ------------------
  |  |  437|   182k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (963:9): [True: 182k, False: 0]
  ------------------
  964|   182k|        s.Take();  // Skip '\"'
  965|       |
  966|   182k|        bool success = false;
  967|   182k|        if (parseFlags & kParseInsituFlag) {
  ------------------
  |  Branch (967:13): [Folded, False: 182k]
  ------------------
  968|      0|            typename InputStream::Ch *head = s.PutBegin();
  969|      0|            ParseStringToStream<parseFlags, SourceEncoding, SourceEncoding>(s, s);
  970|      0|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  971|      0|            size_t length = s.PutEnd(head) - 1;
  972|      0|            RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
  ------------------
  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (972:13): [True: 0, False: 0]
  ------------------
  973|      0|            const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
  974|      0|            success = (isKey ? handler.Key(str, SizeType(length), false) : handler.String(str, SizeType(length), false));
  ------------------
  |  Branch (974:24): [True: 0, False: 0]
  ------------------
  975|      0|        }
  976|   182k|        else {
  977|   182k|            StackStream<typename TargetEncoding::Ch> stackStream(stack_);
  978|   182k|            ParseStringToStream<parseFlags, SourceEncoding, TargetEncoding>(s, stackStream);
  979|   182k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   182k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   182k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   182k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   182k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   182k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   182k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   182k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  980|   182k|            SizeType length = static_cast<SizeType>(stackStream.Length()) - 1;
  981|   182k|            const typename TargetEncoding::Ch* const str = stackStream.Pop();
  982|   182k|            success = (isKey ? handler.Key(str, length, true) : handler.String(str, length, true));
  ------------------
  |  Branch (982:24): [True: 182k, False: 6]
  ------------------
  983|   182k|        }
  984|   182k|        if (RAPIDJSON_UNLIKELY(!success))
  ------------------
  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 182k]
  |  |  ------------------
  ------------------
  985|       |            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (985:13): [True: 0, False: 0]
  ------------------
  986|   182k|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE19ParseStringToStreamILj32ES2_S2_NS_19GenericStringStreamIS2_EENS4_11StackStreamIcEEEEvRT2_RT3_:
  991|   182k|    RAPIDJSON_FORCEINLINE void ParseStringToStream(InputStream& is, OutputStream& os) {
  992|       |//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  994|   182k|        static const char escape[256] = {
  995|   182k|            Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '/',
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '/',
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
  996|   182k|            Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
  997|   182k|            0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0,
  998|   182k|            0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  999|   182k|            Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
  ------------------
  |  |  993|   182k|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
 1000|   182k|        };
 1001|   182k|#undef Z16
 1002|       |//!@endcond
 1003|       |
 1004|   187k|        for (;;) {
 1005|       |            // Scan and copy string before "\\\"" or < 0x20. This is an optional optimzation.
 1006|   187k|            if (!(parseFlags & kParseValidateEncodingFlag))
  ------------------
  |  Branch (1006:17): [True: 187k, Folded]
  ------------------
 1007|   187k|                ScanCopyUnescapedString(is, os);
 1008|       |
 1009|   187k|            Ch c = is.Peek();
 1010|   187k|            if (RAPIDJSON_UNLIKELY(c == '\\')) {    // Escape
  ------------------
  |  |  505|   187k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 1, False: 187k]
  |  |  ------------------
  ------------------
 1011|      1|                size_t escapeOffset = is.Tell();    // For invalid escaping, report the initial '\\' as error offset
 1012|      1|                is.Take();
 1013|      1|                Ch e = is.Peek();
 1014|      1|                if ((sizeof(Ch) == 1 || unsigned(e) < 256) && RAPIDJSON_LIKELY(escape[static_cast<unsigned char>(e)])) {
  ------------------
  |  |  492|      1|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  |  Branch (1014:22): [True: 1, Folded]
  |  Branch (1014:41): [True: 0, False: 0]
  ------------------
 1015|      0|                    is.Take();
 1016|      0|                    os.Put(static_cast<typename TEncoding::Ch>(escape[static_cast<unsigned char>(e)]));
 1017|      0|                }
 1018|      1|                else if ((parseFlags & kParseEscapedApostropheFlag) && RAPIDJSON_LIKELY(e == '\'')) { // Allow escaped apostrophe
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1018:26): [Folded, False: 1]
  ------------------
 1019|      0|                    is.Take();
 1020|      0|                    os.Put('\'');
 1021|      0|                }
 1022|      1|                else if (RAPIDJSON_LIKELY(e == 'u')) {    // Unicode
  ------------------
  |  |  492|      1|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 1023|      1|                    is.Take();
 1024|      1|                    unsigned codepoint = ParseHex4(is, escapeOffset);
 1025|      1|                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|      1|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|      1|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|      1|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|      1|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 1]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 1]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1026|      1|                    if (RAPIDJSON_UNLIKELY(codepoint >= 0xD800 && codepoint <= 0xDFFF)) {
  ------------------
  |  |  505|      1|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 1]
  |  |  |  Branch (505:51): [True: 0, False: 1]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1027|       |                        // high surrogate, check if followed by valid low surrogate
 1028|      0|                        if (RAPIDJSON_LIKELY(codepoint <= 0xDBFF)) {
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1029|       |                            // Handle UTF-16 surrogate pair
 1030|      0|                            if (RAPIDJSON_UNLIKELY(!Consume(is, '\\') || !Consume(is, 'u')))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1031|      0|                                RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1031:33): [True: 0, False: 0]
  ------------------
 1032|      0|                            unsigned codepoint2 = ParseHex4(is, escapeOffset);
 1033|      0|                            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1034|      0|                            if (RAPIDJSON_UNLIKELY(codepoint2 < 0xDC00 || codepoint2 > 0xDFFF))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1035|      0|                                RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1035:33): [True: 0, False: 0]
  ------------------
 1036|      0|                            codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
 1037|      0|                        }
 1038|       |                        // single low surrogate
 1039|      0|                        else
 1040|      0|                        {
 1041|      0|                            RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1041:29): [True: 0, False: 0]
  ------------------
 1042|      0|                        }
 1043|      0|                    }
 1044|      1|                    TEncoding::Encode(os, codepoint);
 1045|      1|                }
 1046|      0|                else
 1047|      1|                    RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, escapeOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1047:21): [True: 0, False: 0]
  ------------------
 1048|      1|            }
 1049|   187k|            else if (RAPIDJSON_UNLIKELY(c == '"')) {    // Closing double quote
  ------------------
  |  |  505|   187k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 182k, False: 4.54k]
  |  |  ------------------
  ------------------
 1050|   182k|                is.Take();
 1051|   182k|                os.Put('\0');   // null-terminate the string
 1052|   182k|                return;
 1053|   182k|            }
 1054|  4.54k|            else if (RAPIDJSON_UNLIKELY(static_cast<unsigned>(c) < 0x20)) { // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
  ------------------
  |  |  505|  4.54k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 4.54k]
  |  |  ------------------
  ------------------
 1055|      0|                if (c == '\0')
  ------------------
  |  Branch (1055:21): [True: 0, False: 0]
  ------------------
 1056|      0|                    RAPIDJSON_PARSE_ERROR(kParseErrorStringMissQuotationMark, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1056:21): [True: 0, False: 0]
  ------------------
 1057|      0|                else
 1058|      0|                    RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1058:21): [True: 0, False: 0]
  ------------------
 1059|      0|            }
 1060|  4.54k|            else {
 1061|  4.54k|                size_t offset = is.Tell();
 1062|  4.54k|                if (RAPIDJSON_UNLIKELY((parseFlags & kParseValidateEncodingFlag ?
  ------------------
  |  |  505|  9.09k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 4.54k]
  |  |  |  Branch (505:51): [Folded, False: 4.54k]
  |  |  ------------------
  ------------------
 1063|  4.54k|                    !Transcoder<SEncoding, TEncoding>::Validate(is, os) :
 1064|  4.54k|                    !Transcoder<SEncoding, TEncoding>::Transcode(is, os))))
 1065|       |                    RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, offset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1065:21): [True: 0, False: 0]
  ------------------
 1066|  4.54k|            }
 1067|   187k|        }
 1068|   182k|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE11ParseObjectILj32ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  740|  7.53k|    void ParseObject(InputStream& is, Handler& handler) {
  741|  7.53k|        RAPIDJSON_ASSERT(is.Peek() == '{');
  ------------------
  |  |  437|  7.53k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (741:9): [True: 7.53k, False: 0]
  ------------------
  742|  7.53k|        is.Take();  // Skip '{'
  743|       |
  744|  7.53k|        if (RAPIDJSON_UNLIKELY(!handler.StartObject()))
  ------------------
  |  |  505|  7.53k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 7.53k]
  |  |  ------------------
  ------------------
  745|  7.53k|            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (745:13): [True: 0, False: 0]
  ------------------
  746|       |
  747|  7.53k|        SkipWhitespaceAndComments<parseFlags>(is);
  748|  7.53k|        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  7.53k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  7.53k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  7.53k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  7.53k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  7.53k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 7.53k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  7.53k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  7.53k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  7.53k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 7.53k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  749|       |
  750|  7.53k|        if (Consume(is, '}')) {
  ------------------
  |  Branch (750:13): [True: 3.76k, False: 3.77k]
  ------------------
  751|  3.76k|            if (RAPIDJSON_UNLIKELY(!handler.EndObject(0)))  // empty object
  ------------------
  |  |  505|  3.76k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 3.76k]
  |  |  ------------------
  ------------------
  752|  3.76k|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (752:17): [True: 0, False: 0]
  ------------------
  753|  3.76k|            return;
  754|  3.76k|        }
  755|       |
  756|   182k|        for (SizeType memberCount = 0;;) {
  757|   182k|            if (RAPIDJSON_UNLIKELY(is.Peek() != '"'))
  ------------------
  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 182k]
  |  |  ------------------
  ------------------
  758|   182k|                RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (758:17): [True: 0, False: 0]
  ------------------
  759|       |
  760|   182k|            ParseString<parseFlags>(is, handler, true);
  761|   182k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   182k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   182k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   182k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   182k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   182k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   182k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   182k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  762|       |
  763|   182k|            SkipWhitespaceAndComments<parseFlags>(is);
  764|   182k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   182k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   182k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   182k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   182k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   182k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   182k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   182k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  765|       |
  766|   182k|            if (RAPIDJSON_UNLIKELY(!Consume(is, ':')))
  ------------------
  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 182k]
  |  |  ------------------
  ------------------
  767|   182k|                RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (767:17): [True: 0, False: 0]
  ------------------
  768|       |
  769|   182k|            SkipWhitespaceAndComments<parseFlags>(is);
  770|   182k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   182k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   182k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   182k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   182k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   182k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   182k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   182k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  771|       |
  772|   182k|            ParseValue<parseFlags>(is, handler);
  773|   182k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   182k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   182k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   182k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   182k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 4, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   182k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   182k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   182k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  774|       |
  775|   182k|            SkipWhitespaceAndComments<parseFlags>(is);
  776|   182k|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   182k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   182k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   182k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   182k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   182k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   182k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   182k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   182k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 182k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  777|       |
  778|   182k|            ++memberCount;
  779|       |
  780|   182k|            switch (is.Peek()) {
  781|   179k|                case ',':
  ------------------
  |  Branch (781:17): [True: 179k, False: 3.76k]
  ------------------
  782|   179k|                    is.Take();
  783|   179k|                    SkipWhitespaceAndComments<parseFlags>(is);
  784|   179k|                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|   179k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|   179k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|   179k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|   179k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|   179k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 179k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|   179k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|   179k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|   179k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 179k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  785|   179k|                    break;
  786|   179k|                case '}':
  ------------------
  |  Branch (786:17): [True: 3.76k, False: 179k]
  ------------------
  787|  3.76k|                    is.Take();
  788|  3.76k|                    if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
  ------------------
  |  |  505|  3.76k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 3.76k]
  |  |  ------------------
  ------------------
  789|  3.76k|                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (789:25): [True: 0, False: 0]
  ------------------
  790|  3.76k|                    return;
  791|  3.76k|                default:
  ------------------
  |  Branch (791:17): [True: 0, False: 182k]
  ------------------
  792|      0|                    RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); break; // This useless break is only for making warning and coverage happy
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (792:21): [True: 0, False: 0]
  ------------------
  793|   182k|            }
  794|       |
  795|   179k|            if (parseFlags & kParseTrailingCommasFlag) {
  ------------------
  |  Branch (795:17): [Folded, False: 179k]
  ------------------
  796|      0|                if (is.Peek() == '}') {
  ------------------
  |  Branch (796:21): [True: 0, False: 0]
  ------------------
  797|      0|                    if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  798|      0|                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (798:25): [True: 0, False: 0]
  ------------------
  799|      0|                    is.Take();
  800|      0|                    return;
  801|      0|                }
  802|      0|            }
  803|   179k|        }
  804|  3.77k|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE10ParseArrayILj32ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
  808|  2.88k|    void ParseArray(InputStream& is, Handler& handler) {
  809|  2.88k|        RAPIDJSON_ASSERT(is.Peek() == '[');
  ------------------
  |  |  437|  2.88k|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (809:9): [True: 2.88k, False: 0]
  ------------------
  810|  2.88k|        is.Take();  // Skip '['
  811|       |
  812|  2.88k|        if (RAPIDJSON_UNLIKELY(!handler.StartArray()))
  ------------------
  |  |  505|  2.88k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 2.88k]
  |  |  ------------------
  ------------------
  813|  2.88k|            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (813:13): [True: 0, False: 0]
  ------------------
  814|       |
  815|  2.88k|        SkipWhitespaceAndComments<parseFlags>(is);
  816|  2.88k|        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  2.88k|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  2.88k|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  2.88k|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  2.88k|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  2.88k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 2.88k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  2.88k|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  2.88k|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  2.88k|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 2.88k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  817|       |
  818|  2.88k|        if (Consume(is, ']')) {
  ------------------
  |  Branch (818:13): [True: 2, False: 2.88k]
  ------------------
  819|      2|            if (RAPIDJSON_UNLIKELY(!handler.EndArray(0))) // empty array
  ------------------
  |  |  505|      2|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  820|      2|                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (820:17): [True: 0, False: 0]
  ------------------
  821|      2|            return;
  822|      2|        }
  823|       |
  824|  1.60M|        for (SizeType elementCount = 0;;) {
  825|  1.60M|            ParseValue<parseFlags>(is, handler);
  826|  1.60M|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  1.60M|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  1.60M|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  1.60M|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  1.60M|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  1.60M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 1.94k, False: 1.60M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  1.60M|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  1.60M|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  1.60M|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 1.60M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  827|       |
  828|  1.60M|            ++elementCount;
  829|  1.60M|            SkipWhitespaceAndComments<parseFlags>(is);
  830|  1.60M|            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  1.60M|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  1.60M|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  1.60M|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  1.60M|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  1.60M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 1.60M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  1.60M|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  1.60M|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  1.60M|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 1.60M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  831|       |
  832|  1.60M|            if (Consume(is, ',')) {
  ------------------
  |  Branch (832:17): [True: 1.60M, False: 945]
  ------------------
  833|  1.60M|                SkipWhitespaceAndComments<parseFlags>(is);
  834|  1.60M|                RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
  ------------------
  |  |   66|  1.60M|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  ------------------
  |  |  |  |   61|  1.60M|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|  1.60M|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |   62|  1.60M|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  ------------------
  |  |  |  |  |  |  505|  1.60M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 1.60M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   63|  1.60M|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|  1.60M|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|  1.60M|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 1.60M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  835|  1.60M|            }
  836|    945|            else if (Consume(is, ']')) {
  ------------------
  |  Branch (836:22): [True: 942, False: 3]
  ------------------
  837|    942|                if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
  ------------------
  |  |  505|    942|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 942]
  |  |  ------------------
  ------------------
  838|    942|                    RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (838:21): [True: 0, False: 0]
  ------------------
  839|    942|                return;
  840|    942|            }
  841|      3|            else
  842|    945|                RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
  ------------------
  |  |  120|      6|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      3|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      6|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      3|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      3|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      3|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      3|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      3|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      3|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      3|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      3|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 3]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      6|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      3|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      6|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      3|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      6|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      3|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 3, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      6|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      3|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      3|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      3|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      3|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      3|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (842:17): [True: 3, False: 0]
  ------------------
  843|       |
  844|  1.60M|            if (parseFlags & kParseTrailingCommasFlag) {
  ------------------
  |  Branch (844:17): [Folded, False: 1.60M]
  ------------------
  845|      0|                if (is.Peek() == ']') {
  ------------------
  |  Branch (845:21): [True: 0, False: 0]
  ------------------
  846|      0|                    if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  847|      0|                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (847:25): [True: 0, False: 0]
  ------------------
  848|      0|                    is.Take();
  849|      0|                    return;
  850|      0|                }
  851|      0|            }
  852|  1.60M|        }
  853|  2.88k|    }
_ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE11ParseNumberILj32ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
 1468|  1.78M|    void ParseNumber(InputStream& is, Handler& handler) {
 1469|  1.78M|        typedef typename internal::SelectIf<internal::BoolType<(parseFlags & kParseNumbersAsStringsFlag) != 0>, typename TargetEncoding::Ch, char>::Type NumberCharacter;
 1470|       |
 1471|  1.78M|        internal::StreamLocalCopy<InputStream> copy(is);
 1472|  1.78M|        NumberStream<InputStream, NumberCharacter,
 1473|  1.78M|            ((parseFlags & kParseNumbersAsStringsFlag) != 0) ?
 1474|  1.78M|                ((parseFlags & kParseInsituFlag) == 0) :
 1475|  1.78M|                ((parseFlags & kParseFullPrecisionFlag) != 0),
 1476|  1.78M|            (parseFlags & kParseNumbersAsStringsFlag) != 0 &&
 1477|  1.78M|                (parseFlags & kParseInsituFlag) == 0> s(*this, copy.s);
 1478|       |
 1479|  1.78M|        size_t startOffset = s.Tell();
 1480|  1.78M|        double d = 0.0;
 1481|  1.78M|        bool useNanOrInf = false;
 1482|       |
 1483|       |        // Parse minus
 1484|  1.78M|        bool minus = Consume(s, '-');
 1485|       |
 1486|       |        // Parse int: zero / ( digit1-9 *DIGIT )
 1487|  1.78M|        unsigned i = 0;
 1488|  1.78M|        uint64_t i64 = 0;
 1489|  1.78M|        bool use64bit = false;
 1490|  1.78M|        int significandDigit = 0;
 1491|  1.78M|        if (RAPIDJSON_UNLIKELY(s.Peek() == '0')) {
  ------------------
  |  |  505|  1.78M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 75.0k, False: 1.70M]
  |  |  ------------------
  ------------------
 1492|  75.0k|            i = 0;
 1493|  75.0k|            s.TakePush();
 1494|  75.0k|        }
 1495|  1.70M|        else if (RAPIDJSON_LIKELY(s.Peek() >= '1' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  3.41M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 1.70M, False: 5]
  |  |  |  Branch (492:49): [True: 1.70M, False: 1]
  |  |  |  Branch (492:49): [True: 1.70M, False: 4]
  |  |  ------------------
  ------------------
 1496|  1.70M|            i = static_cast<unsigned>(s.TakePush() - '0');
 1497|       |
 1498|  1.70M|            if (minus)
  ------------------
  |  Branch (1498:17): [True: 1.55k, False: 1.70M]
  ------------------
 1499|  3.66k|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  5.83k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 2.16k, False: 1.50k]
  |  |  |  Branch (492:49): [True: 2.16k, False: 1.50k]
  |  |  |  Branch (492:49): [True: 2.16k, False: 0]
  |  |  ------------------
  ------------------
 1500|  2.16k|                    if (RAPIDJSON_UNLIKELY(i >= 214748364)) { // 2^31 = 2147483648
  ------------------
  |  |  505|  2.16k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 55, False: 2.11k]
  |  |  ------------------
  ------------------
 1501|     55|                        if (RAPIDJSON_LIKELY(i != 214748364 || s.Peek() > '8')) {
  ------------------
  |  |  492|     55|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 55, False: 0]
  |  |  |  Branch (492:49): [True: 55, False: 0]
  |  |  |  Branch (492:49): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1502|     55|                            i64 = i;
 1503|     55|                            use64bit = true;
 1504|     55|                            break;
 1505|     55|                        }
 1506|     55|                    }
 1507|  2.11k|                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1508|  2.11k|                    significandDigit++;
 1509|  2.11k|                }
 1510|  1.70M|            else
 1511|  1.76M|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  1.83M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 67.0k, False: 1.70M]
  |  |  |  Branch (492:49): [True: 70.0k, False: 1.69M]
  |  |  |  Branch (492:49): [True: 67.0k, False: 3.06k]
  |  |  ------------------
  ------------------
 1512|  67.0k|                    if (RAPIDJSON_UNLIKELY(i >= 429496729)) { // 2^32 - 1 = 4294967295
  ------------------
  |  |  505|  67.0k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 3.49k, False: 63.5k]
  |  |  ------------------
  ------------------
 1513|  3.49k|                        if (RAPIDJSON_LIKELY(i != 429496729 || s.Peek() > '5')) {
  ------------------
  |  |  492|  3.50k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 3.49k, False: 4]
  |  |  |  Branch (492:49): [True: 3.48k, False: 9]
  |  |  |  Branch (492:49): [True: 5, False: 4]
  |  |  ------------------
  ------------------
 1514|  3.49k|                            i64 = i;
 1515|  3.49k|                            use64bit = true;
 1516|  3.49k|                            break;
 1517|  3.49k|                        }
 1518|  3.49k|                    }
 1519|  63.5k|                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1520|  63.5k|                    significandDigit++;
 1521|  63.5k|                }
 1522|  1.70M|        }
 1523|       |        // Parse NaN or Infinity here
 1524|      5|        else if ((parseFlags & kParseNanAndInfFlag) && RAPIDJSON_LIKELY((s.Peek() == 'I' || s.Peek() == 'N'))) {
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  |  Branch (492:49): [True: 0, False: 0]
  |  |  |  Branch (492:49): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1524:18): [Folded, False: 5]
  ------------------
 1525|      0|            if (Consume(s, 'N')) {
  ------------------
  |  Branch (1525:17): [True: 0, False: 0]
  ------------------
 1526|      0|                if (Consume(s, 'a') && Consume(s, 'N')) {
  ------------------
  |  Branch (1526:21): [True: 0, False: 0]
  |  Branch (1526:40): [True: 0, False: 0]
  ------------------
 1527|      0|                    d = std::numeric_limits<double>::quiet_NaN();
 1528|      0|                    useNanOrInf = true;
 1529|      0|                }
 1530|      0|            }
 1531|      0|            else if (RAPIDJSON_LIKELY(Consume(s, 'I'))) {
  ------------------
  |  |  492|      0|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1532|      0|                if (Consume(s, 'n') && Consume(s, 'f')) {
  ------------------
  |  Branch (1532:21): [True: 0, False: 0]
  |  Branch (1532:40): [True: 0, False: 0]
  ------------------
 1533|      0|                    d = (minus ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity());
  ------------------
  |  Branch (1533:26): [True: 0, False: 0]
  ------------------
 1534|      0|                    useNanOrInf = true;
 1535|       |
 1536|      0|                    if (RAPIDJSON_UNLIKELY(s.Peek() == 'i' && !(Consume(s, 'i') && Consume(s, 'n')
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  |  Branch (505:51): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1537|      0|                                                                && Consume(s, 'i') && Consume(s, 't') && Consume(s, 'y')))) {
 1538|      0|                        RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1538:25): [True: 0, False: 0]
  ------------------
 1539|      0|                    }
 1540|      0|                }
 1541|      0|            }
 1542|       |
 1543|      0|            if (RAPIDJSON_UNLIKELY(!useNanOrInf)) {
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1544|      0|                RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1544:17): [True: 0, False: 0]
  ------------------
 1545|      0|            }
 1546|      0|        }
 1547|      5|        else
 1548|      5|            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
  ------------------
  |  |  120|     10|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      5|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|     10|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      5|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      5|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      5|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      5|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      5|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      5|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      5|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      5|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|     10|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      5|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|     10|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      5|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|     10|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      5|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 5, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|     10|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      5|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      5|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      5|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      5|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      5|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1548:13): [True: 5, False: 0]
  ------------------
 1549|       |
 1550|       |        // Parse 64bit int
 1551|  1.78M|        bool useDouble = false;
 1552|  1.78M|        if (use64bit) {
  ------------------
  |  Branch (1552:13): [True: 3.54k, False: 1.77M]
  ------------------
 1553|  3.54k|            if (minus)
  ------------------
  |  Branch (1553:17): [True: 55, False: 3.49k]
  ------------------
 1554|    149|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|    245|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 96, False: 53]
  |  |  |  Branch (492:49): [True: 96, False: 53]
  |  |  |  Branch (492:49): [True: 96, False: 0]
  |  |  ------------------
  ------------------
 1555|     96|                     if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC))) // 2^63 = 9223372036854775808
  ------------------
  |  |  505|     96|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 2, False: 94]
  |  |  ------------------
  ------------------
 1556|      2|                        if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC) || s.Peek() > '8')) {
  ------------------
  |  |  492|      2|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 2, False: 0]
  |  |  |  Branch (492:49): [True: 2, False: 0]
  |  |  |  Branch (492:49): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1557|      2|                            d = static_cast<double>(i64);
 1558|      2|                            useDouble = true;
 1559|      2|                            break;
 1560|      2|                        }
 1561|     94|                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1562|     94|                    significandDigit++;
 1563|     94|                }
 1564|  3.49k|            else
 1565|  32.4k|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  62.9k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 30.4k, False: 1.92k]
  |  |  |  Branch (492:49): [True: 30.5k, False: 1.87k]
  |  |  |  Branch (492:49): [True: 30.4k, False: 48]
  |  |  ------------------
  ------------------
 1566|  30.4k|                    if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999))) // 2^64 - 1 = 18446744073709551615
  ------------------
  |  |  505|  30.4k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 1.56k, False: 28.9k]
  |  |  ------------------
  ------------------
 1567|  1.56k|                        if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || s.Peek() > '5')) {
  ------------------
  |  |  492|  1.57k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 1.56k, False: 4]
  |  |  |  Branch (492:49): [True: 1.56k, False: 4]
  |  |  |  Branch (492:49): [True: 0, False: 4]
  |  |  ------------------
  ------------------
 1568|  1.56k|                            d = static_cast<double>(i64);
 1569|  1.56k|                            useDouble = true;
 1570|  1.56k|                            break;
 1571|  1.56k|                        }
 1572|  28.9k|                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1573|  28.9k|                    significandDigit++;
 1574|  28.9k|                }
 1575|  3.54k|        }
 1576|       |
 1577|       |        // Force double for big integer
 1578|  1.78M|        if (useDouble) {
  ------------------
  |  Branch (1578:13): [True: 1.56k, False: 1.77M]
  ------------------
 1579|  1.92M|            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  3.85M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 1.92M, False: 1.56k]
  |  |  |  Branch (492:49): [True: 1.92M, False: 1.55k]
  |  |  |  Branch (492:49): [True: 1.92M, False: 10]
  |  |  ------------------
  ------------------
 1580|  1.92M|                d = d * 10 + (s.TakePush() - '0');
 1581|  1.92M|            }
 1582|  1.56k|        }
 1583|       |
 1584|       |        // Parse frac = decimal-point 1*DIGIT
 1585|  1.78M|        int expFrac = 0;
 1586|  1.78M|        size_t decimalPosition;
 1587|  1.78M|        if (!useNanOrInf && Consume(s, '.')) {
  ------------------
  |  Branch (1587:13): [True: 1.78M, False: 0]
  |  Branch (1587:29): [True: 10.8k, False: 1.76M]
  ------------------
 1588|  10.8k|            decimalPosition = s.Length();
 1589|       |
 1590|  10.8k|            if (RAPIDJSON_UNLIKELY(!(s.Peek() >= '0' && s.Peek() <= '9')))
  ------------------
  |  |  505|  21.7k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 10.8k]
  |  |  |  Branch (505:51): [True: 10.8k, False: 0]
  |  |  |  Branch (505:51): [True: 10.8k, False: 0]
  |  |  ------------------
  ------------------
 1591|  10.8k|                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1591:17): [True: 0, False: 0]
  ------------------
 1592|       |
 1593|  10.8k|            if (!useDouble) {
  ------------------
  |  Branch (1593:17): [True: 10.6k, False: 188]
  ------------------
 1594|  10.6k|#if RAPIDJSON_64BIT
 1595|       |                // Use i64 to store significand in 64-bit architecture
 1596|  10.6k|                if (!use64bit)
  ------------------
  |  Branch (1596:21): [True: 10.6k, False: 62]
  ------------------
 1597|  10.6k|                    i64 = i;
 1598|       |
 1599|   417k|                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|   823k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 406k, False: 10.6k]
  |  |  |  Branch (492:49): [True: 406k, False: 10.5k]
  |  |  |  Branch (492:49): [True: 406k, False: 107]
  |  |  ------------------
  ------------------
 1600|   406k|                    if (i64 > RAPIDJSON_UINT64_C2(0x1FFFFF, 0xFFFFFFFF)) // 2^53 - 1 for fast path
  ------------------
  |  |  320|   406k|#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
  ------------------
  |  Branch (1600:25): [True: 21, False: 406k]
  ------------------
 1601|     21|                        break;
 1602|   406k|                    else {
 1603|   406k|                        i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
 1604|   406k|                        --expFrac;
 1605|   406k|                        if (i64 != 0)
  ------------------
  |  Branch (1605:29): [True: 10.8k, False: 395k]
  ------------------
 1606|  10.8k|                            significandDigit++;
 1607|   406k|                    }
 1608|   406k|                }
 1609|       |
 1610|  10.6k|                d = static_cast<double>(i64);
 1611|       |#else
 1612|       |                // Use double to store significand in 32-bit architecture
 1613|       |                d = static_cast<double>(use64bit ? i64 : i);
 1614|       |#endif
 1615|  10.6k|                useDouble = true;
 1616|  10.6k|            }
 1617|       |
 1618|  7.18M|            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  14.3M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 7.17M, False: 10.8k]
  |  |  |  Branch (492:49): [True: 7.17M, False: 10.5k]
  |  |  |  Branch (492:49): [True: 7.17M, False: 305]
  |  |  ------------------
  ------------------
 1619|  7.17M|                if (significandDigit < 17) {
  ------------------
  |  Branch (1619:21): [True: 14, False: 7.17M]
  ------------------
 1620|     14|                    d = d * 10.0 + (s.TakePush() - '0');
 1621|     14|                    --expFrac;
 1622|     14|                    if (RAPIDJSON_LIKELY(d > 0.0))
  ------------------
  |  |  492|     14|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 14, False: 0]
  |  |  ------------------
  ------------------
 1623|     14|                        significandDigit++;
 1624|     14|                }
 1625|  7.17M|                else
 1626|  7.17M|                    s.TakePush();
 1627|  7.17M|            }
 1628|  10.8k|        }
 1629|  1.76M|        else
 1630|  1.76M|            decimalPosition = s.Length(); // decimal position at the end of integer.
 1631|       |
 1632|       |        // Parse exp = e [ minus / plus ] 1*DIGIT
 1633|  1.78M|        int exp = 0;
 1634|  1.78M|        if (!useNanOrInf && (Consume(s, 'e') || Consume(s, 'E'))) {
  ------------------
  |  Branch (1634:13): [True: 1.78M, False: 0]
  |  Branch (1634:30): [True: 436, False: 1.78M]
  |  Branch (1634:49): [True: 2.98k, False: 1.77M]
  ------------------
 1635|  3.42k|            if (!useDouble) {
  ------------------
  |  Branch (1635:17): [True: 3.10k, False: 313]
  ------------------
 1636|  3.10k|                d = static_cast<double>(use64bit ? i64 : i);
  ------------------
  |  Branch (1636:41): [True: 48, False: 3.06k]
  ------------------
 1637|  3.10k|                useDouble = true;
 1638|  3.10k|            }
 1639|       |
 1640|  3.42k|            bool expMinus = false;
 1641|  3.42k|            if (Consume(s, '+'))
  ------------------
  |  Branch (1641:17): [True: 0, False: 3.42k]
  ------------------
 1642|      0|                ;
 1643|  3.42k|            else if (Consume(s, '-'))
  ------------------
  |  Branch (1643:22): [True: 432, False: 2.99k]
  ------------------
 1644|    432|                expMinus = true;
 1645|       |
 1646|  3.42k|            if (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  6.84k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 3.42k, False: 0]
  |  |  |  Branch (492:49): [True: 3.42k, False: 0]
  |  |  |  Branch (492:49): [True: 3.42k, False: 0]
  |  |  ------------------
  ------------------
 1647|  3.42k|                exp = static_cast<int>(s.Take() - '0');
 1648|  3.42k|                if (expMinus) {
  ------------------
  |  Branch (1648:21): [True: 432, False: 2.99k]
  ------------------
 1649|       |                    // (exp + expFrac) must not underflow int => we're detecting when -exp gets
 1650|       |                    // dangerously close to INT_MIN (a pessimistic next digit 9 would push it into
 1651|       |                    // underflow territory):
 1652|       |                    //
 1653|       |                    //        -(exp * 10 + 9) + expFrac >= INT_MIN
 1654|       |                    //   <=>  exp <= (expFrac - INT_MIN - 9) / 10
 1655|    432|                    RAPIDJSON_ASSERT(expFrac <= 0);
  ------------------
  |  |  437|    432|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (1655:21): [True: 432, False: 0]
  ------------------
 1656|    432|                    int maxExp = (expFrac + 2147483639) / 10;
 1657|       |
 1658|   854k|                    while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|  1.70M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 854k, False: 432]
  |  |  |  Branch (492:49): [True: 854k, False: 431]
  |  |  |  Branch (492:49): [True: 854k, False: 1]
  |  |  ------------------
  ------------------
 1659|   854k|                        exp = exp * 10 + static_cast<int>(s.Take() - '0');
 1660|   854k|                        if (RAPIDJSON_UNLIKELY(exp > maxExp)) {
  ------------------
  |  |  505|   854k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 5, False: 854k]
  |  |  ------------------
  ------------------
 1661|     13|                            while (RAPIDJSON_UNLIKELY(s.Peek() >= '0' && s.Peek() <= '9'))  // Consume the rest of exponent
  ------------------
  |  |  505|     21|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 8, False: 5]
  |  |  |  Branch (505:51): [True: 8, False: 5]
  |  |  |  Branch (505:51): [True: 8, False: 0]
  |  |  ------------------
  ------------------
 1662|      8|                                s.Take();
 1663|      5|                        }
 1664|   854k|                    }
 1665|    432|                }
 1666|  2.99k|                else {  // positive exp
 1667|  2.99k|                    int maxExp = 308 - expFrac;
 1668|   486k|                    while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
  ------------------
  |  |  492|   970k|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (492:29): [True: 483k, False: 2.98k]
  |  |  |  Branch (492:49): [True: 483k, False: 2.98k]
  |  |  |  Branch (492:49): [True: 483k, False: 0]
  |  |  ------------------
  ------------------
 1669|   483k|                        exp = exp * 10 + static_cast<int>(s.Take() - '0');
 1670|   483k|                        if (RAPIDJSON_UNLIKELY(exp > maxExp))
  ------------------
  |  |  505|   483k|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 1, False: 483k]
  |  |  ------------------
  ------------------
 1671|   483k|                            RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
  ------------------
  |  |  120|      2|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      2|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      1|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      1|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      1|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      1|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 1]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      2|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      1|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      2|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      1|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      2|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      1|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 1, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      2|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      1|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      1|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      1|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1671:29): [True: 1, False: 0]
  ------------------
 1672|   483k|                    }
 1673|  2.99k|                }
 1674|  3.42k|            }
 1675|      0|            else
 1676|  3.42k|                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissExponent, s.Tell());
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1676:17): [True: 0, False: 0]
  ------------------
 1677|       |
 1678|  3.42k|            if (expMinus)
  ------------------
  |  Branch (1678:17): [True: 432, False: 2.98k]
  ------------------
 1679|    432|                exp = -exp;
 1680|  3.42k|        }
 1681|       |
 1682|       |        // Finish parsing, call event according to the type of number.
 1683|  1.78M|        bool cont = true;
 1684|       |
 1685|  1.78M|        if (parseFlags & kParseNumbersAsStringsFlag) {
  ------------------
  |  Branch (1685:13): [Folded, False: 1.78M]
  ------------------
 1686|      0|            if (parseFlags & kParseInsituFlag) {
  ------------------
  |  Branch (1686:17): [Folded, False: 0]
  ------------------
 1687|      0|                s.Pop();  // Pop stack no matter if it will be used or not.
 1688|      0|                typename InputStream::Ch* head = is.PutBegin();
 1689|      0|                const size_t length = s.Tell() - startOffset;
 1690|      0|                RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
  ------------------
  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (1690:17): [True: 0, False: 0]
  ------------------
 1691|       |                // unable to insert the \0 character here, it will erase the comma after this number
 1692|      0|                const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
 1693|      0|                cont = handler.RawNumber(str, SizeType(length), false);
 1694|      0|            }
 1695|      0|            else {
 1696|      0|                SizeType numCharsToCopy = static_cast<SizeType>(s.Length());
 1697|      0|                GenericStringStream<UTF8<NumberCharacter> > srcStream(s.Pop());
 1698|      0|                StackStream<typename TargetEncoding::Ch> dstStream(stack_);
 1699|      0|                while (numCharsToCopy--) {
  ------------------
  |  Branch (1699:24): [True: 0, False: 0]
  ------------------
 1700|      0|                    Transcoder<UTF8<typename TargetEncoding::Ch>, TargetEncoding>::Transcode(srcStream, dstStream);
 1701|      0|                }
 1702|      0|                dstStream.Put('\0');
 1703|      0|                const typename TargetEncoding::Ch* str = dstStream.Pop();
 1704|      0|                const SizeType length = static_cast<SizeType>(dstStream.Length()) - 1;
 1705|      0|                cont = handler.RawNumber(str, SizeType(length), true);
 1706|      0|            }
 1707|      0|        }
 1708|  1.78M|        else {
 1709|  1.78M|           size_t length = s.Length();
 1710|  1.78M|           const NumberCharacter* decimal = s.Pop();  // Pop stack no matter if it will be used or not.
 1711|       |
 1712|  1.78M|           if (useDouble) {
  ------------------
  |  Branch (1712:16): [True: 15.3k, False: 1.76M]
  ------------------
 1713|  15.3k|               int p = exp + expFrac;
 1714|  15.3k|               if (parseFlags & kParseFullPrecisionFlag)
  ------------------
  |  Branch (1714:20): [Folded, False: 15.3k]
  ------------------
 1715|      0|                   d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp);
 1716|  15.3k|               else
 1717|  15.3k|                   d = internal::StrtodNormalPrecision(d, p);
 1718|       |
 1719|       |               // Use > max, instead of == inf, to fix bogus warning -Wfloat-equal
 1720|  15.3k|               if (d > (std::numeric_limits<double>::max)()) {
  ------------------
  |  Branch (1720:20): [True: 6, False: 15.3k]
  ------------------
 1721|       |                   // Overflow
 1722|       |                   // TODO: internal::StrtodX should report overflow (or underflow)
 1723|      6|                   RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
  ------------------
  |  |  120|      6|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      6|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      6|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      6|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      6|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      6|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      6|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      6|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      6|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      6|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      6|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 6]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      6|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      6|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|     12|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      6|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|     12|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      6|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 6, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|     12|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      6|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      6|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      6|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      6|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      6|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1723:20): [True: 6, False: 0]
  ------------------
 1724|      6|               }
 1725|       |
 1726|  15.3k|               cont = handler.Double(minus ? -d : d);
  ------------------
  |  Branch (1726:38): [True: 3, False: 15.3k]
  ------------------
 1727|  15.3k|           }
 1728|  1.76M|           else if (useNanOrInf) {
  ------------------
  |  Branch (1728:21): [True: 0, False: 1.76M]
  ------------------
 1729|      0|               cont = handler.Double(d);
 1730|      0|           }
 1731|  1.76M|           else {
 1732|  1.76M|               if (use64bit) {
  ------------------
  |  Branch (1732:20): [True: 1.87k, False: 1.76M]
  ------------------
 1733|  1.87k|                   if (minus)
  ------------------
  |  Branch (1733:24): [True: 53, False: 1.81k]
  ------------------
 1734|     53|                       cont = handler.Int64(static_cast<int64_t>(~i64 + 1));
 1735|  1.81k|                   else
 1736|  1.81k|                       cont = handler.Uint64(i64);
 1737|  1.87k|               }
 1738|  1.76M|               else {
 1739|  1.76M|                   if (minus)
  ------------------
  |  Branch (1739:24): [True: 1.68k, False: 1.76M]
  ------------------
 1740|  1.68k|                       cont = handler.Int(static_cast<int32_t>(~i + 1));
 1741|  1.76M|                   else
 1742|  1.76M|                       cont = handler.Uint(i);
 1743|  1.76M|               }
 1744|  1.76M|           }
 1745|  1.78M|        }
 1746|  1.78M|        if (RAPIDJSON_UNLIKELY(!cont))
  ------------------
  |  |  505|  1.78M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 1.78M]
  |  |  ------------------
  ------------------
 1747|       |            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, startOffset);
  ------------------
  |  |  120|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  ------------------
  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  ------------------
  |  |  121|      0|    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
  |  |  ------------------
  |  |  |  |  101|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  ------------------
  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  ------------------
  |  |  |  |  102|      0|    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
  |  |  |  |  ------------------
  |  |  |  |  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  |  |  |  |  ------------------
  |  |  |  |  103|      0|    SetParseError(parseErrorCode, offset); \
  |  |  |  |  104|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  122|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
  |  |  ------------------
  |  |  |  |   66|      0|    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|    RAPIDJSON_MULTILINEMACRO_BEGIN \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  516|      0|#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|      0|    RAPIDJSON_MULTILINEMACRO_END
  |  |  ------------------
  |  |  |  |  517|      0|#define RAPIDJSON_MULTILINEMACRO_END \
  |  |  |  |  518|      0|} while((void)0, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (518:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1747:13): [True: 0, False: 0]
  ------------------
 1748|  1.78M|    }

_ZN9rapidjson19GenericStringStreamINS_4UTF8IcEEEC2EPKc:
  157|  5.72M|    GenericStringStream(const Ch *src) : src_(src), head_(src) {}
_ZN9rapidjson19GenericStringStreamINS_4UTF8IcEEE4TakeEv:
  160|  91.9M|    Ch Take() { return *src_++; }
_ZNK9rapidjson19GenericStringStreamINS_4UTF8IcEEE4PeekEv:
  159|   255M|    Ch Peek() const { return *src_; }
_ZNK9rapidjson19GenericStringStreamINS_4UTF8IcEEE4TellEv:
  161|  24.4M|    size_t Tell() const { return static_cast<size_t>(src_ - head_); }

_ZN9rapidjson19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEC2EPS3_m:
   45|     44|    GenericStringBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
_ZN9rapidjson19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEE3PutEc:
   56|  8.44M|    void Put(Ch c) { *stack_.template Push<Ch>() = c; }
_ZN9rapidjson4PutNINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEEcEEvRT_T0_m:
  111|  3.48M|inline void PutN(GenericStringBuffer<UTF8<> >& stream, char c, size_t n) {
  112|  3.48M|    std::memset(stream.stack_.Push<char>(n), c, n * sizeof(c));
  113|  3.48M|}
_ZN9rapidjson19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEE5FlushEv:
   58|     59|    void Flush() {}
_ZN9rapidjson10PutReserveINS_4UTF8IcEENS_12CrtAllocatorEEEvRNS_19GenericStringBufferIT_T0_EEm:
  100|  2.48M|inline void PutReserve(GenericStringBuffer<Encoding, Allocator>& stream, size_t count) {
  101|  2.48M|    stream.Reserve(count);
  102|  2.48M|}
_ZN9rapidjson19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEE7ReserveEm:
   68|  2.48M|    void Reserve(size_t count) { stack_.template Reserve<Ch>(count); }
_ZN9rapidjson9PutUnsafeINS_4UTF8IcEENS_12CrtAllocatorEEEvRNS_19GenericStringBufferIT_T0_EENS5_2ChE:
  105|  16.4M|inline void PutUnsafe(GenericStringBuffer<Encoding, Allocator>& stream, typename Encoding::Ch c) {
  106|  16.4M|    stream.PutUnsafe(c);
  107|  16.4M|}
_ZN9rapidjson19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEE9PutUnsafeEc:
   57|  16.4M|    void PutUnsafe(Ch c) { *stack_.template PushUnsafe<Ch>() = c; }
_ZN9rapidjson19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEE4PushEm:
   69|  1.70M|    Ch* Push(size_t count) { return stack_.template Push<Ch>(count); }
_ZN9rapidjson19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEE3PopEm:
   71|  1.70M|    void Pop(size_t count) { stack_.template Pop<Ch>(count); }
_ZNK9rapidjson19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEE9GetStringEv:
   73|     44|    const Ch* GetString() const {
   74|       |        // Push and pop a null terminator. This is safe.
   75|     44|        *stack_.template Push<Ch>() = '\0';
   76|     44|        stack_.template Pop<Ch>(1);
   77|       |
   78|     44|        return stack_.template Bottom<Ch>();
   79|     44|    }

_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EEC2ERS5_PS4_m:
  104|     44|        os_(&os), level_stack_(stackAllocator, levelDepth * sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {}
_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE8EndValueEb:
  500|  4.20M|    bool EndValue(bool ret) {
  501|  4.20M|        if (RAPIDJSON_UNLIKELY(level_stack_.Empty()))   // end of json text
  ------------------
  |  |  505|  4.20M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 44, False: 4.20M]
  |  |  ------------------
  ------------------
  502|     44|            Flush();
  503|  4.20M|        return ret;
  504|  4.20M|    }
_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE5FlushEv:
  283|     59|    void Flush() {
  284|     59|        os_->Flush();
  285|     59|    }
_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE9WriteNullEv:
  297|      9|    bool WriteNull()  {
  298|      9|        PutReserve(*os_, 4);
  299|      9|        PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 'l'); return true;
  300|      9|    }
_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE9WriteBoolEb:
  302|    311|    bool WriteBool(bool b)  {
  303|    311|        if (b) {
  ------------------
  |  Branch (303:13): [True: 11, False: 300]
  ------------------
  304|     11|            PutReserve(*os_, 4);
  305|     11|            PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'r'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'e');
  306|     11|        }
  307|    300|        else {
  308|    300|            PutReserve(*os_, 5);
  309|    300|            PutUnsafe(*os_, 'f'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 's'); PutUnsafe(*os_, 'e');
  310|    300|        }
  311|    311|        return true;
  312|    311|    }
_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE5LevelC2Eb:
  292|  15.4k|        Level(bool inArray_) : valueCount(0), inArray(inArray_) {}
_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE16WriteStartObjectEv:
  461|     74|    bool WriteStartObject() { os_->Put('{'); return true; }
_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE14WriteEndObjectEv:
  462|     74|    bool WriteEndObject()   { os_->Put('}'); return true; }
_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE15WriteStartArrayEv:
  463|  15.4k|    bool WriteStartArray()  { os_->Put('['); return true; }
_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE13WriteEndArrayEv:
  464|  15.4k|    bool WriteEndArray()    { os_->Put(']'); return true; }
_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE11WriteStringEPKcj:
  383|  2.48M|    bool WriteString(const Ch* str, SizeType length)  {
  384|  2.48M|        static const typename OutputStream::Ch hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
  385|  2.48M|        static const char escape[256] = {
  386|  2.48M|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  387|       |            //0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
  388|  2.48M|            'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't', 'n', 'u', 'f', 'r', 'u', 'u', // 00
  389|  2.48M|            'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', // 10
  390|  2.48M|              0,   0, '"',   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 20
  391|  2.48M|            Z16, Z16,                                                                       // 30~4F
  ------------------
  |  |  386|  2.48M|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16,                                                                       // 30~4F
  ------------------
  |  |  386|  2.48M|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
  392|  2.48M|              0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,'\\',   0,   0,   0, // 50
  393|  2.48M|            Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
  ------------------
  |  |  386|  2.48M|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
  ------------------
  |  |  386|  2.48M|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
  ------------------
  |  |  386|  2.48M|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
  ------------------
  |  |  386|  2.48M|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
  ------------------
  |  |  386|  2.48M|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
  ------------------
  |  |  386|  2.48M|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
  ------------------
  |  |  386|  2.48M|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
  ------------------
  |  |  386|  2.48M|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
  ------------------
  |  |  386|  2.48M|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
                          Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
  ------------------
  |  |  386|  2.48M|#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ------------------
  394|  2.48M|#undef Z16
  395|  2.48M|        };
  396|       |
  397|  2.48M|        if (TargetEncoding::supportUnicode)
  ------------------
  |  Branch (397:13): [True: 2.48M, Folded]
  ------------------
  398|  2.48M|            PutReserve(*os_, 2 + length * 6); // "\uxxxx..."
  399|      0|        else
  400|      0|            PutReserve(*os_, 2 + length * 12);  // "\uxxxx\uyyyy..."
  401|       |
  402|  2.48M|        PutUnsafe(*os_, '\"');
  403|  2.48M|        GenericStringStream<SourceEncoding> is(str);
  404|  13.9M|        while (ScanWriteUnescapedString(is, length)) {
  ------------------
  |  Branch (404:16): [True: 11.4M, False: 2.48M]
  ------------------
  405|  11.4M|            const Ch c = is.Peek();
  406|  11.4M|            if (!TargetEncoding::supportUnicode && static_cast<unsigned>(c) >= 0x80) {
  ------------------
  |  Branch (406:17): [Folded, False: 11.4M]
  |  Branch (406:52): [True: 0, False: 0]
  ------------------
  407|       |                // Unicode escaping
  408|      0|                unsigned codepoint;
  409|      0|                if (RAPIDJSON_UNLIKELY(!SourceEncoding::Decode(is, &codepoint)))
  ------------------
  |  |  505|      0|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  410|      0|                    return false;
  411|      0|                PutUnsafe(*os_, '\\');
  412|      0|                PutUnsafe(*os_, 'u');
  413|      0|                if (codepoint <= 0xD7FF || (codepoint >= 0xE000 && codepoint <= 0xFFFF)) {
  ------------------
  |  Branch (413:21): [True: 0, False: 0]
  |  Branch (413:45): [True: 0, False: 0]
  |  Branch (413:68): [True: 0, False: 0]
  ------------------
  414|      0|                    PutUnsafe(*os_, hexDigits[(codepoint >> 12) & 15]);
  415|      0|                    PutUnsafe(*os_, hexDigits[(codepoint >>  8) & 15]);
  416|      0|                    PutUnsafe(*os_, hexDigits[(codepoint >>  4) & 15]);
  417|      0|                    PutUnsafe(*os_, hexDigits[(codepoint      ) & 15]);
  418|      0|                }
  419|      0|                else {
  420|      0|                    RAPIDJSON_ASSERT(codepoint >= 0x010000 && codepoint <= 0x10FFFF);
  ------------------
  |  |  437|      0|#define RAPIDJSON_ASSERT(x) assert(x)
  ------------------
  |  Branch (420:21): [True: 0, False: 0]
  |  Branch (420:21): [True: 0, False: 0]
  |  Branch (420:21): [True: 0, False: 0]
  ------------------
  421|       |                    // Surrogate pair
  422|      0|                    unsigned s = codepoint - 0x010000;
  423|      0|                    unsigned lead = (s >> 10) + 0xD800;
  424|      0|                    unsigned trail = (s & 0x3FF) + 0xDC00;
  425|      0|                    PutUnsafe(*os_, hexDigits[(lead >> 12) & 15]);
  426|      0|                    PutUnsafe(*os_, hexDigits[(lead >>  8) & 15]);
  427|      0|                    PutUnsafe(*os_, hexDigits[(lead >>  4) & 15]);
  428|      0|                    PutUnsafe(*os_, hexDigits[(lead      ) & 15]);
  429|      0|                    PutUnsafe(*os_, '\\');
  430|      0|                    PutUnsafe(*os_, 'u');
  431|      0|                    PutUnsafe(*os_, hexDigits[(trail >> 12) & 15]);
  432|      0|                    PutUnsafe(*os_, hexDigits[(trail >>  8) & 15]);
  433|      0|                    PutUnsafe(*os_, hexDigits[(trail >>  4) & 15]);
  434|      0|                    PutUnsafe(*os_, hexDigits[(trail      ) & 15]);                    
  435|      0|                }
  436|      0|            }
  437|  11.4M|            else if ((sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256) && RAPIDJSON_UNLIKELY(escape[static_cast<unsigned char>(c)]))  {
  ------------------
  |  |  505|  11.4M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 2.26k, False: 11.4M]
  |  |  ------------------
  ------------------
  |  Branch (437:23): [True: 11.4M, Folded]
  |  Branch (437:42): [True: 0, False: 0]
  ------------------
  438|  2.26k|                is.Take();
  439|  2.26k|                PutUnsafe(*os_, '\\');
  440|  2.26k|                PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(escape[static_cast<unsigned char>(c)]));
  441|  2.26k|                if (escape[static_cast<unsigned char>(c)] == 'u') {
  ------------------
  |  Branch (441:21): [True: 0, False: 2.26k]
  ------------------
  442|      0|                    PutUnsafe(*os_, '0');
  443|      0|                    PutUnsafe(*os_, '0');
  444|      0|                    PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) >> 4]);
  445|      0|                    PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) & 0xF]);
  446|      0|                }
  447|  2.26k|            }
  448|  11.4M|            else if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ? 
  ------------------
  |  |  505|  22.8M|#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (505:31): [True: 0, False: 11.4M]
  |  |  |  Branch (505:51): [Folded, False: 11.4M]
  |  |  ------------------
  ------------------
  449|  11.4M|                Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_) :
  450|  11.4M|                Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
  451|      0|                return false;
  452|  11.4M|        }
  453|  2.48M|        PutUnsafe(*os_, '\"');
  454|  2.48M|        return true;
  455|  2.48M|    }
_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE24ScanWriteUnescapedStringERNS_19GenericStringStreamIS3_EEm:
  457|  13.9M|    bool ScanWriteUnescapedString(GenericStringStream<SourceEncoding>& is, size_t length) {
  458|  13.9M|        return RAPIDJSON_LIKELY(is.Tell() < length);
  ------------------
  |  |  492|  13.9M|#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
  ------------------
  459|  13.9M|    }
_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE11WriteDoubleEd:
  552|  7.71k|inline bool Writer<StringBuffer>::WriteDouble(double d) {
  553|  7.71k|    if (internal::Double(d).IsNanOrInf()) {
  ------------------
  |  Branch (553:9): [True: 0, False: 7.71k]
  ------------------
  554|       |        // Note: This code path can only be reached if (RAPIDJSON_WRITE_DEFAULT_FLAGS & kWriteNanAndInfFlag).
  555|      0|        if (!(kWriteDefaultFlags & kWriteNanAndInfFlag))
  ------------------
  |  Branch (555:13): [True: 0, Folded]
  ------------------
  556|      0|            return false;
  557|      0|        if (kWriteDefaultFlags & kWriteNanAndInfNullFlag) {
  ------------------
  |  Branch (557:13): [Folded, False: 0]
  ------------------
  558|      0|            PutReserve(*os_, 4);
  559|      0|            PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 'l');
  560|      0|            return true;
  561|      0|        }
  562|      0|        if (internal::Double(d).IsNan()) {
  ------------------
  |  Branch (562:13): [True: 0, False: 0]
  ------------------
  563|      0|            PutReserve(*os_, 3);
  564|      0|            PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N');
  565|      0|            return true;
  566|      0|        }
  567|      0|        if (internal::Double(d).Sign()) {
  ------------------
  |  Branch (567:13): [True: 0, False: 0]
  ------------------
  568|      0|            PutReserve(*os_, 9);
  569|      0|            PutUnsafe(*os_, '-');
  570|      0|        }
  571|      0|        else
  572|      0|            PutReserve(*os_, 8);
  573|      0|        PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f');
  574|      0|        PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y');
  575|      0|        return true;
  576|      0|    }
  577|       |    
  578|  7.71k|    char *buffer = os_->Push(25);
  579|  7.71k|    char* end = internal::dtoa(d, buffer, maxDecimalPlaces_);
  580|  7.71k|    os_->Pop(static_cast<size_t>(25 - (end - buffer)));
  581|  7.71k|    return true;
  582|  7.71k|}
_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE8WriteIntEi:
  520|  1.68M|inline bool Writer<StringBuffer>::WriteInt(int i) {
  521|  1.68M|    char *buffer = os_->Push(11);
  522|  1.68M|    const char* end = internal::i32toa(i, buffer);
  523|  1.68M|    os_->Pop(static_cast<size_t>(11 - (end - buffer)));
  524|  1.68M|    return true;
  525|  1.68M|}
_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE9WriteUintEj:
  528|      6|inline bool Writer<StringBuffer>::WriteUint(unsigned u) {
  529|      6|    char *buffer = os_->Push(10);
  530|      6|    const char* end = internal::u32toa(u, buffer);
  531|      6|    os_->Pop(static_cast<size_t>(10 - (end - buffer)));
  532|      6|    return true;
  533|      6|}
_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE10WriteInt64El:
  536|  5.90k|inline bool Writer<StringBuffer>::WriteInt64(int64_t i64) {
  537|  5.90k|    char *buffer = os_->Push(21);
  538|  5.90k|    const char* end = internal::i64toa(i64, buffer);
  539|  5.90k|    os_->Pop(static_cast<size_t>(21 - (end - buffer)));
  540|  5.90k|    return true;
  541|  5.90k|}
_ZN9rapidjson6WriterINS_19GenericStringBufferINS_4UTF8IcEENS_12CrtAllocatorEEES3_S3_S4_Lj0EE11WriteUint64Em:
  544|     74|inline bool Writer<StringBuffer>::WriteUint64(uint64_t u) {
  545|     74|    char *buffer = os_->Push(20);
  546|     74|    const char* end = internal::u64toa(u, buffer);
  547|     74|    os_->Pop(static_cast<size_t>(20 - (end - buffer)));
  548|     74|    return true;
  549|     74|}