_ZN11flatbuffers12EndianScalarIjEET_S1_:
  416|  78.3M|template<typename T> T EndianScalar(T t) {
  417|  78.3M|  #if FLATBUFFERS_LITTLEENDIAN
  418|  78.3M|    return t;
  419|       |  #else
  420|       |    return EndianSwap(t);
  421|       |  #endif
  422|  78.3M|}
_ZN11flatbuffers10ReadScalarIjEET_PKv:
  427|  58.2M|T ReadScalar(const void *p) {
  428|  58.2M|  return EndianScalar(*reinterpret_cast<const T *>(p));
  429|  58.2M|}
_ZN11flatbuffers10ReadScalarIiEET_PKv:
  427|  61.3M|T ReadScalar(const void *p) {
  428|  61.3M|  return EndianScalar(*reinterpret_cast<const T *>(p));
  429|  61.3M|}
_ZN11flatbuffers12EndianScalarIiEET_S1_:
  416|  61.3M|template<typename T> T EndianScalar(T t) {
  417|  61.3M|  #if FLATBUFFERS_LITTLEENDIAN
  418|  61.3M|    return t;
  419|       |  #else
  420|       |    return EndianSwap(t);
  421|       |  #endif
  422|  61.3M|}
_ZN11flatbuffers10ReadScalarItEET_PKv:
  427|   110M|T ReadScalar(const void *p) {
  428|   110M|  return EndianScalar(*reinterpret_cast<const T *>(p));
  429|   110M|}
_ZN11flatbuffers12EndianScalarItEET_S1_:
  416|   110M|template<typename T> T EndianScalar(T t) {
  417|   110M|  #if FLATBUFFERS_LITTLEENDIAN
  418|   110M|    return t;
  419|       |  #else
  420|       |    return EndianSwap(t);
  421|       |  #endif
  422|   110M|}
_ZN11flatbuffers10ReadScalarIhEET_PKv:
  427|  4.46M|T ReadScalar(const void *p) {
  428|  4.46M|  return EndianScalar(*reinterpret_cast<const T *>(p));
  429|  4.46M|}
_ZN11flatbuffers12EndianScalarIhEET_S1_:
  416|  4.46M|template<typename T> T EndianScalar(T t) {
  417|  4.46M|  #if FLATBUFFERS_LITTLEENDIAN
  418|  4.46M|    return t;
  419|       |  #else
  420|       |    return EndianSwap(t);
  421|       |  #endif
  422|  4.46M|}
_ZN11flatbuffers10IsOutRangeIN10reflection8BaseTypeEEEbRKT_S5_S5_:
  492|   527k|inline bool IsOutRange(const T &v, const T &low, const T &high) {
  493|   527k|  return (v < low) || (high < v);
  ------------------
  |  Branch (493:10): [True: 0, False: 527k]
  |  Branch (493:23): [True: 0, False: 527k]
  ------------------
  494|   527k|}
_ZN11flatbuffers10ReadScalarIaEET_PKv:
  427|  6.52M|T ReadScalar(const void *p) {
  428|  6.52M|  return EndianScalar(*reinterpret_cast<const T *>(p));
  429|  6.52M|}
_ZN11flatbuffers12EndianScalarIaEET_S1_:
  416|  6.52M|template<typename T> T EndianScalar(T t) {
  417|  6.52M|  #if FLATBUFFERS_LITTLEENDIAN
  418|  6.52M|    return t;
  419|       |  #else
  420|       |    return EndianSwap(t);
  421|       |  #endif
  422|  6.52M|}
_ZN11flatbuffers10ReadScalarIlEET_PKv:
  427|  3.80k|T ReadScalar(const void *p) {
  428|  3.80k|  return EndianScalar(*reinterpret_cast<const T *>(p));
  429|  3.80k|}
_ZN11flatbuffers12EndianScalarIlEET_S1_:
  416|  3.80k|template<typename T> T EndianScalar(T t) {
  417|  3.80k|  #if FLATBUFFERS_LITTLEENDIAN
  418|  3.80k|    return t;
  419|       |  #else
  420|       |    return EndianSwap(t);
  421|       |  #endif
  422|  3.80k|}
_ZN11flatbuffers10ReadScalarIdEET_PKv:
  427|  74.1k|T ReadScalar(const void *p) {
  428|  74.1k|  return EndianScalar(*reinterpret_cast<const T *>(p));
  429|  74.1k|}
_ZN11flatbuffers12EndianScalarIdEET_S1_:
  416|  74.1k|template<typename T> T EndianScalar(T t) {
  417|  74.1k|  #if FLATBUFFERS_LITTLEENDIAN
  418|  74.1k|    return t;
  419|       |  #else
  420|       |    return EndianSwap(t);
  421|       |  #endif
  422|  74.1k|}

_ZN11flatbuffers7GetRootIN10reflection6SchemaEEEPKT_PKv:
  214|  3.32k|const T* GetRoot(const void* buf) {
  215|  3.32k|  return GetMutableRoot<T>(const_cast<void*>(buf));
  216|  3.32k|}
_ZN11flatbuffers14GetMutableRootIN10reflection6SchemaEEEPT_Pv:
  201|  3.32k|T* GetMutableRoot(void* buf) {
  202|  3.32k|  if (!buf) return nullptr;
  ------------------
  |  Branch (202:7): [True: 0, False: 3.32k]
  ------------------
  203|  3.32k|  EndianCheck();
  204|  3.32k|  return reinterpret_cast<T*>(reinterpret_cast<uint8_t*>(buf) +
  205|  3.32k|                              EndianScalar(*reinterpret_cast<uoffset_t*>(buf)));
  206|  3.32k|}
_ZN11flatbuffers11EndianCheckEv:
   68|  3.32k|inline void EndianCheck() {
   69|  3.32k|  int endiantest = 1;
   70|       |  // If this fails, see FLATBUFFERS_LITTLEENDIAN above.
   71|  3.32k|  FLATBUFFERS_ASSERT(*reinterpret_cast<char*>(&endiantest) ==
   72|  3.32k|                     FLATBUFFERS_LITTLEENDIAN);
   73|  3.32k|  (void)endiantest;
   74|  3.32k|}
_ZN11flatbuffers19BufferHasIdentifierEPKvPKcb:
  193|  3.32k|                                bool size_prefixed = false) {
  194|  3.32k|  return strncmp(GetBufferIdentifier(buf, size_prefixed), identifier,
  195|  3.32k|                 flatbuffers::kFileIdentifierLength) == 0;
  196|  3.32k|}
_ZN11flatbuffers19GetBufferIdentifierEPKvb:
  186|  3.32k|                                       bool size_prefixed = false) {
  187|  3.32k|  return reinterpret_cast<const char*>(buf) +
  188|  3.32k|         ((size_prefixed) ? 2 * sizeof(uoffset_t) : sizeof(uoffset_t));
  ------------------
  |  Branch (188:11): [True: 0, False: 3.32k]
  ------------------
  189|  3.32k|}
_ZN11flatbuffers14IndirectHelperINS_6OffsetIN10reflection6ObjectEEEvE4ReadEPKhj:
  130|   133k|  static return_type Read(const uint8_t* const p, const offset_type i) {
  131|       |    // Offsets are relative to themselves, so first update the pointer to
  132|       |    // point to the offset location.
  133|   133k|    const uint8_t* const offset_location = p + i * element_stride;
  134|       |
  135|       |    // Then read the scalar value of the offset (which may be 32 or 64-bits) and
  136|       |    // then determine the relative location from the offset location.
  137|   133k|    return reinterpret_cast<return_type>(
  138|   133k|        offset_location + ReadScalar<offset_type>(offset_location));
  139|   133k|  }
_ZN11flatbuffers14IndirectHelperINS_6OffsetIN10reflection5FieldEEEvE4ReadEPKhj:
  130|  1.68M|  static return_type Read(const uint8_t* const p, const offset_type i) {
  131|       |    // Offsets are relative to themselves, so first update the pointer to
  132|       |    // point to the offset location.
  133|  1.68M|    const uint8_t* const offset_location = p + i * element_stride;
  134|       |
  135|       |    // Then read the scalar value of the offset (which may be 32 or 64-bits) and
  136|       |    // then determine the relative location from the offset location.
  137|  1.68M|    return reinterpret_cast<return_type>(
  138|  1.68M|        offset_location + ReadScalar<offset_type>(offset_location));
  139|  1.68M|  }
_ZN11flatbuffers14IndirectHelperINS_6OffsetIN10reflection4EnumEEEvE4ReadEPKhj:
  130|  4.54M|  static return_type Read(const uint8_t* const p, const offset_type i) {
  131|       |    // Offsets are relative to themselves, so first update the pointer to
  132|       |    // point to the offset location.
  133|  4.54M|    const uint8_t* const offset_location = p + i * element_stride;
  134|       |
  135|       |    // Then read the scalar value of the offset (which may be 32 or 64-bits) and
  136|       |    // then determine the relative location from the offset location.
  137|  4.54M|    return reinterpret_cast<return_type>(
  138|  4.54M|        offset_location + ReadScalar<offset_type>(offset_location));
  139|  4.54M|  }
_ZN11flatbuffers14IndirectHelperINS_6OffsetIN10reflection7EnumValEEEvE4ReadEPKhj:
  130|   259k|  static return_type Read(const uint8_t* const p, const offset_type i) {
  131|       |    // Offsets are relative to themselves, so first update the pointer to
  132|       |    // point to the offset location.
  133|   259k|    const uint8_t* const offset_location = p + i * element_stride;
  134|       |
  135|       |    // Then read the scalar value of the offset (which may be 32 or 64-bits) and
  136|       |    // then determine the relative location from the offset location.
  137|   259k|    return reinterpret_cast<return_type>(
  138|   259k|        offset_location + ReadScalar<offset_type>(offset_location));
  139|   259k|  }

_ZN11flatbuffers8IsScalarEN10reflection8BaseTypeE:
   33|   630k|constexpr bool IsScalar(reflection::BaseType t) {
   34|   630k|  return t >= reflection::UType && t <= reflection::Double;
  ------------------
  |  Branch (34:10): [True: 630k, False: 0]
  |  Branch (34:36): [True: 504k, False: 126k]
  ------------------
   35|   630k|}
_ZN11flatbuffers7IsFloatEN10reflection8BaseTypeE:
   39|  82.9k|constexpr bool IsFloat(reflection::BaseType t) {
   40|  82.9k|  return t == reflection::Float || t == reflection::Double;
  ------------------
  |  Branch (40:10): [True: 50.4k, False: 32.5k]
  |  Branch (40:36): [True: 23.7k, False: 8.77k]
  ------------------
   41|  82.9k|}
_ZN11flatbuffers11GetTypeSizeEN10reflection8BaseTypeE:
   77|   422k|constexpr size_t GetTypeSize(reflection::BaseType base_type) {
   78|   422k|  return kBaseTypeSize[base_type];
   79|   422k|}

_ZN10reflection9GetSchemaEPKv:
 1489|  3.32k|inline const reflection::Schema *GetSchema(const void *buf) {
 1490|  3.32k|  return ::flatbuffers::GetRoot<reflection::Schema>(buf);
 1491|  3.32k|}
_ZN10reflection18VerifySchemaBufferILb0EEEbRN11flatbuffers16VerifierTemplateIXT_EEE:
 1513|  3.32k|    ::flatbuffers::VerifierTemplate<B> &verifier) {
 1514|  3.32k|  return verifier.template VerifyBuffer<reflection::Schema>(SchemaIdentifier());
 1515|  3.32k|}
_ZNK10reflection6Schema6VerifyILb0EEEbRN11flatbuffers16VerifierTemplateIXT_EEE:
 1373|  3.32k|  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
 1374|  3.32k|    return VerifyTableStart(verifier) &&
  ------------------
  |  Branch (1374:12): [True: 3.32k, False: 0]
  ------------------
 1375|  3.32k|           VerifyOffsetRequired(verifier, VT_OBJECTS) &&
  ------------------
  |  Branch (1375:12): [True: 3.32k, False: 0]
  ------------------
 1376|  3.32k|           verifier.VerifyVector(objects()) &&
  ------------------
  |  Branch (1376:12): [True: 3.32k, False: 0]
  ------------------
 1377|  3.32k|           verifier.VerifyVectorOfTables(objects()) &&
  ------------------
  |  Branch (1377:12): [True: 3.32k, False: 0]
  ------------------
 1378|  3.32k|           VerifyOffsetRequired(verifier, VT_ENUMS) &&
  ------------------
  |  Branch (1378:12): [True: 3.32k, False: 0]
  ------------------
 1379|  3.32k|           verifier.VerifyVector(enums()) &&
  ------------------
  |  Branch (1379:12): [True: 3.32k, False: 0]
  ------------------
 1380|  3.32k|           verifier.VerifyVectorOfTables(enums()) &&
  ------------------
  |  Branch (1380:12): [True: 3.32k, False: 0]
  ------------------
 1381|  3.32k|           VerifyOffset(verifier, VT_FILE_IDENT) &&
  ------------------
  |  Branch (1381:12): [True: 3.32k, False: 0]
  ------------------
 1382|  3.32k|           verifier.VerifyString(file_ident()) &&
  ------------------
  |  Branch (1382:12): [True: 3.32k, False: 0]
  ------------------
 1383|  3.32k|           VerifyOffset(verifier, VT_FILE_EXT) &&
  ------------------
  |  Branch (1383:12): [True: 3.32k, False: 0]
  ------------------
 1384|  3.32k|           verifier.VerifyString(file_ext()) &&
  ------------------
  |  Branch (1384:12): [True: 3.32k, False: 0]
  ------------------
 1385|  3.32k|           VerifyOffset(verifier, VT_ROOT_TABLE) &&
  ------------------
  |  Branch (1385:12): [True: 3.32k, False: 0]
  ------------------
 1386|  3.32k|           verifier.VerifyTable(root_table()) &&
  ------------------
  |  Branch (1386:12): [True: 3.32k, False: 0]
  ------------------
 1387|  3.32k|           VerifyOffset(verifier, VT_SERVICES) &&
  ------------------
  |  Branch (1387:12): [True: 3.32k, False: 0]
  ------------------
 1388|  3.32k|           verifier.VerifyVector(services()) &&
  ------------------
  |  Branch (1388:12): [True: 3.32k, False: 0]
  ------------------
 1389|  3.32k|           verifier.VerifyVectorOfTables(services()) &&
  ------------------
  |  Branch (1389:12): [True: 3.32k, False: 0]
  ------------------
 1390|  3.32k|           VerifyField<uint64_t>(verifier, VT_ADVANCED_FEATURES, 8) &&
  ------------------
  |  Branch (1390:12): [True: 3.32k, False: 0]
  ------------------
 1391|  3.32k|           VerifyOffset(verifier, VT_FBS_FILES) &&
  ------------------
  |  Branch (1391:12): [True: 3.32k, False: 0]
  ------------------
 1392|  3.32k|           verifier.VerifyVector(fbs_files()) &&
  ------------------
  |  Branch (1392:12): [True: 3.32k, False: 0]
  ------------------
 1393|  3.32k|           verifier.VerifyVectorOfTables(fbs_files()) &&
  ------------------
  |  Branch (1393:12): [True: 3.32k, False: 0]
  ------------------
 1394|  3.32k|           verifier.EndTable();
  ------------------
  |  Branch (1394:12): [True: 3.32k, False: 0]
  ------------------
 1395|  3.32k|  }
_ZNK10reflection6Schema7objectsEv:
 1346|   116k|  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>> *objects() const {
 1347|   116k|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>> *>(VT_OBJECTS);
 1348|   116k|  }
_ZNK10reflection6Object6VerifyILb0EEEbRN11flatbuffers16VerifierTemplateIXT_EEE:
  889|  26.6k|  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
  890|  26.6k|    return VerifyTableStart(verifier) &&
  ------------------
  |  Branch (890:12): [True: 26.6k, False: 0]
  ------------------
  891|  26.6k|           VerifyOffsetRequired(verifier, VT_NAME) &&
  ------------------
  |  Branch (891:12): [True: 26.6k, False: 0]
  ------------------
  892|  26.6k|           verifier.VerifyString(name()) &&
  ------------------
  |  Branch (892:12): [True: 26.6k, False: 0]
  ------------------
  893|  26.6k|           VerifyOffsetRequired(verifier, VT_FIELDS) &&
  ------------------
  |  Branch (893:12): [True: 26.6k, False: 0]
  ------------------
  894|  26.6k|           verifier.VerifyVector(fields()) &&
  ------------------
  |  Branch (894:12): [True: 26.6k, False: 0]
  ------------------
  895|  26.6k|           verifier.VerifyVectorOfTables(fields()) &&
  ------------------
  |  Branch (895:12): [True: 26.6k, False: 0]
  ------------------
  896|  26.6k|           VerifyField<uint8_t>(verifier, VT_IS_STRUCT, 1) &&
  ------------------
  |  Branch (896:12): [True: 26.6k, False: 0]
  ------------------
  897|  26.6k|           VerifyField<int32_t>(verifier, VT_MINALIGN, 4) &&
  ------------------
  |  Branch (897:12): [True: 26.6k, False: 0]
  ------------------
  898|  26.6k|           VerifyField<int32_t>(verifier, VT_BYTESIZE, 4) &&
  ------------------
  |  Branch (898:12): [True: 26.6k, False: 0]
  ------------------
  899|  26.6k|           VerifyOffset(verifier, VT_ATTRIBUTES) &&
  ------------------
  |  Branch (899:12): [True: 26.6k, False: 0]
  ------------------
  900|  26.6k|           verifier.VerifyVector(attributes()) &&
  ------------------
  |  Branch (900:12): [True: 26.6k, False: 0]
  ------------------
  901|  26.6k|           verifier.VerifyVectorOfTables(attributes()) &&
  ------------------
  |  Branch (901:12): [True: 26.6k, False: 0]
  ------------------
  902|  26.6k|           VerifyOffset(verifier, VT_DOCUMENTATION) &&
  ------------------
  |  Branch (902:12): [True: 26.6k, False: 0]
  ------------------
  903|  26.6k|           verifier.VerifyVector(documentation()) &&
  ------------------
  |  Branch (903:12): [True: 26.6k, False: 0]
  ------------------
  904|  26.6k|           verifier.VerifyVectorOfStrings(documentation()) &&
  ------------------
  |  Branch (904:12): [True: 26.6k, False: 0]
  ------------------
  905|  26.6k|           VerifyOffset(verifier, VT_DECLARATION_FILE) &&
  ------------------
  |  Branch (905:12): [True: 26.6k, False: 0]
  ------------------
  906|  26.6k|           verifier.VerifyString(declaration_file()) &&
  ------------------
  |  Branch (906:12): [True: 26.6k, False: 0]
  ------------------
  907|  26.6k|           verifier.EndTable();
  ------------------
  |  Branch (907:12): [True: 26.6k, False: 0]
  ------------------
  908|  26.6k|  }
_ZNK10reflection6Object4nameEv:
  851|  3.22M|  const ::flatbuffers::String *name() const {
  852|  3.22M|    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  853|  3.22M|  }
_ZNK10reflection6Object6fieldsEv:
  866|  2.78M|  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>> *fields() const {
  867|  2.78M|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>> *>(VT_FIELDS);
  868|  2.78M|  }
_ZNK10reflection5Field6VerifyILb0EEEbRN11flatbuffers16VerifierTemplateIXT_EEE:
  683|   222k|  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
  684|   222k|    return VerifyTableStart(verifier) &&
  ------------------
  |  Branch (684:12): [True: 222k, False: 0]
  ------------------
  685|   222k|           VerifyOffsetRequired(verifier, VT_NAME) &&
  ------------------
  |  Branch (685:12): [True: 222k, False: 0]
  ------------------
  686|   222k|           verifier.VerifyString(name()) &&
  ------------------
  |  Branch (686:12): [True: 222k, False: 0]
  ------------------
  687|   222k|           VerifyOffsetRequired(verifier, VT_TYPE) &&
  ------------------
  |  Branch (687:12): [True: 222k, False: 0]
  ------------------
  688|   222k|           verifier.VerifyTable(type()) &&
  ------------------
  |  Branch (688:12): [True: 222k, False: 0]
  ------------------
  689|   222k|           VerifyField<uint16_t>(verifier, VT_ID, 2) &&
  ------------------
  |  Branch (689:12): [True: 222k, False: 0]
  ------------------
  690|   222k|           VerifyField<uint16_t>(verifier, VT_OFFSET, 2) &&
  ------------------
  |  Branch (690:12): [True: 222k, False: 0]
  ------------------
  691|   222k|           VerifyField<int64_t>(verifier, VT_DEFAULT_INTEGER, 8) &&
  ------------------
  |  Branch (691:12): [True: 222k, False: 0]
  ------------------
  692|   222k|           VerifyField<double>(verifier, VT_DEFAULT_REAL, 8) &&
  ------------------
  |  Branch (692:12): [True: 222k, False: 0]
  ------------------
  693|   222k|           VerifyField<uint8_t>(verifier, VT_DEPRECATED, 1) &&
  ------------------
  |  Branch (693:12): [True: 222k, False: 0]
  ------------------
  694|   222k|           VerifyField<uint8_t>(verifier, VT_REQUIRED, 1) &&
  ------------------
  |  Branch (694:12): [True: 222k, False: 0]
  ------------------
  695|   222k|           VerifyField<uint8_t>(verifier, VT_KEY, 1) &&
  ------------------
  |  Branch (695:12): [True: 222k, False: 0]
  ------------------
  696|   222k|           VerifyOffset(verifier, VT_ATTRIBUTES) &&
  ------------------
  |  Branch (696:12): [True: 222k, False: 0]
  ------------------
  697|   222k|           verifier.VerifyVector(attributes()) &&
  ------------------
  |  Branch (697:12): [True: 222k, False: 0]
  ------------------
  698|   222k|           verifier.VerifyVectorOfTables(attributes()) &&
  ------------------
  |  Branch (698:12): [True: 222k, False: 0]
  ------------------
  699|   222k|           VerifyOffset(verifier, VT_DOCUMENTATION) &&
  ------------------
  |  Branch (699:12): [True: 222k, False: 0]
  ------------------
  700|   222k|           verifier.VerifyVector(documentation()) &&
  ------------------
  |  Branch (700:12): [True: 222k, False: 0]
  ------------------
  701|   222k|           verifier.VerifyVectorOfStrings(documentation()) &&
  ------------------
  |  Branch (701:12): [True: 222k, False: 0]
  ------------------
  702|   222k|           VerifyField<uint8_t>(verifier, VT_OPTIONAL, 1) &&
  ------------------
  |  Branch (702:12): [True: 222k, False: 0]
  ------------------
  703|   222k|           VerifyField<uint16_t>(verifier, VT_PADDING, 2) &&
  ------------------
  |  Branch (703:12): [True: 222k, False: 0]
  ------------------
  704|   222k|           VerifyField<uint8_t>(verifier, VT_OFFSET64, 1) &&
  ------------------
  |  Branch (704:12): [True: 222k, False: 0]
  ------------------
  705|   222k|           verifier.EndTable();
  ------------------
  |  Branch (705:12): [True: 222k, False: 0]
  ------------------
  706|   222k|  }
_ZNK10reflection5Field4nameEv:
  626|  1.38M|  const ::flatbuffers::String *name() const {
  627|  1.38M|    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  628|  1.38M|  }
_ZNK10reflection4Type6VerifyILb0EEEbRN11flatbuffers16VerifierTemplateIXT_EEE:
  200|   279k|  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
  201|   279k|    return VerifyTableStart(verifier) &&
  ------------------
  |  Branch (201:12): [True: 279k, False: 0]
  ------------------
  202|   279k|           VerifyField<int8_t>(verifier, VT_BASE_TYPE, 1) &&
  ------------------
  |  Branch (202:12): [True: 279k, False: 0]
  ------------------
  203|   279k|           VerifyField<int8_t>(verifier, VT_ELEMENT, 1) &&
  ------------------
  |  Branch (203:12): [True: 279k, False: 0]
  ------------------
  204|   279k|           VerifyField<int32_t>(verifier, VT_INDEX, 4) &&
  ------------------
  |  Branch (204:12): [True: 279k, False: 0]
  ------------------
  205|   279k|           VerifyField<uint16_t>(verifier, VT_FIXED_LENGTH, 2) &&
  ------------------
  |  Branch (205:12): [True: 279k, False: 0]
  ------------------
  206|   279k|           VerifyField<uint32_t>(verifier, VT_BASE_SIZE, 4) &&
  ------------------
  |  Branch (206:12): [True: 279k, False: 0]
  ------------------
  207|   279k|           VerifyField<uint32_t>(verifier, VT_ELEMENT_SIZE, 4) &&
  ------------------
  |  Branch (207:12): [True: 279k, False: 0]
  ------------------
  208|   279k|           verifier.EndTable();
  ------------------
  |  Branch (208:12): [True: 279k, False: 0]
  ------------------
  209|   279k|  }
_ZNK10reflection5Field4typeEv:
  641|  11.4M|  const reflection::Type *type() const {
  642|  11.4M|    return GetPointer<const reflection::Type *>(VT_TYPE);
  643|  11.4M|  }
_ZNK10reflection5Field10attributesEv:
  665|   445k|  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
  666|   445k|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
  667|   445k|  }
_ZNK10reflection5Field13documentationEv:
  668|   445k|  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
  669|   445k|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
  670|   445k|  }
_ZNK10reflection6Object10attributesEv:
  878|  53.2k|  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
  879|  53.2k|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
  880|  53.2k|  }
_ZNK10reflection6Object13documentationEv:
  881|  53.2k|  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
  882|  53.2k|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
  883|  53.2k|  }
_ZNK10reflection6Object16declaration_fileEv:
  885|  26.6k|  const ::flatbuffers::String *declaration_file() const {
  886|  26.6k|    return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
  887|  26.6k|  }
_ZNK10reflection6Schema5enumsEv:
 1349|  8.85M|  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>> *enums() const {
 1350|  8.85M|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>> *>(VT_ENUMS);
 1351|  8.85M|  }
_ZNK10reflection4Enum6VerifyILb0EEEbRN11flatbuffers16VerifierTemplateIXT_EEE:
  502|  13.3k|  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
  503|  13.3k|    return VerifyTableStart(verifier) &&
  ------------------
  |  Branch (503:12): [True: 13.3k, False: 0]
  ------------------
  504|  13.3k|           VerifyOffsetRequired(verifier, VT_NAME) &&
  ------------------
  |  Branch (504:12): [True: 13.3k, False: 0]
  ------------------
  505|  13.3k|           verifier.VerifyString(name()) &&
  ------------------
  |  Branch (505:12): [True: 13.3k, False: 0]
  ------------------
  506|  13.3k|           VerifyOffsetRequired(verifier, VT_VALUES) &&
  ------------------
  |  Branch (506:12): [True: 13.3k, False: 0]
  ------------------
  507|  13.3k|           verifier.VerifyVector(values()) &&
  ------------------
  |  Branch (507:12): [True: 13.3k, False: 0]
  ------------------
  508|  13.3k|           verifier.VerifyVectorOfTables(values()) &&
  ------------------
  |  Branch (508:12): [True: 13.3k, False: 0]
  ------------------
  509|  13.3k|           VerifyField<uint8_t>(verifier, VT_IS_UNION, 1) &&
  ------------------
  |  Branch (509:12): [True: 13.3k, False: 0]
  ------------------
  510|  13.3k|           VerifyOffsetRequired(verifier, VT_UNDERLYING_TYPE) &&
  ------------------
  |  Branch (510:12): [True: 13.3k, False: 0]
  ------------------
  511|  13.3k|           verifier.VerifyTable(underlying_type()) &&
  ------------------
  |  Branch (511:12): [True: 13.3k, False: 0]
  ------------------
  512|  13.3k|           VerifyOffset(verifier, VT_ATTRIBUTES) &&
  ------------------
  |  Branch (512:12): [True: 13.3k, False: 0]
  ------------------
  513|  13.3k|           verifier.VerifyVector(attributes()) &&
  ------------------
  |  Branch (513:12): [True: 13.3k, False: 0]
  ------------------
  514|  13.3k|           verifier.VerifyVectorOfTables(attributes()) &&
  ------------------
  |  Branch (514:12): [True: 13.3k, False: 0]
  ------------------
  515|  13.3k|           VerifyOffset(verifier, VT_DOCUMENTATION) &&
  ------------------
  |  Branch (515:12): [True: 13.3k, False: 0]
  ------------------
  516|  13.3k|           verifier.VerifyVector(documentation()) &&
  ------------------
  |  Branch (516:12): [True: 13.3k, False: 0]
  ------------------
  517|  13.3k|           verifier.VerifyVectorOfStrings(documentation()) &&
  ------------------
  |  Branch (517:12): [True: 13.3k, False: 0]
  ------------------
  518|  13.3k|           VerifyOffset(verifier, VT_DECLARATION_FILE) &&
  ------------------
  |  Branch (518:12): [True: 13.3k, False: 0]
  ------------------
  519|  13.3k|           verifier.VerifyString(declaration_file()) &&
  ------------------
  |  Branch (519:12): [True: 13.3k, False: 0]
  ------------------
  520|  13.3k|           verifier.EndTable();
  ------------------
  |  Branch (520:12): [True: 13.3k, False: 0]
  ------------------
  521|  13.3k|  }
_ZNK10reflection4Enum4nameEv:
  467|  13.3k|  const ::flatbuffers::String *name() const {
  468|  13.3k|    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  469|  13.3k|  }
_ZNK10reflection4Enum6valuesEv:
  482|  4.55M|  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>> *values() const {
  483|  4.55M|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>> *>(VT_VALUES);
  484|  4.55M|  }
_ZNK10reflection7EnumVal6VerifyILb0EEEbRN11flatbuffers16VerifierTemplateIXT_EEE:
  373|  43.2k|  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
  374|  43.2k|    return VerifyTableStart(verifier) &&
  ------------------
  |  Branch (374:12): [True: 43.2k, False: 0]
  ------------------
  375|  43.2k|           VerifyOffsetRequired(verifier, VT_NAME) &&
  ------------------
  |  Branch (375:12): [True: 43.2k, False: 0]
  ------------------
  376|  43.2k|           verifier.VerifyString(name()) &&
  ------------------
  |  Branch (376:12): [True: 43.2k, False: 0]
  ------------------
  377|  43.2k|           VerifyField<int64_t>(verifier, VT_VALUE, 8) &&
  ------------------
  |  Branch (377:12): [True: 43.2k, False: 0]
  ------------------
  378|  43.2k|           VerifyOffset(verifier, VT_UNION_TYPE) &&
  ------------------
  |  Branch (378:12): [True: 43.2k, False: 0]
  ------------------
  379|  43.2k|           verifier.VerifyTable(union_type()) &&
  ------------------
  |  Branch (379:12): [True: 43.2k, False: 0]
  ------------------
  380|  43.2k|           VerifyOffset(verifier, VT_DOCUMENTATION) &&
  ------------------
  |  Branch (380:12): [True: 43.2k, False: 0]
  ------------------
  381|  43.2k|           verifier.VerifyVector(documentation()) &&
  ------------------
  |  Branch (381:12): [True: 43.2k, False: 0]
  ------------------
  382|  43.2k|           verifier.VerifyVectorOfStrings(documentation()) &&
  ------------------
  |  Branch (382:12): [True: 43.2k, False: 0]
  ------------------
  383|  43.2k|           VerifyOffset(verifier, VT_ATTRIBUTES) &&
  ------------------
  |  Branch (383:12): [True: 43.2k, False: 0]
  ------------------
  384|  43.2k|           verifier.VerifyVector(attributes()) &&
  ------------------
  |  Branch (384:12): [True: 43.2k, False: 0]
  ------------------
  385|  43.2k|           verifier.VerifyVectorOfTables(attributes()) &&
  ------------------
  |  Branch (385:12): [True: 43.2k, False: 0]
  ------------------
  386|  43.2k|           verifier.EndTable();
  ------------------
  |  Branch (386:12): [True: 43.2k, False: 0]
  ------------------
  387|  43.2k|  }
_ZNK10reflection7EnumVal4nameEv:
  351|   259k|  const ::flatbuffers::String *name() const {
  352|   259k|    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  353|   259k|  }
_ZNK10reflection7EnumVal10union_typeEv:
  363|   249k|  const reflection::Type *union_type() const {
  364|   249k|    return GetPointer<const reflection::Type *>(VT_UNION_TYPE);
  365|   249k|  }
_ZNK10reflection7EnumVal13documentationEv:
  366|  86.4k|  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
  367|  86.4k|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
  368|  86.4k|  }
_ZNK10reflection7EnumVal10attributesEv:
  369|  86.4k|  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
  370|  86.4k|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
  371|  86.4k|  }
_ZNK10reflection4Enum15underlying_typeEv:
  488|  13.3k|  const reflection::Type *underlying_type() const {
  489|  13.3k|    return GetPointer<const reflection::Type *>(VT_UNDERLYING_TYPE);
  490|  13.3k|  }
_ZNK10reflection4Enum10attributesEv:
  491|  26.6k|  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
  492|  26.6k|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
  493|  26.6k|  }
_ZNK10reflection4Enum13documentationEv:
  494|  26.6k|  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
  495|  26.6k|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
  496|  26.6k|  }
_ZNK10reflection4Enum16declaration_fileEv:
  498|  13.3k|  const ::flatbuffers::String *declaration_file() const {
  499|  13.3k|    return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
  500|  13.3k|  }
_ZNK10reflection6Schema10file_identEv:
 1352|  3.32k|  const ::flatbuffers::String *file_ident() const {
 1353|  3.32k|    return GetPointer<const ::flatbuffers::String *>(VT_FILE_IDENT);
 1354|  3.32k|  }
_ZNK10reflection6Schema8file_extEv:
 1355|  3.32k|  const ::flatbuffers::String *file_ext() const {
 1356|  3.32k|    return GetPointer<const ::flatbuffers::String *>(VT_FILE_EXT);
 1357|  3.32k|  }
_ZNK10reflection6Schema10root_tableEv:
 1358|  9.89k|  const reflection::Object *root_table() const {
 1359|  9.89k|    return GetPointer<const reflection::Object *>(VT_ROOT_TABLE);
 1360|  9.89k|  }
_ZNK10reflection6Schema8servicesEv:
 1361|  6.65k|  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>> *services() const {
 1362|  6.65k|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>> *>(VT_SERVICES);
 1363|  6.65k|  }
_ZNK10reflection6Schema9fbs_filesEv:
 1369|  6.65k|  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>> *fbs_files() const {
 1370|  6.65k|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>> *>(VT_FBS_FILES);
 1371|  6.65k|  }
_ZN10reflection16SchemaIdentifierEv:
 1497|  3.32k|inline const char *SchemaIdentifier() {
 1498|  3.32k|  return "BFBS";
 1499|  3.32k|}
_ZNK10reflection4Type9base_typeEv:
  179|  2.53M|  reflection::BaseType base_type() const {
  180|  2.53M|    return static_cast<reflection::BaseType>(GetField<int8_t>(VT_BASE_TYPE, 0));
  181|  2.53M|  }
_ZNK10reflection4Type7elementEv:
  182|  4.19M|  reflection::BaseType element() const {
  183|  4.19M|    return static_cast<reflection::BaseType>(GetField<int8_t>(VT_ELEMENT, 0));
  184|  4.19M|  }
_ZNK10reflection4Type5indexEv:
  185|  4.64M|  int32_t index() const {
  186|  4.64M|    return GetField<int32_t>(VT_INDEX, -1);
  187|  4.64M|  }
_ZNK10reflection4Type12fixed_lengthEv:
  188|  9.69k|  uint16_t fixed_length() const {
  189|  9.69k|    return GetField<uint16_t>(VT_FIXED_LENGTH, 0);
  190|  9.69k|  }
_ZNK10reflection5Field2idEv:
  644|  1.81M|  uint16_t id() const {
  645|  1.81M|    return GetField<uint16_t>(VT_ID, 0);
  646|  1.81M|  }
_ZNK10reflection5Field15default_integerEv:
  650|  8.77k|  int64_t default_integer() const {
  651|  8.77k|    return GetField<int64_t>(VT_DEFAULT_INTEGER, 0);
  652|  8.77k|  }
_ZNK10reflection5Field12default_realEv:
  653|  74.1k|  double default_real() const {
  654|  74.1k|    return GetField<double>(VT_DEFAULT_REAL, 0.0);
  655|  74.1k|  }
_ZNK10reflection5Field8requiredEv:
  659|   104k|  bool required() const {
  660|   104k|    return GetField<uint8_t>(VT_REQUIRED, 0) != 0;
  661|   104k|  }
_ZNK10reflection5Field7paddingEv:
  675|   293k|  uint16_t padding() const {
  676|   293k|    return GetField<uint16_t>(VT_PADDING, 0);
  677|   293k|  }
_ZNK10reflection5Field8offset64Ev:
  679|  85.2k|  bool offset64() const {
  680|  85.2k|    return GetField<uint8_t>(VT_OFFSET64, 0) != 0;
  681|  85.2k|  }
_ZNK10reflection6Object9is_structEv:
  869|   253k|  bool is_struct() const {
  870|   253k|    return GetField<uint8_t>(VT_IS_STRUCT, 0) != 0;
  871|   253k|  }
_ZNK10reflection6Object8bytesizeEv:
  875|    148|  int32_t bytesize() const {
  876|    148|    return GetField<int32_t>(VT_BYTESIZE, 0);
  877|    148|  }
_ZN10reflection17EnumNamesBaseTypeEv:
   97|   527k|inline const char * const *EnumNamesBaseType() {
   98|   527k|  static const char * const names[21] = {
   99|   527k|    "None",
  100|   527k|    "UType",
  101|   527k|    "Bool",
  102|   527k|    "Byte",
  103|   527k|    "UByte",
  104|   527k|    "Short",
  105|   527k|    "UShort",
  106|   527k|    "Int",
  107|   527k|    "UInt",
  108|   527k|    "Long",
  109|   527k|    "ULong",
  110|   527k|    "Float",
  111|   527k|    "Double",
  112|   527k|    "String",
  113|   527k|    "Vector",
  114|   527k|    "Obj",
  115|   527k|    "Union",
  116|   527k|    "Array",
  117|   527k|    "Vector64",
  118|   527k|    "MaxBaseType",
  119|   527k|    nullptr
  120|   527k|  };
  121|   527k|  return names;
  122|   527k|}
_ZN10reflection16EnumNameBaseTypeENS_8BaseTypeE:
  124|   527k|inline const char *EnumNameBaseType(BaseType e) {
  125|   527k|  if (::flatbuffers::IsOutRange(e, None, MaxBaseType)) return "";
  ------------------
  |  Branch (125:7): [True: 0, False: 527k]
  ------------------
  126|   527k|  const size_t index = static_cast<size_t>(e);
  127|   527k|  return EnumNamesBaseType()[index];
  128|   527k|}

_ZNK11flatbuffers6String5c_strEv:
   26|  4.57M|  const char* c_str() const { return reinterpret_cast<const char*>(Data()); }
_ZNK11flatbuffers6String3strEv:
   27|  3.27M|  std::string str() const { return std::string(c_str(), size()); }

_ZNK11flatbuffers5Table16VerifyTableStartILb0EEEbRNS_16VerifierTemplateIXT_EEE:
  153|   588k|  bool VerifyTableStart(VerifierTemplate<B>& verifier) const {
  154|   588k|    return verifier.VerifyTableStart(data_);
  155|   588k|  }
_ZNK11flatbuffers5Table20VerifyOffsetRequiredIjLb0EEEbRKNS_16VerifierTemplateIXT0_EEEt:
  189|   588k|                            voffset_t field) const {
  190|   588k|    auto field_offset = GetOptionalFieldOffset(field);
  191|   588k|    return verifier.Check(field_offset != 0) &&
  ------------------
  |  Branch (191:12): [True: 588k, False: 0]
  ------------------
  192|   588k|           verifier.template VerifyOffset<OffsetT>(data_, field_offset);
  ------------------
  |  Branch (192:12): [True: 588k, False: 0]
  ------------------
  193|   588k|  }
_ZNK11flatbuffers5Table22GetOptionalFieldOffsetEt:
   36|  53.5M|  voffset_t GetOptionalFieldOffset(voffset_t field) const {
   37|       |    // The vtable offset is always at the start.
   38|  53.5M|    auto vtable = GetVTable();
   39|       |    // The first element is the size of the vtable (fields + type id + itself).
   40|  53.5M|    auto vtsize = ReadScalar<voffset_t>(vtable);
   41|       |    // If the field we're accessing is outside the vtable, we're reading older
   42|       |    // data, so it's the same as if the offset was 0 (not present).
   43|  53.5M|    return field < vtsize ? ReadScalar<voffset_t>(vtable + field) : 0;
  ------------------
  |  Branch (43:12): [True: 51.0M, False: 2.44M]
  ------------------
   44|  53.5M|  }
_ZNK11flatbuffers5Table9GetVTableEv:
   30|  53.5M|  const uint8_t* GetVTable() const {
   31|  53.5M|    return data_ - ReadScalar<soffset_t>(data_);
   32|  53.5M|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN10reflection6ObjectEEEjEEjEET_t:
   60|   116k|  P GetPointer(voffset_t field) const {
   61|   116k|    return const_cast<Table*>(this)->GetPointer<P, OffsetSize>(field);
   62|   116k|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN10reflection6ObjectEEEjEEjEET_t:
   53|   116k|  P GetPointer(voffset_t field) {
   54|   116k|    auto field_offset = GetOptionalFieldOffset(field);
   55|   116k|    auto p = data_ + field_offset;
   56|   116k|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (56:12): [True: 116k, False: 0]
  ------------------
   57|   116k|                        : nullptr;
   58|   116k|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6StringEjEET_t:
   60|  4.92M|  P GetPointer(voffset_t field) const {
   61|  4.92M|    return const_cast<Table*>(this)->GetPointer<P, OffsetSize>(field);
   62|  4.92M|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6StringEjEET_t:
   53|  4.92M|  P GetPointer(voffset_t field) {
   54|  4.92M|    auto field_offset = GetOptionalFieldOffset(field);
   55|  4.92M|    auto p = data_ + field_offset;
   56|  4.92M|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (56:12): [True: 4.92M, False: 0]
  ------------------
   57|  4.92M|                        : nullptr;
   58|  4.92M|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN10reflection5FieldEEEjEEjEET_t:
   60|  2.78M|  P GetPointer(voffset_t field) const {
   61|  2.78M|    return const_cast<Table*>(this)->GetPointer<P, OffsetSize>(field);
   62|  2.78M|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN10reflection5FieldEEEjEEjEET_t:
   53|  2.78M|  P GetPointer(voffset_t field) {
   54|  2.78M|    auto field_offset = GetOptionalFieldOffset(field);
   55|  2.78M|    auto p = data_ + field_offset;
   56|  2.78M|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (56:12): [True: 2.78M, False: 0]
  ------------------
   57|  2.78M|                        : nullptr;
   58|  2.78M|  }
_ZNK11flatbuffers5Table11VerifyFieldIaLb0EEEbRKNS_16VerifierTemplateIXT0_EEEtm:
  160|   558k|                   size_t align) const {
  161|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  162|       |    // VerifyTable().
  163|   558k|    auto field_offset = GetOptionalFieldOffset(field);
  164|       |    // Check the actual field.
  165|   558k|    return !field_offset ||
  ------------------
  |  Branch (165:12): [True: 256k, False: 302k]
  ------------------
  166|   302k|           verifier.template VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (166:12): [True: 302k, False: 0]
  ------------------
  167|   558k|  }
_ZNK11flatbuffers5Table11VerifyFieldIjLb0EEEbRKNS_16VerifierTemplateIXT0_EEEtm:
  160|   558k|                   size_t align) const {
  161|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  162|       |    // VerifyTable().
  163|   558k|    auto field_offset = GetOptionalFieldOffset(field);
  164|       |    // Check the actual field.
  165|   558k|    return !field_offset ||
  ------------------
  |  Branch (165:12): [True: 186k, False: 372k]
  ------------------
  166|   372k|           verifier.template VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (166:12): [True: 372k, False: 0]
  ------------------
  167|   558k|  }
_ZNK11flatbuffers5Table10GetPointerIPKN10reflection4TypeEjEET_t:
   60|  11.6M|  P GetPointer(voffset_t field) const {
   61|  11.6M|    return const_cast<Table*>(this)->GetPointer<P, OffsetSize>(field);
   62|  11.6M|  }
_ZN11flatbuffers5Table10GetPointerIPKN10reflection4TypeEjEET_t:
   53|  11.6M|  P GetPointer(voffset_t field) {
   54|  11.6M|    auto field_offset = GetOptionalFieldOffset(field);
   55|  11.6M|    auto p = data_ + field_offset;
   56|  11.6M|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (56:12): [True: 11.6M, False: 0]
  ------------------
   57|  11.6M|                        : nullptr;
   58|  11.6M|  }
_ZNK11flatbuffers5Table11VerifyFieldItLb0EEEbRKNS_16VerifierTemplateIXT0_EEEtm:
  160|   947k|                   size_t align) const {
  161|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  162|       |    // VerifyTable().
  163|   947k|    auto field_offset = GetOptionalFieldOffset(field);
  164|       |    // Check the actual field.
  165|   947k|    return !field_offset ||
  ------------------
  |  Branch (165:12): [True: 532k, False: 415k]
  ------------------
  166|   415k|           verifier.template VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (166:12): [True: 415k, False: 0]
  ------------------
  167|   947k|  }
_ZNK11flatbuffers5Table11VerifyFieldIlLb0EEEbRKNS_16VerifierTemplateIXT0_EEEtm:
  160|   266k|                   size_t align) const {
  161|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  162|       |    // VerifyTable().
  163|   266k|    auto field_offset = GetOptionalFieldOffset(field);
  164|       |    // Check the actual field.
  165|   266k|    return !field_offset ||
  ------------------
  |  Branch (165:12): [True: 212k, False: 53.2k]
  ------------------
  166|  53.2k|           verifier.template VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (166:12): [True: 53.2k, False: 0]
  ------------------
  167|   266k|  }
_ZNK11flatbuffers5Table11VerifyFieldIdLb0EEEbRKNS_16VerifierTemplateIXT0_EEEtm:
  160|   222k|                   size_t align) const {
  161|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  162|       |    // VerifyTable().
  163|   222k|    auto field_offset = GetOptionalFieldOffset(field);
  164|       |    // Check the actual field.
  165|   222k|    return !field_offset ||
  ------------------
  |  Branch (165:12): [True: 209k, False: 13.3k]
  ------------------
  166|  13.3k|           verifier.template VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (166:12): [True: 13.3k, False: 0]
  ------------------
  167|   222k|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN10reflection8KeyValueEEEjEEjEET_t:
   60|   611k|  P GetPointer(voffset_t field) const {
   61|   611k|    return const_cast<Table*>(this)->GetPointer<P, OffsetSize>(field);
   62|   611k|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN10reflection8KeyValueEEEjEEjEET_t:
   53|   611k|  P GetPointer(voffset_t field) {
   54|   611k|    auto field_offset = GetOptionalFieldOffset(field);
   55|   611k|    auto p = data_ + field_offset;
   56|   611k|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (56:12): [True: 0, False: 611k]
  ------------------
   57|   611k|                        : nullptr;
   58|   611k|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetINS_6StringEEEjEEjEET_t:
   60|   611k|  P GetPointer(voffset_t field) const {
   61|   611k|    return const_cast<Table*>(this)->GetPointer<P, OffsetSize>(field);
   62|   611k|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetINS_6StringEEEjEEjEET_t:
   53|   611k|  P GetPointer(voffset_t field) {
   54|   611k|    auto field_offset = GetOptionalFieldOffset(field);
   55|   611k|    auto p = data_ + field_offset;
   56|   611k|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (56:12): [True: 0, False: 611k]
  ------------------
   57|   611k|                        : nullptr;
   58|   611k|  }
_ZNK11flatbuffers5Table11VerifyFieldIhLb0EEEbRKNS_16VerifierTemplateIXT0_EEEtm:
  160|  1.15M|                   size_t align) const {
  161|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  162|       |    // VerifyTable().
  163|  1.15M|    auto field_offset = GetOptionalFieldOffset(field);
  164|       |    // Check the actual field.
  165|  1.15M|    return !field_offset ||
  ------------------
  |  Branch (165:12): [True: 1.00M, False: 149k]
  ------------------
  166|   149k|           verifier.template VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (166:12): [True: 149k, False: 0]
  ------------------
  167|  1.15M|  }
_ZNK11flatbuffers5Table11VerifyFieldIiLb0EEEbRKNS_16VerifierTemplateIXT0_EEEtm:
  160|   332k|                   size_t align) const {
  161|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  162|       |    // VerifyTable().
  163|   332k|    auto field_offset = GetOptionalFieldOffset(field);
  164|       |    // Check the actual field.
  165|   332k|    return !field_offset ||
  ------------------
  |  Branch (165:12): [True: 152k, False: 179k]
  ------------------
  166|   179k|           verifier.template VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (166:12): [True: 179k, False: 0]
  ------------------
  167|   332k|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN10reflection4EnumEEEjEEjEET_t:
   60|  8.85M|  P GetPointer(voffset_t field) const {
   61|  8.85M|    return const_cast<Table*>(this)->GetPointer<P, OffsetSize>(field);
   62|  8.85M|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN10reflection4EnumEEEjEEjEET_t:
   53|  8.85M|  P GetPointer(voffset_t field) {
   54|  8.85M|    auto field_offset = GetOptionalFieldOffset(field);
   55|  8.85M|    auto p = data_ + field_offset;
   56|  8.85M|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (56:12): [True: 8.85M, False: 0]
  ------------------
   57|  8.85M|                        : nullptr;
   58|  8.85M|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN10reflection7EnumValEEEjEEjEET_t:
   60|  4.55M|  P GetPointer(voffset_t field) const {
   61|  4.55M|    return const_cast<Table*>(this)->GetPointer<P, OffsetSize>(field);
   62|  4.55M|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN10reflection7EnumValEEEjEEjEET_t:
   53|  4.55M|  P GetPointer(voffset_t field) {
   54|  4.55M|    auto field_offset = GetOptionalFieldOffset(field);
   55|  4.55M|    auto p = data_ + field_offset;
   56|  4.55M|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (56:12): [True: 4.55M, False: 0]
  ------------------
   57|  4.55M|                        : nullptr;
   58|  4.55M|  }
_ZNK11flatbuffers5Table12VerifyOffsetIjLb0EEEbRKNS_16VerifierTemplateIXT0_EEEt:
  181|   711k|                    voffset_t field) const {
  182|   711k|    auto field_offset = GetOptionalFieldOffset(field);
  183|   711k|    return !field_offset ||
  ------------------
  |  Branch (183:12): [True: 615k, False: 96.4k]
  ------------------
  184|  96.4k|           verifier.template VerifyOffset<OffsetT>(data_, field_offset);
  ------------------
  |  Branch (184:12): [True: 96.4k, False: 0]
  ------------------
  185|   711k|  }
_ZNK11flatbuffers5Table10GetPointerIPKN10reflection6ObjectEjEET_t:
   60|  9.89k|  P GetPointer(voffset_t field) const {
   61|  9.89k|    return const_cast<Table*>(this)->GetPointer<P, OffsetSize>(field);
   62|  9.89k|  }
_ZN11flatbuffers5Table10GetPointerIPKN10reflection6ObjectEjEET_t:
   53|  9.89k|  P GetPointer(voffset_t field) {
   54|  9.89k|    auto field_offset = GetOptionalFieldOffset(field);
   55|  9.89k|    auto p = data_ + field_offset;
   56|  9.89k|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (56:12): [True: 9.89k, False: 0]
  ------------------
   57|  9.89k|                        : nullptr;
   58|  9.89k|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN10reflection7ServiceEEEjEEjEET_t:
   60|  6.65k|  P GetPointer(voffset_t field) const {
   61|  6.65k|    return const_cast<Table*>(this)->GetPointer<P, OffsetSize>(field);
   62|  6.65k|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN10reflection7ServiceEEEjEEjEET_t:
   53|  6.65k|  P GetPointer(voffset_t field) {
   54|  6.65k|    auto field_offset = GetOptionalFieldOffset(field);
   55|  6.65k|    auto p = data_ + field_offset;
   56|  6.65k|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (56:12): [True: 6.65k, False: 0]
  ------------------
   57|  6.65k|                        : nullptr;
   58|  6.65k|  }
_ZNK11flatbuffers5Table11VerifyFieldImLb0EEEbRKNS_16VerifierTemplateIXT0_EEEtm:
  160|  3.32k|                   size_t align) const {
  161|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  162|       |    // VerifyTable().
  163|  3.32k|    auto field_offset = GetOptionalFieldOffset(field);
  164|       |    // Check the actual field.
  165|  3.32k|    return !field_offset ||
  ------------------
  |  Branch (165:12): [True: 0, False: 3.32k]
  ------------------
  166|  3.32k|           verifier.template VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (166:12): [True: 3.32k, False: 0]
  ------------------
  167|  3.32k|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN10reflection10SchemaFileEEEjEEjEET_t:
   60|  6.65k|  P GetPointer(voffset_t field) const {
   61|  6.65k|    return const_cast<Table*>(this)->GetPointer<P, OffsetSize>(field);
   62|  6.65k|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN10reflection10SchemaFileEEEjEEjEET_t:
   53|  6.65k|  P GetPointer(voffset_t field) {
   54|  6.65k|    auto field_offset = GetOptionalFieldOffset(field);
   55|  6.65k|    auto p = data_ + field_offset;
   56|  6.65k|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (56:12): [True: 0, False: 6.65k]
  ------------------
   57|  6.65k|                        : nullptr;
   58|  6.65k|  }
_ZNK11flatbuffers5Table8GetFieldIaEET_tS2_:
   47|  6.73M|  T GetField(voffset_t field, T defaultval) const {
   48|  6.73M|    auto field_offset = GetOptionalFieldOffset(field);
   49|  6.73M|    return field_offset ? ReadScalar<T>(data_ + field_offset) : defaultval;
  ------------------
  |  Branch (49:12): [True: 6.52M, False: 204k]
  ------------------
   50|  6.73M|  }
_ZNK11flatbuffers5Table8GetFieldIiEET_tS2_:
   47|  4.64M|  T GetField(voffset_t field, T defaultval) const {
   48|  4.64M|    auto field_offset = GetOptionalFieldOffset(field);
   49|  4.64M|    return field_offset ? ReadScalar<T>(data_ + field_offset) : defaultval;
  ------------------
  |  Branch (49:12): [True: 4.64M, False: 0]
  ------------------
   50|  4.64M|  }
_ZNK11flatbuffers5Table8GetFieldItEET_tS2_:
   47|  2.11M|  T GetField(voffset_t field, T defaultval) const {
   48|  2.11M|    auto field_offset = GetOptionalFieldOffset(field);
   49|  2.11M|    return field_offset ? ReadScalar<T>(data_ + field_offset) : defaultval;
  ------------------
  |  Branch (49:12): [True: 1.21M, False: 903k]
  ------------------
   50|  2.11M|  }
_ZNK11flatbuffers5Table8GetFieldIlEET_tS2_:
   47|  8.77k|  T GetField(voffset_t field, T defaultval) const {
   48|  8.77k|    auto field_offset = GetOptionalFieldOffset(field);
   49|  8.77k|    return field_offset ? ReadScalar<T>(data_ + field_offset) : defaultval;
  ------------------
  |  Branch (49:12): [True: 3.80k, False: 4.96k]
  ------------------
   50|  8.77k|  }
_ZNK11flatbuffers5Table8GetFieldIhEET_tS2_:
   47|   442k|  T GetField(voffset_t field, T defaultval) const {
   48|   442k|    auto field_offset = GetOptionalFieldOffset(field);
   49|   442k|    return field_offset ? ReadScalar<T>(data_ + field_offset) : defaultval;
  ------------------
  |  Branch (49:12): [True: 150k, False: 291k]
  ------------------
   50|   442k|  }
_ZNK11flatbuffers5Table8GetFieldIdEET_tS2_:
   47|  74.1k|  T GetField(voffset_t field, T defaultval) const {
   48|  74.1k|    auto field_offset = GetOptionalFieldOffset(field);
   49|  74.1k|    return field_offset ? ReadScalar<T>(data_ + field_offset) : defaultval;
  ------------------
  |  Branch (49:12): [True: 74.1k, False: 0]
  ------------------
   50|  74.1k|  }

_ZN11flatbuffers11NumToStringImEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEET_:
  131|   141k|std::string NumToString(T t) {
  132|       |  // clang-format off
  133|       |
  134|   141k|  #ifndef FLATBUFFERS_PREFER_PRINTF
  135|   141k|    std::stringstream ss;
  136|   141k|    ss << t;
  137|   141k|    return ss.str();
  138|       |  #else // FLATBUFFERS_PREFER_PRINTF
  139|       |    auto v = static_cast<long long>(t);
  140|       |    return NumToStringImplWrapper(v, "%.*lld");
  141|       |  #endif // FLATBUFFERS_PREFER_PRINTF
  142|       |  // clang-format on
  143|   141k|}

_ZNK11flatbuffers6VectorINS_6OffsetIN10reflection6ObjectEEEjE4sizeEv:
  178|   160k|  SizeT size() const { return EndianScalar(length_); }
_ZNK11flatbuffers6VectorINS_6OffsetIN10reflection6ObjectEEEjE3GetEj:
  194|   133k|  return_type Get(SizeT i) const {
  195|   133k|    FLATBUFFERS_ASSERT(i < size());
  196|   133k|    return IndirectHelper<T>::Read(Data(), i);
  197|   133k|  }
_ZNK11flatbuffers6VectorINS_6OffsetIN10reflection6ObjectEEEjE4DataEv:
  274|   133k|  const uint8_t* Data() const {
  275|   133k|    return reinterpret_cast<const uint8_t*>(&length_ + 1);
  276|   133k|  }
_ZNK11flatbuffers6VectorINS_6OffsetIN10reflection5FieldEEEjE4sizeEv:
  178|  3.20M|  SizeT size() const { return EndianScalar(length_); }
_ZNK11flatbuffers6VectorINS_6OffsetIN10reflection5FieldEEEjE3GetEj:
  194|  1.68M|  return_type Get(SizeT i) const {
  195|  1.68M|    FLATBUFFERS_ASSERT(i < size());
  196|  1.68M|    return IndirectHelper<T>::Read(Data(), i);
  197|  1.68M|  }
_ZNK11flatbuffers6VectorINS_6OffsetIN10reflection5FieldEEEjE4DataEv:
  274|  1.68M|  const uint8_t* Data() const {
  275|  1.68M|    return reinterpret_cast<const uint8_t*>(&length_ + 1);
  276|  1.68M|  }
_ZNK11flatbuffers6VectorINS_6OffsetIN10reflection4EnumEEEjE4sizeEv:
  178|  8.87M|  SizeT size() const { return EndianScalar(length_); }
_ZNK11flatbuffers6VectorINS_6OffsetIN10reflection4EnumEEEjE3GetEj:
  194|  4.54M|  return_type Get(SizeT i) const {
  195|  4.54M|    FLATBUFFERS_ASSERT(i < size());
  196|  4.54M|    return IndirectHelper<T>::Read(Data(), i);
  197|  4.54M|  }
_ZNK11flatbuffers6VectorINS_6OffsetIN10reflection4EnumEEEjE4DataEv:
  274|  4.54M|  const uint8_t* Data() const {
  275|  4.54M|    return reinterpret_cast<const uint8_t*>(&length_ + 1);
  276|  4.54M|  }
_ZNK11flatbuffers6VectorINS_6OffsetIN10reflection7EnumValEEEjE4sizeEv:
  178|  4.63M|  SizeT size() const { return EndianScalar(length_); }
_ZNK11flatbuffers6VectorINS_6OffsetIN10reflection7EnumValEEEjE3GetEj:
  194|   259k|  return_type Get(SizeT i) const {
  195|   259k|    FLATBUFFERS_ASSERT(i < size());
  196|   259k|    return IndirectHelper<T>::Read(Data(), i);
  197|   259k|  }
_ZNK11flatbuffers6VectorINS_6OffsetIN10reflection7EnumValEEEjE4DataEv:
  274|   259k|  const uint8_t* Data() const {
  275|   259k|    return reinterpret_cast<const uint8_t*>(&length_ + 1);
  276|   259k|  }
_ZNK11flatbuffers6VectorINS_6OffsetIN10reflection7ServiceEEEjE4sizeEv:
  178|  3.32k|  SizeT size() const { return EndianScalar(length_); }
_ZNK11flatbuffers6VectorIcjE4DataEv:
  274|  4.57M|  const uint8_t* Data() const {
  275|  4.57M|    return reinterpret_cast<const uint8_t*>(&length_ + 1);
  276|  4.57M|  }
_ZNK11flatbuffers6VectorIcjE4sizeEv:
  178|  3.27M|  SizeT size() const { return EndianScalar(length_); }

_ZN11flatbuffers16VerifierTemplateILb0EEC2EPKhmjjb:
   55|  3.32k|      : VerifierTemplate(buf, buf_len, [&] {
   56|  3.32k|          Options opts;
   57|  3.32k|          opts.max_depth = max_depth;
   58|  3.32k|          opts.max_tables = max_tables;
   59|  3.32k|          opts.check_alignment = check_alignment;
   60|  3.32k|          return opts;
   61|  3.32k|        }()) {}
_ZZN11flatbuffers16VerifierTemplateILb0EEC1EPKhmjjbENKUlvE_clEv:
   55|  3.32k|      : VerifierTemplate(buf, buf_len, [&] {
   56|  3.32k|          Options opts;
   57|  3.32k|          opts.max_depth = max_depth;
   58|  3.32k|          opts.max_tables = max_tables;
   59|  3.32k|          opts.check_alignment = check_alignment;
   60|  3.32k|          return opts;
   61|  3.32k|        }()) {}
_ZN11flatbuffers16VerifierTemplateILb0EEC2EPKhmRKNS1_7OptionsE:
   46|  3.32k|      : buf_(buf), size_(buf_len), opts_(opts) {
   47|  3.32k|    FLATBUFFERS_ASSERT(size_ < opts.max_size);
   48|  3.32k|  }
_ZN11flatbuffers16VerifierTemplateILb0EE12VerifyBufferIN10reflection6SchemaEEEbPKc:
  251|  3.32k|  bool VerifyBuffer(const char* const identifier) {
  252|  3.32k|    return VerifyBufferFromStart<T>(identifier, 0);
  253|  3.32k|  }
_ZN11flatbuffers16VerifierTemplateILb0EE21VerifyBufferFromStartIN10reflection6SchemaEEEbPKcm:
  203|  3.32k|  bool VerifyBufferFromStart(const char* const identifier, const size_t start) {
  204|       |    // Buffers have to be of some size to be valid. The reason it is a runtime
  205|       |    // check instead of static_assert, is that nested flatbuffers go through
  206|       |    // this call and their size is determined at runtime.
  207|  3.32k|    if (!Check(size_ >= FLATBUFFERS_MIN_BUFFER_SIZE)) return false;
  ------------------
  |  |  349|  3.32k|#define FLATBUFFERS_MIN_BUFFER_SIZE sizeof(::flatbuffers::uoffset_t) + \
  |  |  350|  3.32k|  sizeof(::flatbuffers::soffset_t) + sizeof(uint16_t) + sizeof(uint16_t)
  ------------------
  |  Branch (207:9): [True: 0, False: 3.32k]
  ------------------
  208|       |
  209|       |    // If an identifier is provided, check that we have a buffer
  210|  3.32k|    if (identifier && !Check((size_ >= 2 * sizeof(flatbuffers::uoffset_t) &&
  ------------------
  |  Branch (210:9): [True: 3.32k, False: 0]
  |  Branch (210:23): [True: 0, False: 3.32k]
  |  Branch (210:31): [True: 3.32k, False: 0]
  ------------------
  211|  3.32k|                              BufferHasIdentifier(buf_ + start, identifier)))) {
  ------------------
  |  Branch (211:31): [True: 3.32k, False: 0]
  ------------------
  212|      0|      return false;
  213|      0|    }
  214|       |
  215|       |    // Call T::Verify, which must be in the generated code for this type.
  216|  3.32k|    const auto o = VerifyOffset<uoffset_t>(start);
  217|  3.32k|    if (!Check(o != 0)) return false;
  ------------------
  |  Branch (217:9): [True: 0, False: 3.32k]
  ------------------
  218|  3.32k|    if (!(reinterpret_cast<const T*>(buf_ + start + o)->Verify(*this))) {
  ------------------
  |  Branch (218:9): [True: 0, False: 3.32k]
  ------------------
  219|      0|      return false;
  220|      0|    }
  221|  3.32k|    if (TrackVerifierBufferSize) {
  ------------------
  |  Branch (221:9): [Folded, False: 3.32k]
  ------------------
  222|      0|      if (GetComputedSize() == 0) return false;
  ------------------
  |  Branch (222:11): [True: 0, False: 0]
  ------------------
  223|      0|    }
  224|  3.32k|    return true;
  225|  3.32k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE5CheckEb:
   64|  14.0M|  bool Check(const bool ok) const {
   65|       |    // clang-format off
   66|       |    #ifdef FLATBUFFERS_DEBUG_VERIFICATION_FAILURE
   67|       |      if (opts_.assert) { FLATBUFFERS_ASSERT(ok); }
   68|       |    #endif
   69|       |    // clang-format on
   70|  14.0M|    if (TrackVerifierBufferSize) {
  ------------------
  |  Branch (70:9): [Folded, False: 14.0M]
  ------------------
   71|      0|      if (!ok) {
  ------------------
  |  Branch (71:11): [True: 0, False: 0]
  ------------------
   72|      0|        upper_bound_ = 0;
   73|      0|      }
   74|      0|    }
   75|  14.0M|    return ok;
   76|  14.0M|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE12VerifyOffsetIjiEEmm:
  265|   688k|  size_t VerifyOffset(const size_t start) const {
  266|   688k|    if (!Verify<OffsetT>(start)) return 0;
  ------------------
  |  Branch (266:9): [True: 0, False: 688k]
  ------------------
  267|   688k|    const auto o = ReadScalar<OffsetT>(buf_ + start);
  268|       |    // May not point to itself.
  269|   688k|    if (!Check(o != 0)) return 0;
  ------------------
  |  Branch (269:9): [True: 0, False: 688k]
  ------------------
  270|       |    // Can't wrap around larger than the max size.
  271|   688k|    if (!Check(static_cast<SOffsetT>(o) >= 0)) return 0;
  ------------------
  |  Branch (271:9): [True: 0, False: 688k]
  ------------------
  272|       |    // Must be inside the buffer to create a pointer from it (pointer outside
  273|       |    // buffer is UB).
  274|   688k|    if (!Verify(start + o, 1)) return 0;
  ------------------
  |  Branch (274:9): [True: 0, False: 688k]
  ------------------
  275|   688k|    return o;
  276|   688k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE6VerifyIjEEbm:
   95|  1.09M|  bool Verify(const size_t elem) const {
   96|  1.09M|    return VerifyAlignment(elem, sizeof(T)) && Verify(elem, sizeof(T));
  ------------------
  |  Branch (96:12): [True: 1.09M, False: 0]
  |  Branch (96:48): [True: 1.09M, False: 0]
  ------------------
   97|  1.09M|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE15VerifyAlignmentEmm:
   89|  4.34M|  bool VerifyAlignment(const size_t elem, const size_t align) const {
   90|  4.34M|    return Check((elem & (align - 1)) == 0 || !opts_.check_alignment);
  ------------------
  |  Branch (90:18): [True: 4.34M, False: 0]
  |  Branch (90:47): [True: 0, False: 0]
  ------------------
   91|  4.34M|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE6VerifyEmm:
   79|  5.78M|  bool Verify(const size_t elem, const size_t elem_len) const {
   80|  5.78M|    if (TrackVerifierBufferSize) {
  ------------------
  |  Branch (80:9): [Folded, False: 5.78M]
  ------------------
   81|      0|      auto upper_bound = elem + elem_len;
   82|      0|      if (upper_bound_ < upper_bound) {
  ------------------
  |  Branch (82:11): [True: 0, False: 0]
  ------------------
   83|      0|        upper_bound_ = upper_bound;
   84|      0|      }
   85|      0|    }
   86|  5.78M|    return Check(elem_len < size_ && elem <= size_ - elem_len);
  ------------------
  |  Branch (86:18): [True: 5.78M, False: 0]
  |  Branch (86:38): [True: 5.78M, False: 0]
  ------------------
   87|  5.78M|  }
_ZN11flatbuffers16VerifierTemplateILb0EE16VerifyTableStartEPKh:
  185|   588k|  bool VerifyTableStart(const uint8_t* const table) {
  186|       |    // Check the vtable offset.
  187|   588k|    const auto tableo = static_cast<size_t>(table - buf_);
  188|   588k|    if (!Verify<soffset_t>(tableo)) return false;
  ------------------
  |  Branch (188:9): [True: 0, False: 588k]
  ------------------
  189|       |    // This offset may be signed, but doing the subtraction unsigned always
  190|       |    // gives the result we want.
  191|   588k|    const auto vtableo =
  192|   588k|        tableo - static_cast<size_t>(ReadScalar<soffset_t>(table));
  193|       |    // Check the vtable size field, then check vtable fits in its entirety.
  194|   588k|    if (!(VerifyComplexity() && Verify<voffset_t>(vtableo) &&
  ------------------
  |  Branch (194:11): [True: 588k, False: 0]
  |  Branch (194:33): [True: 588k, False: 0]
  ------------------
  195|   588k|          VerifyAlignment(ReadScalar<voffset_t>(buf_ + vtableo),
  ------------------
  |  Branch (195:11): [True: 588k, False: 0]
  ------------------
  196|   588k|                          sizeof(voffset_t))))
  197|      0|      return false;
  198|   588k|    const auto vsize = ReadScalar<voffset_t>(buf_ + vtableo);
  199|   588k|    return Check((vsize & 1) == 0) && Verify(vtableo, vsize);
  ------------------
  |  Branch (199:12): [True: 588k, False: 0]
  |  Branch (199:39): [True: 588k, False: 0]
  ------------------
  200|   588k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE6VerifyIiEEbm:
   95|   588k|  bool Verify(const size_t elem) const {
   96|   588k|    return VerifyAlignment(elem, sizeof(T)) && Verify(elem, sizeof(T));
  ------------------
  |  Branch (96:12): [True: 588k, False: 0]
  |  Branch (96:48): [True: 588k, False: 0]
  ------------------
   97|   588k|  }
_ZN11flatbuffers16VerifierTemplateILb0EE16VerifyComplexityEv:
  286|   588k|  bool VerifyComplexity() {
  287|   588k|    depth_++;
  288|   588k|    num_tables_++;
  289|   588k|    return Check(depth_ <= opts_.max_depth && num_tables_ <= opts_.max_tables);
  ------------------
  |  Branch (289:18): [True: 588k, False: 0]
  |  Branch (289:47): [True: 588k, False: 0]
  ------------------
  290|   588k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE6VerifyItEEbm:
   95|   588k|  bool Verify(const size_t elem) const {
   96|   588k|    return VerifyAlignment(elem, sizeof(T)) && Verify(elem, sizeof(T));
  ------------------
  |  Branch (96:12): [True: 588k, False: 0]
  |  Branch (96:48): [True: 588k, False: 0]
  ------------------
   97|   588k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE12VerifyOffsetIjEEmPKht:
  279|   684k|  size_t VerifyOffset(const uint8_t* const base, const voffset_t start) const {
  280|   684k|    return VerifyOffset<OffsetT>(static_cast<size_t>(base - buf_) + start);
  281|   684k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE12VerifyVectorITpTnRiJENS_6OffsetIN10reflection6ObjectEEEjEEbPKNS_6VectorIT0_T1_EE:
  125|  3.32k|  bool VerifyVector(const Vector<T, LenT>* const vec) const {
  126|  3.32k|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (126:12): [True: 0, False: 3.32k]
  |  Branch (126:20): [True: 3.32k, False: 0]
  ------------------
  127|  3.32k|                       reinterpret_cast<const uint8_t*>(vec), sizeof(T));
  128|  3.32k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE20VerifyVectorOrStringIjEEbPKhmPm:
  148|   402k|                            size_t* const end = nullptr) const {
  149|   402k|    const auto vec_offset = static_cast<size_t>(vec - buf_);
  150|       |    // Check we can read the size field.
  151|   402k|    if (!Verify<LenT>(vec_offset)) return false;
  ------------------
  |  Branch (151:9): [True: 0, False: 402k]
  ------------------
  152|       |    // Check the whole array. If this is a string, the byte past the array must
  153|       |    // be 0.
  154|   402k|    const LenT size = ReadScalar<LenT>(vec);
  155|   402k|    const auto max_elems = opts_.max_size / elem_size;
  156|   402k|    if (!Check(size < max_elems))
  ------------------
  |  Branch (156:9): [True: 0, False: 402k]
  ------------------
  157|      0|      return false;  // Protect against byte_size overflowing.
  158|   402k|    const auto byte_size = sizeof(LenT) + elem_size * size;
  159|   402k|    if (end) *end = vec_offset + byte_size;
  ------------------
  |  Branch (159:9): [True: 352k, False: 49.8k]
  ------------------
  160|   402k|    return Verify(vec_offset, byte_size);
  161|   402k|  }
_ZN11flatbuffers16VerifierTemplateILb0EE20VerifyVectorOfTablesIN10reflection6ObjectEEEbPKNS_6VectorINS_6OffsetIT_EEjEE:
  175|  3.32k|  bool VerifyVectorOfTables(const Vector<Offset<T>>* const vec) {
  176|  3.32k|    if (vec) {
  ------------------
  |  Branch (176:9): [True: 3.32k, False: 0]
  ------------------
  177|  26.6k|      for (uoffset_t i = 0; i < vec->size(); i++) {
  ------------------
  |  Branch (177:29): [True: 23.2k, False: 3.32k]
  ------------------
  178|  23.2k|        if (!vec->Get(i)->Verify(*this)) return false;
  ------------------
  |  Branch (178:13): [True: 0, False: 23.2k]
  ------------------
  179|  23.2k|      }
  180|  3.32k|    }
  181|  3.32k|    return true;
  182|  3.32k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE12VerifyVectorITpTnRiJENS_6OffsetIN10reflection5FieldEEEjEEbPKNS_6VectorIT0_T1_EE:
  125|  26.6k|  bool VerifyVector(const Vector<T, LenT>* const vec) const {
  126|  26.6k|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (126:12): [True: 0, False: 26.6k]
  |  Branch (126:20): [True: 26.6k, False: 0]
  ------------------
  127|  26.6k|                       reinterpret_cast<const uint8_t*>(vec), sizeof(T));
  128|  26.6k|  }
_ZN11flatbuffers16VerifierTemplateILb0EE20VerifyVectorOfTablesIN10reflection5FieldEEEbPKNS_6VectorINS_6OffsetIT_EEjEE:
  175|  26.6k|  bool VerifyVectorOfTables(const Vector<Offset<T>>* const vec) {
  176|  26.6k|    if (vec) {
  ------------------
  |  Branch (176:9): [True: 26.6k, False: 0]
  ------------------
  177|   249k|      for (uoffset_t i = 0; i < vec->size(); i++) {
  ------------------
  |  Branch (177:29): [True: 222k, False: 26.6k]
  ------------------
  178|   222k|        if (!vec->Get(i)->Verify(*this)) return false;
  ------------------
  |  Branch (178:13): [True: 0, False: 222k]
  ------------------
  179|   222k|      }
  180|  26.6k|    }
  181|  26.6k|    return true;
  182|  26.6k|  }
_ZN11flatbuffers16VerifierTemplateILb0EE11VerifyTableIN10reflection4TypeEEEbPKT_:
  119|   279k|  bool VerifyTable(const T* const table) {
  120|   279k|    return !table || table->Verify(*this);
  ------------------
  |  Branch (120:12): [True: 0, False: 279k]
  |  Branch (120:22): [True: 279k, False: 0]
  ------------------
  121|   279k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE11VerifyFieldIaEEbPKhtm:
  112|   302k|                   const size_t align) const {
  113|   302k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  114|   302k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (114:12): [True: 302k, False: 0]
  |  Branch (114:41): [True: 302k, False: 0]
  ------------------
  115|   302k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE11VerifyFieldIjEEbPKhtm:
  112|   372k|                   const size_t align) const {
  113|   372k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  114|   372k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (114:12): [True: 372k, False: 0]
  |  Branch (114:41): [True: 372k, False: 0]
  ------------------
  115|   372k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE11VerifyFieldItEEbPKhtm:
  112|   415k|                   const size_t align) const {
  113|   415k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  114|   415k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (114:12): [True: 415k, False: 0]
  |  Branch (114:41): [True: 415k, False: 0]
  ------------------
  115|   415k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE11VerifyFieldIlEEbPKhtm:
  112|  53.2k|                   const size_t align) const {
  113|  53.2k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  114|  53.2k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (114:12): [True: 53.2k, False: 0]
  |  Branch (114:41): [True: 53.2k, False: 0]
  ------------------
  115|  53.2k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE11VerifyFieldIdEEbPKhtm:
  112|  13.3k|                   const size_t align) const {
  113|  13.3k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  114|  13.3k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (114:12): [True: 13.3k, False: 0]
  |  Branch (114:41): [True: 13.3k, False: 0]
  ------------------
  115|  13.3k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE11VerifyFieldIhEEbPKhtm:
  112|   149k|                   const size_t align) const {
  113|   149k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  114|   149k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (114:12): [True: 149k, False: 0]
  |  Branch (114:41): [True: 149k, False: 0]
  ------------------
  115|   149k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE11VerifyFieldIiEEbPKhtm:
  112|   179k|                   const size_t align) const {
  113|   179k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  114|   179k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (114:12): [True: 179k, False: 0]
  |  Branch (114:41): [True: 179k, False: 0]
  ------------------
  115|   179k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE12VerifyVectorITpTnRiJENS_6OffsetIN10reflection8KeyValueEEEjEEbPKNS_6VectorIT0_T1_EE:
  125|   305k|  bool VerifyVector(const Vector<T, LenT>* const vec) const {
  126|   305k|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (126:12): [True: 305k, False: 0]
  |  Branch (126:20): [True: 0, False: 0]
  ------------------
  127|      0|                       reinterpret_cast<const uint8_t*>(vec), sizeof(T));
  128|   305k|  }
_ZN11flatbuffers16VerifierTemplateILb0EE20VerifyVectorOfTablesIN10reflection8KeyValueEEEbPKNS_6VectorINS_6OffsetIT_EEjEE:
  175|   305k|  bool VerifyVectorOfTables(const Vector<Offset<T>>* const vec) {
  176|   305k|    if (vec) {
  ------------------
  |  Branch (176:9): [True: 0, False: 305k]
  ------------------
  177|      0|      for (uoffset_t i = 0; i < vec->size(); i++) {
  ------------------
  |  Branch (177:29): [True: 0, False: 0]
  ------------------
  178|      0|        if (!vec->Get(i)->Verify(*this)) return false;
  ------------------
  |  Branch (178:13): [True: 0, False: 0]
  ------------------
  179|      0|      }
  180|      0|    }
  181|   305k|    return true;
  182|   305k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE12VerifyVectorITpTnRiJENS_6OffsetINS_6StringEEEjEEbPKNS_6VectorIT0_T1_EE:
  125|   305k|  bool VerifyVector(const Vector<T, LenT>* const vec) const {
  126|   305k|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (126:12): [True: 305k, False: 0]
  |  Branch (126:20): [True: 0, False: 0]
  ------------------
  127|      0|                       reinterpret_cast<const uint8_t*>(vec), sizeof(T));
  128|   305k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE21VerifyVectorOfStringsEPKNS_6VectorINS_6OffsetINS_6StringEEEjEE:
  164|   305k|  bool VerifyVectorOfStrings(const Vector<Offset<String>>* const vec) const {
  165|   305k|    if (vec) {
  ------------------
  |  Branch (165:9): [True: 0, False: 305k]
  ------------------
  166|      0|      for (uoffset_t i = 0; i < vec->size(); i++) {
  ------------------
  |  Branch (166:29): [True: 0, False: 0]
  ------------------
  167|      0|        if (!VerifyString(vec->Get(i))) return false;
  ------------------
  |  Branch (167:13): [True: 0, False: 0]
  ------------------
  168|      0|      }
  169|      0|    }
  170|   305k|    return true;
  171|   305k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE12VerifyVectorITpTnRiJENS_6OffsetIN10reflection4EnumEEEjEEbPKNS_6VectorIT0_T1_EE:
  125|  3.32k|  bool VerifyVector(const Vector<T, LenT>* const vec) const {
  126|  3.32k|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (126:12): [True: 0, False: 3.32k]
  |  Branch (126:20): [True: 3.32k, False: 0]
  ------------------
  127|  3.32k|                       reinterpret_cast<const uint8_t*>(vec), sizeof(T));
  128|  3.32k|  }
_ZN11flatbuffers16VerifierTemplateILb0EE20VerifyVectorOfTablesIN10reflection4EnumEEEbPKNS_6VectorINS_6OffsetIT_EEjEE:
  175|  3.32k|  bool VerifyVectorOfTables(const Vector<Offset<T>>* const vec) {
  176|  3.32k|    if (vec) {
  ------------------
  |  Branch (176:9): [True: 3.32k, False: 0]
  ------------------
  177|  16.6k|      for (uoffset_t i = 0; i < vec->size(); i++) {
  ------------------
  |  Branch (177:29): [True: 13.3k, False: 3.32k]
  ------------------
  178|  13.3k|        if (!vec->Get(i)->Verify(*this)) return false;
  ------------------
  |  Branch (178:13): [True: 0, False: 13.3k]
  ------------------
  179|  13.3k|      }
  180|  3.32k|    }
  181|  3.32k|    return true;
  182|  3.32k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE12VerifyVectorITpTnRiJENS_6OffsetIN10reflection7EnumValEEEjEEbPKNS_6VectorIT0_T1_EE:
  125|  13.3k|  bool VerifyVector(const Vector<T, LenT>* const vec) const {
  126|  13.3k|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (126:12): [True: 0, False: 13.3k]
  |  Branch (126:20): [True: 13.3k, False: 0]
  ------------------
  127|  13.3k|                       reinterpret_cast<const uint8_t*>(vec), sizeof(T));
  128|  13.3k|  }
_ZN11flatbuffers16VerifierTemplateILb0EE20VerifyVectorOfTablesIN10reflection7EnumValEEEbPKNS_6VectorINS_6OffsetIT_EEjEE:
  175|  13.3k|  bool VerifyVectorOfTables(const Vector<Offset<T>>* const vec) {
  176|  13.3k|    if (vec) {
  ------------------
  |  Branch (176:9): [True: 13.3k, False: 0]
  ------------------
  177|  56.5k|      for (uoffset_t i = 0; i < vec->size(); i++) {
  ------------------
  |  Branch (177:29): [True: 43.2k, False: 13.3k]
  ------------------
  178|  43.2k|        if (!vec->Get(i)->Verify(*this)) return false;
  ------------------
  |  Branch (178:13): [True: 0, False: 43.2k]
  ------------------
  179|  43.2k|      }
  180|  13.3k|    }
  181|  13.3k|    return true;
  182|  13.3k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE12VerifyStringEPKNS_6StringE:
  137|   352k|  bool VerifyString(const String* const str) const {
  138|   352k|    size_t end;
  139|   352k|    return !str || (VerifyVectorOrString<uoffset_t>(
  ------------------
  |  Branch (139:12): [True: 0, False: 352k]
  |  Branch (139:21): [True: 352k, False: 0]
  ------------------
  140|   352k|                        reinterpret_cast<const uint8_t*>(str), 1, &end) &&
  141|   352k|                    Verify(end, 1) &&           // Must have terminator
  ------------------
  |  Branch (141:21): [True: 352k, False: 0]
  ------------------
  142|   352k|                    Check(buf_[end] == '\0'));  // Terminating byte must be 0.
  ------------------
  |  Branch (142:21): [True: 352k, False: 0]
  ------------------
  143|   352k|  }
_ZN11flatbuffers16VerifierTemplateILb0EE11VerifyTableIN10reflection6ObjectEEEbPKT_:
  119|  3.32k|  bool VerifyTable(const T* const table) {
  120|  3.32k|    return !table || table->Verify(*this);
  ------------------
  |  Branch (120:12): [True: 0, False: 3.32k]
  |  Branch (120:22): [True: 3.32k, False: 0]
  ------------------
  121|  3.32k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE12VerifyVectorITpTnRiJENS_6OffsetIN10reflection7ServiceEEEjEEbPKNS_6VectorIT0_T1_EE:
  125|  3.32k|  bool VerifyVector(const Vector<T, LenT>* const vec) const {
  126|  3.32k|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (126:12): [True: 0, False: 3.32k]
  |  Branch (126:20): [True: 3.32k, False: 0]
  ------------------
  127|  3.32k|                       reinterpret_cast<const uint8_t*>(vec), sizeof(T));
  128|  3.32k|  }
_ZN11flatbuffers16VerifierTemplateILb0EE20VerifyVectorOfTablesIN10reflection7ServiceEEEbPKNS_6VectorINS_6OffsetIT_EEjEE:
  175|  3.32k|  bool VerifyVectorOfTables(const Vector<Offset<T>>* const vec) {
  176|  3.32k|    if (vec) {
  ------------------
  |  Branch (176:9): [True: 3.32k, False: 0]
  ------------------
  177|  3.32k|      for (uoffset_t i = 0; i < vec->size(); i++) {
  ------------------
  |  Branch (177:29): [True: 0, False: 3.32k]
  ------------------
  178|      0|        if (!vec->Get(i)->Verify(*this)) return false;
  ------------------
  |  Branch (178:13): [True: 0, False: 0]
  ------------------
  179|      0|      }
  180|  3.32k|    }
  181|  3.32k|    return true;
  182|  3.32k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE11VerifyFieldImEEbPKhtm:
  112|  3.32k|                   const size_t align) const {
  113|  3.32k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  114|  3.32k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (114:12): [True: 3.32k, False: 0]
  |  Branch (114:41): [True: 3.32k, False: 0]
  ------------------
  115|  3.32k|  }
_ZNK11flatbuffers16VerifierTemplateILb0EE12VerifyVectorITpTnRiJENS_6OffsetIN10reflection10SchemaFileEEEjEEbPKNS_6VectorIT0_T1_EE:
  125|  3.32k|  bool VerifyVector(const Vector<T, LenT>* const vec) const {
  126|  3.32k|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (126:12): [True: 3.32k, False: 0]
  |  Branch (126:20): [True: 0, False: 0]
  ------------------
  127|      0|                       reinterpret_cast<const uint8_t*>(vec), sizeof(T));
  128|  3.32k|  }
_ZN11flatbuffers16VerifierTemplateILb0EE20VerifyVectorOfTablesIN10reflection10SchemaFileEEEbPKNS_6VectorINS_6OffsetIT_EEjEE:
  175|  3.32k|  bool VerifyVectorOfTables(const Vector<Offset<T>>* const vec) {
  176|  3.32k|    if (vec) {
  ------------------
  |  Branch (176:9): [True: 0, False: 3.32k]
  ------------------
  177|      0|      for (uoffset_t i = 0; i < vec->size(); i++) {
  ------------------
  |  Branch (177:29): [True: 0, False: 0]
  ------------------
  178|      0|        if (!vec->Get(i)->Verify(*this)) return false;
  ------------------
  |  Branch (178:13): [True: 0, False: 0]
  ------------------
  179|      0|      }
  180|      0|    }
  181|  3.32k|    return true;
  182|  3.32k|  }
_ZN11flatbuffers16VerifierTemplateILb0EE8EndTableEv:
  293|   588k|  bool EndTable() {
  294|   588k|    depth_--;
  295|   588k|    return true;
  296|   588k|  }

_ZN11flatbuffers15BinaryAnnotator8AnnotateEv:
  126|  3.32k|std::map<uint64_t, BinarySection> BinaryAnnotator::Annotate() {
  127|  3.32k|  if (bfbs_ != nullptr && bfbs_length_ != 0) {
  ------------------
  |  Branch (127:7): [True: 3.32k, False: 0]
  |  Branch (127:27): [True: 3.32k, False: 0]
  ------------------
  128|  3.32k|    flatbuffers::Verifier verifier(bfbs_, static_cast<size_t>(bfbs_length_));
  129|  3.32k|    if (!reflection::VerifySchemaBuffer(verifier)) {
  ------------------
  |  Branch (129:9): [True: 0, False: 3.32k]
  ------------------
  130|      0|      return {};
  131|      0|    }
  132|  3.32k|  }
  133|       |
  134|       |  // The binary is too short to read as a flatbuffers.
  135|  3.32k|  if (binary_length_ < FLATBUFFERS_MIN_BUFFER_SIZE) {
  ------------------
  |  |  349|  3.32k|#define FLATBUFFERS_MIN_BUFFER_SIZE sizeof(::flatbuffers::uoffset_t) + \
  |  |  350|  3.32k|  sizeof(::flatbuffers::soffset_t) + sizeof(uint16_t) + sizeof(uint16_t)
  ------------------
  |  Branch (135:7): [True: 5, False: 3.31k]
  ------------------
  136|      5|    return {};
  137|      5|  }
  138|       |
  139|       |  // Make sure we start with a clean slate.
  140|  3.31k|  vtables_.clear();
  141|  3.31k|  sections_.clear();
  142|       |
  143|       |  // First parse the header region which always start at offset 0.
  144|       |  // The returned offset will point to the root_table location.
  145|  3.31k|  const uint64_t root_table_offset = BuildHeader(0);
  146|       |
  147|  3.31k|  if (IsValidOffset(root_table_offset)) {
  ------------------
  |  Branch (147:7): [True: 3.24k, False: 71]
  ------------------
  148|       |    // Build the root table, and all else will be referenced from it.
  149|  3.24k|    BuildTable(root_table_offset, BinarySectionType::RootTable, RootTable());
  150|  3.24k|  }
  151|       |
  152|       |  // Now that all the sections are built, make sure the binary sections are
  153|       |  // contiguous.
  154|  3.31k|  FixMissingRegions();
  155|       |
  156|       |  // Then scan the area between BinarySections insert padding sections that are
  157|       |  // implied.
  158|  3.31k|  FixMissingSections();
  159|       |
  160|  3.31k|  return sections_;
  161|  3.32k|}
_ZN11flatbuffers15BinaryAnnotator11BuildHeaderEm:
  163|  3.31k|uint64_t BinaryAnnotator::BuildHeader(const uint64_t header_offset) {
  164|  3.31k|  uint64_t offset = header_offset;
  165|  3.31k|  std::vector<BinaryRegion> regions;
  166|       |
  167|       |  // If this binary is a size prefixed one, attempt to parse the size.
  168|  3.31k|  if (is_size_prefixed_) {
  ------------------
  |  Branch (168:7): [True: 0, False: 3.31k]
  ------------------
  169|      0|    BinaryRegionComment prefix_length_comment;
  170|      0|    prefix_length_comment.type = BinaryRegionCommentType::SizePrefix;
  171|       |
  172|      0|    bool has_prefix_value = false;
  173|      0|    const auto prefix_length = ReadScalar<uoffset64_t>(offset);
  174|      0|    if (*prefix_length <= binary_length_) {
  ------------------
  |  Branch (174:9): [True: 0, False: 0]
  ------------------
  175|      0|      regions.push_back(MakeBinaryRegion(offset, sizeof(uoffset64_t),
  176|      0|                                         BinaryRegionType::Uint64, 0, 0,
  177|      0|                                         prefix_length_comment));
  178|      0|      offset += sizeof(uoffset64_t);
  179|      0|      has_prefix_value = true;
  180|      0|    }
  181|       |
  182|      0|    if (!has_prefix_value) {
  ------------------
  |  Branch (182:9): [True: 0, False: 0]
  ------------------
  183|      0|      const auto prefix_length = ReadScalar<uoffset_t>(offset);
  184|      0|      if (*prefix_length <= binary_length_) {
  ------------------
  |  Branch (184:11): [True: 0, False: 0]
  ------------------
  185|      0|        regions.push_back(MakeBinaryRegion(offset, sizeof(uoffset_t),
  186|      0|                                           BinaryRegionType::Uint32, 0, 0,
  187|      0|                                           prefix_length_comment));
  188|      0|        offset += sizeof(uoffset_t);
  189|      0|        has_prefix_value = true;
  190|      0|      }
  191|      0|    }
  192|       |
  193|      0|    if (!has_prefix_value) {
  ------------------
  |  Branch (193:9): [True: 0, False: 0]
  ------------------
  194|      0|      SetError(prefix_length_comment, BinaryRegionStatus::ERROR);
  195|      0|    }
  196|      0|  }
  197|       |
  198|  3.31k|  const auto root_table_offset = ReadScalar<uint32_t>(offset);
  199|       |
  200|  3.31k|  if (!root_table_offset.has_value()) {
  ------------------
  |  Branch (200:7): [True: 0, False: 3.31k]
  ------------------
  201|       |    // This shouldn't occur, since we validate the min size of the buffer
  202|       |    // before. But for completion sake, we shouldn't read passed the binary end.
  203|      0|    return std::numeric_limits<uint64_t>::max();
  204|      0|  }
  205|       |
  206|  3.31k|  const auto root_table_loc = offset + *root_table_offset;
  207|       |
  208|  3.31k|  BinaryRegionComment root_offset_comment;
  209|  3.31k|  root_offset_comment.type = BinaryRegionCommentType::RootTableOffset;
  210|  3.31k|  root_offset_comment.name = RootTable()->name()->str();
  211|       |
  212|  3.31k|  if (!IsValidOffset(root_table_loc)) {
  ------------------
  |  Branch (212:7): [True: 71, False: 3.24k]
  ------------------
  213|     71|    SetError(root_offset_comment,
  214|     71|             BinaryRegionStatus::ERROR_OFFSET_OUT_OF_BINARY);
  215|     71|  }
  216|       |
  217|  3.31k|  regions.push_back(MakeBinaryRegion(offset, sizeof(uint32_t),
  218|  3.31k|                                     BinaryRegionType::UOffset, 0,
  219|  3.31k|                                     root_table_loc, root_offset_comment));
  220|  3.31k|  offset += sizeof(uint32_t);
  221|       |
  222|  3.31k|  if (IsValidRead(offset, flatbuffers::kFileIdentifierLength) &&
  ------------------
  |  Branch (222:7): [True: 3.31k, False: 0]
  ------------------
  223|  3.31k|      IsPrintableRegion(offset, flatbuffers::kFileIdentifierLength, binary_)) {
  ------------------
  |  Branch (223:7): [True: 14, False: 3.30k]
  ------------------
  224|     14|    BinaryRegionComment comment;
  225|     14|    comment.type = BinaryRegionCommentType::FileIdentifier;
  226|       |    // Check if the file identifier region has non-zero data, and assume its
  227|       |    // the file identifier. Otherwise, it will get filled in with padding
  228|       |    // later.
  229|     14|    regions.push_back(MakeBinaryRegion(
  230|     14|        offset, flatbuffers::kFileIdentifierLength * sizeof(uint8_t),
  231|     14|        BinaryRegionType::Char, flatbuffers::kFileIdentifierLength, 0,
  232|     14|        comment));
  233|     14|  }
  234|       |
  235|  3.31k|  AddSection(header_offset, MakeBinarySection("", BinarySectionType::Header,
  236|  3.31k|                                              std::move(regions)));
  237|       |
  238|  3.31k|  return root_table_loc;
  239|  3.31k|}
_ZN11flatbuffers15BinaryAnnotator16GetOrBuildVTableEmPKN10reflection6ObjectEm:
  243|  2.34M|    const uint64_t offset_of_referring_table) {
  244|       |  // Get a list of vtables (if any) already defined at this offset.
  245|  2.34M|  std::list<VTable>& vtables = vtables_[vtable_offset];
  246|       |
  247|       |  // See if this vtable for the table type has been generated before.
  248|  2.34M|  for (VTable& vtable : vtables) {
  ------------------
  |  Branch (248:23): [True: 11.9k, False: 2.34M]
  ------------------
  249|  11.9k|    if (vtable.referring_table == table) {
  ------------------
  |  Branch (249:9): [True: 7.04k, False: 4.95k]
  ------------------
  250|  7.04k|      return &vtable;
  251|  7.04k|    }
  252|  11.9k|  }
  253|       |
  254|       |  // If we are trying to make a new vtable and it is already encompassed by
  255|       |  // another binary section, something is corrupted.
  256|  2.34M|  if (vtables.empty() && ContainsSection(vtable_offset)) {
  ------------------
  |  Branch (256:7): [True: 2.33M, False: 3.22k]
  |  Branch (256:26): [True: 93.0k, False: 2.24M]
  ------------------
  257|  93.0k|    return nullptr;
  258|  93.0k|  }
  259|       |
  260|  2.24M|  const std::string referring_table_name = table->name()->str();
  261|       |
  262|  2.24M|  BinaryRegionComment vtable_size_comment;
  263|  2.24M|  vtable_size_comment.type = BinaryRegionCommentType::VTableSize;
  264|       |
  265|  2.24M|  const auto vtable_length = ReadScalar<uint16_t>(vtable_offset);
  266|  2.24M|  if (!vtable_length.has_value()) {
  ------------------
  |  Branch (266:7): [True: 30, False: 2.24M]
  ------------------
  267|     30|    const uint64_t remaining = RemainingBytes(vtable_offset);
  268|       |
  269|     30|    SetError(vtable_size_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY,
  270|     30|             "2");
  271|       |
  272|     30|    AddSection(vtable_offset,
  273|     30|               MakeSingleRegionBinarySection(
  274|     30|                   referring_table_name, BinarySectionType::VTable,
  275|     30|                   MakeBinaryRegion(vtable_offset, remaining,
  276|     30|                                    BinaryRegionType::Unknown, remaining, 0,
  277|     30|                                    vtable_size_comment)));
  278|     30|    return nullptr;
  279|     30|  }
  280|       |
  281|       |  // Vtables start with the size of the vtable
  282|  2.24M|  const uint16_t vtable_size = vtable_length.value();
  283|       |
  284|  2.24M|  if (!IsValidOffset(vtable_offset + vtable_size - 1)) {
  ------------------
  |  Branch (284:7): [True: 11.1k, False: 2.23M]
  ------------------
  285|  11.1k|    SetError(vtable_size_comment, BinaryRegionStatus::ERROR_LENGTH_TOO_LONG);
  286|       |    // The vtable_size points to off the end of the binary.
  287|  11.1k|    AddSection(vtable_offset,
  288|  11.1k|               MakeSingleRegionBinarySection(
  289|  11.1k|                   referring_table_name, BinarySectionType::VTable,
  290|  11.1k|                   MakeBinaryRegion(vtable_offset, sizeof(uint16_t),
  291|  11.1k|                                    BinaryRegionType::Uint16, 0, 0,
  292|  11.1k|                                    vtable_size_comment)));
  293|       |
  294|  11.1k|    return nullptr;
  295|  2.23M|  } else if (vtable_size < 2 * sizeof(uint16_t)) {
  ------------------
  |  Branch (295:14): [True: 2.11M, False: 126k]
  ------------------
  296|  2.11M|    SetError(vtable_size_comment, BinaryRegionStatus::ERROR_LENGTH_TOO_SHORT,
  297|  2.11M|             "4");
  298|       |    // The size includes itself and the table size which are both uint16_t.
  299|  2.11M|    AddSection(vtable_offset,
  300|  2.11M|               MakeSingleRegionBinarySection(
  301|  2.11M|                   referring_table_name, BinarySectionType::VTable,
  302|  2.11M|                   MakeBinaryRegion(vtable_offset, sizeof(uint16_t),
  303|  2.11M|                                    BinaryRegionType::Uint16, 0, 0,
  304|  2.11M|                                    vtable_size_comment)));
  305|  2.11M|    return nullptr;
  306|  2.11M|  }
  307|       |
  308|   126k|  std::vector<BinaryRegion> regions;
  309|       |
  310|   126k|  regions.push_back(MakeBinaryRegion(vtable_offset, sizeof(uint16_t),
  311|   126k|                                     BinaryRegionType::Uint16, 0, 0,
  312|   126k|                                     vtable_size_comment));
  313|   126k|  uint64_t offset = vtable_offset + sizeof(uint16_t);
  314|       |
  315|   126k|  BinaryRegionComment ref_table_len_comment;
  316|   126k|  ref_table_len_comment.type =
  317|   126k|      BinaryRegionCommentType::VTableRefferingTableLength;
  318|       |
  319|       |  // Ensure we can read the next uint16_t field, which is the size of the
  320|       |  // referring table.
  321|   126k|  const auto table_length = ReadScalar<uint16_t>(offset);
  322|       |
  323|   126k|  if (!table_length.has_value()) {
  ------------------
  |  Branch (323:7): [True: 0, False: 126k]
  ------------------
  324|      0|    const uint64_t remaining = RemainingBytes(offset);
  325|      0|    SetError(ref_table_len_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY,
  326|      0|             "2");
  327|       |
  328|      0|    AddSection(offset, MakeSingleRegionBinarySection(
  329|      0|                           referring_table_name, BinarySectionType::VTable,
  330|      0|                           MakeBinaryRegion(
  331|      0|                               offset, remaining, BinaryRegionType::Unknown,
  332|      0|                               remaining, 0, ref_table_len_comment)));
  333|      0|    return nullptr;
  334|      0|  }
  335|       |
  336|       |  // Then they have the size of the table they reference.
  337|   126k|  const uint16_t table_size = table_length.value();
  338|       |
  339|   126k|  if (!IsValidOffset(offset_of_referring_table + table_size - 1)) {
  ------------------
  |  Branch (339:7): [True: 5.58k, False: 120k]
  ------------------
  340|  5.58k|    SetError(ref_table_len_comment, BinaryRegionStatus::ERROR_LENGTH_TOO_LONG);
  341|   120k|  } else if (table_size < 4) {
  ------------------
  |  Branch (341:14): [True: 79.3k, False: 41.1k]
  ------------------
  342|  79.3k|    SetError(ref_table_len_comment, BinaryRegionStatus::ERROR_LENGTH_TOO_SHORT,
  343|  79.3k|             "4");
  344|  79.3k|  }
  345|       |
  346|   126k|  regions.push_back(MakeBinaryRegion(offset, sizeof(uint16_t),
  347|   126k|                                     BinaryRegionType::Uint16, 0, 0,
  348|   126k|                                     ref_table_len_comment));
  349|   126k|  offset += sizeof(uint16_t);
  350|       |
  351|   126k|  const uint64_t offset_start = offset;
  352|       |
  353|       |  // A mapping between field (and its id) to the relative offset (uint16_t) from
  354|       |  // the start of the table.
  355|   126k|  std::map<uint16_t, VTable::Entry> fields;
  356|       |
  357|       |  // Counter for determining if the binary has more vtable entries than the
  358|       |  // schema provided. This can occur if the binary was created at a newer schema
  359|       |  // version and is being processed with an older one.
  360|   126k|  uint16_t fields_processed = 0;
  361|       |
  362|       |  // Loop over all the fields.
  363|   126k|  ForAllFields(table, /*reverse=*/false, [&](const reflection::Field* field) {
  364|   126k|    const uint64_t field_offset = offset_start + field->id() * sizeof(uint16_t);
  365|       |
  366|   126k|    if (field_offset >= vtable_offset + vtable_size) {
  367|       |      // This field_offset is too large for this vtable, so it must come from a
  368|       |      // newer schema than the binary was create with or the binary writer did
  369|       |      // not write it. For either case, it is safe to ignore.
  370|       |
  371|       |      // TODO(dbaileychess): We could show which fields are not set an their
  372|       |      // default values if we want. We just need a way to make it obvious that
  373|       |      // it isn't part of the buffer.
  374|   126k|      return;
  375|   126k|    }
  376|       |
  377|   126k|    BinaryRegionComment field_comment;
  378|   126k|    field_comment.type = BinaryRegionCommentType::VTableFieldOffset;
  379|   126k|    field_comment.name = std::string(field->name()->c_str()) +
  380|   126k|                         "` (id: " + std::to_string(field->id()) + ")";
  381|       |
  382|   126k|    const auto offset_from_table = ReadScalar<uint16_t>(field_offset);
  383|       |
  384|   126k|    if (!offset_from_table.has_value()) {
  385|   126k|      const uint64_t remaining = RemainingBytes(field_offset);
  386|       |
  387|   126k|      SetError(field_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "2");
  388|   126k|      regions.push_back(MakeBinaryRegion(field_offset, remaining,
  389|   126k|                                         BinaryRegionType::Unknown, remaining,
  390|   126k|                                         0, field_comment));
  391|       |
  392|   126k|      return;
  393|   126k|    }
  394|       |
  395|   126k|    if (!IsValidOffset(offset_of_referring_table + offset_from_table.value() -
  396|   126k|                       1)) {
  397|   126k|      SetError(field_comment, BinaryRegionStatus::ERROR_OFFSET_OUT_OF_BINARY);
  398|   126k|      regions.push_back(MakeBinaryRegion(field_offset, sizeof(uint16_t),
  399|   126k|                                         BinaryRegionType::VOffset, 0, 0,
  400|   126k|                                         field_comment));
  401|   126k|      return;
  402|   126k|    }
  403|       |
  404|   126k|    VTable::Entry entry;
  405|   126k|    entry.field = field;
  406|   126k|    entry.offset_from_table = offset_from_table.value();
  407|   126k|    fields.insert(std::make_pair(field->id(), entry));
  408|       |
  409|   126k|    std::string default_label;
  410|   126k|    if (offset_from_table.value() == 0) {
  411|       |      // Not present, so could be default or be optional.
  412|   126k|      if (field->required()) {
  413|   126k|        SetError(field_comment,
  414|   126k|                 BinaryRegionStatus::ERROR_REQUIRED_FIELD_NOT_PRESENT);
  415|       |        // If this is a required field, make it known this is an error.
  416|   126k|        regions.push_back(MakeBinaryRegion(field_offset, sizeof(uint16_t),
  417|   126k|                                           BinaryRegionType::VOffset, 0, 0,
  418|   126k|                                           field_comment));
  419|   126k|        return;
  420|   126k|      } else {
  421|       |        // Its an optional field, so get the default value and interpret and
  422|       |        // provided an annotation for it.
  423|   126k|        if (IsScalar(field->type()->base_type())) {
  424|   126k|          default_label += "<defaults to ";
  425|   126k|          default_label += IsFloat(field->type()->base_type())
  426|   126k|                               ? std::to_string(field->default_real())
  427|   126k|                               : std::to_string(field->default_integer());
  428|   126k|          default_label += "> (";
  429|   126k|        } else {
  430|   126k|          default_label += "<null> (";
  431|   126k|        }
  432|   126k|        default_label +=
  433|   126k|            reflection::EnumNameBaseType(field->type()->base_type());
  434|   126k|        default_label += ")";
  435|   126k|      }
  436|   126k|    }
  437|   126k|    field_comment.default_value = default_label;
  438|       |
  439|   126k|    regions.push_back(MakeBinaryRegion(field_offset, sizeof(uint16_t),
  440|   126k|                                       BinaryRegionType::VOffset, 0, 0,
  441|   126k|                                       field_comment));
  442|       |
  443|   126k|    fields_processed++;
  444|   126k|  });
  445|       |
  446|       |  // Check if we covered all the expectant fields. If not, we need to add them
  447|       |  // as unknown fields.
  448|   126k|  uint16_t expectant_vtable_fields =
  449|   126k|      (vtable_size - sizeof(uint16_t) - sizeof(uint16_t)) / sizeof(uint16_t);
  450|       |
  451|       |  // Prevent a bad binary from declaring a really large vtable_size, that we can
  452|       |  // not independently verify.
  453|   126k|  expectant_vtable_fields = std::min(
  454|   126k|      static_cast<uint16_t>(fields_processed * 3), expectant_vtable_fields);
  455|       |
  456|   583k|  for (uint16_t id = fields_processed; id < expectant_vtable_fields; ++id) {
  ------------------
  |  Branch (456:40): [True: 457k, False: 126k]
  ------------------
  457|   457k|    const uint64_t field_offset = offset_start + id * sizeof(uint16_t);
  458|       |
  459|   457k|    const auto offset_from_table = ReadScalar<uint16_t>(field_offset);
  460|       |
  461|   457k|    BinaryRegionComment field_comment;
  462|   457k|    field_comment.type = BinaryRegionCommentType::VTableUnknownFieldOffset;
  463|   457k|    field_comment.index = id;
  464|       |
  465|   457k|    if (!offset_from_table.has_value()) {
  ------------------
  |  Branch (465:9): [True: 0, False: 457k]
  ------------------
  466|      0|      const uint64_t remaining = RemainingBytes(field_offset);
  467|      0|      SetError(field_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "2");
  468|      0|      regions.push_back(MakeBinaryRegion(field_offset, remaining,
  469|      0|                                         BinaryRegionType::Unknown, remaining,
  470|      0|                                         0, field_comment));
  471|      0|      continue;
  472|      0|    }
  473|       |
  474|   457k|    VTable::Entry entry;
  475|   457k|    entry.field = nullptr;  // No field to reference.
  476|   457k|    entry.offset_from_table = offset_from_table.value();
  477|   457k|    fields.insert(std::make_pair(id, entry));
  478|       |
  479|   457k|    regions.push_back(MakeBinaryRegion(field_offset, sizeof(uint16_t),
  480|   457k|                                       BinaryRegionType::VOffset, 0, 0,
  481|   457k|                                       field_comment));
  482|   457k|  }
  483|       |
  484|       |  // If we have never added this vtable before record the Binary section.
  485|   126k|  if (vtables.empty()) {
  ------------------
  |  Branch (485:7): [True: 122k, False: 3.22k]
  ------------------
  486|   122k|    sections_[vtable_offset] = MakeBinarySection(
  487|   122k|        referring_table_name, BinarySectionType::VTable, std::move(regions));
  488|   122k|  } else {
  489|       |    // Add the current table name to the name of the section.
  490|  3.22k|    sections_[vtable_offset].name += ", " + referring_table_name;
  491|  3.22k|  }
  492|       |
  493|   126k|  VTable vtable;
  494|   126k|  vtable.referring_table = table;
  495|   126k|  vtable.fields = std::move(fields);
  496|   126k|  vtable.table_size = table_size;
  497|   126k|  vtable.vtable_size = vtable_size;
  498|       |
  499|       |  // Add this vtable to the collection of vtables at this offset.
  500|   126k|  vtables.push_back(std::move(vtable));
  501|       |
  502|       |  // Return the vtable we just added.
  503|   126k|  return &vtables.back();
  504|   126k|}
_ZN11flatbuffers15BinaryAnnotator10BuildTableEmNS_17BinarySectionTypeEPKN10reflection6ObjectE:
  508|  5.97M|                                 const reflection::Object* const table) {
  509|  5.97M|  if (ContainsSection(table_offset)) {
  ------------------
  |  Branch (509:7): [True: 3.33M, False: 2.64M]
  ------------------
  510|  3.33M|    return;
  511|  3.33M|  }
  512|       |
  513|  2.64M|  BinaryRegionComment vtable_offset_comment;
  514|  2.64M|  vtable_offset_comment.type = BinaryRegionCommentType::TableVTableOffset;
  515|       |
  516|  2.64M|  const auto vtable_soffset = ReadScalar<int32_t>(table_offset);
  517|       |
  518|  2.64M|  if (!vtable_soffset.has_value()) {
  ------------------
  |  Branch (518:7): [True: 328, False: 2.64M]
  ------------------
  519|    328|    const uint64_t remaining = RemainingBytes(table_offset);
  520|    328|    SetError(vtable_offset_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY,
  521|    328|             "4");
  522|       |
  523|    328|    AddSection(
  524|    328|        table_offset,
  525|    328|        MakeSingleRegionBinarySection(
  526|    328|            table->name()->str(), type,
  527|    328|            MakeBinaryRegion(table_offset, remaining, BinaryRegionType::Unknown,
  528|    328|                             remaining, 0, vtable_offset_comment)));
  529|       |
  530|       |    // If there aren't enough bytes left to read the vtable offset, there is
  531|       |    // nothing we can do.
  532|    328|    return;
  533|    328|  }
  534|       |
  535|       |  // Tables start with the vtable
  536|  2.64M|  const uint64_t vtable_offset = table_offset - vtable_soffset.value();
  537|       |
  538|  2.64M|  if (!IsValidOffset(vtable_offset)) {
  ------------------
  |  Branch (538:7): [True: 296k, False: 2.34M]
  ------------------
  539|   296k|    SetError(vtable_offset_comment,
  540|   296k|             BinaryRegionStatus::ERROR_OFFSET_OUT_OF_BINARY);
  541|       |
  542|   296k|    AddSection(table_offset,
  543|   296k|               MakeSingleRegionBinarySection(
  544|   296k|                   table->name()->str(), type,
  545|   296k|                   MakeBinaryRegion(table_offset, sizeof(int32_t),
  546|   296k|                                    BinaryRegionType::SOffset, 0, vtable_offset,
  547|   296k|                                    vtable_offset_comment)));
  548|       |
  549|       |    // There isn't much to do with an invalid vtable offset, as we won't be able
  550|       |    // to intepret the rest of the table fields.
  551|   296k|    return;
  552|   296k|  }
  553|       |
  554|  2.34M|  std::vector<BinaryRegion> regions;
  555|  2.34M|  regions.push_back(MakeBinaryRegion(table_offset, sizeof(int32_t),
  556|  2.34M|                                     BinaryRegionType::SOffset, 0,
  557|  2.34M|                                     vtable_offset, vtable_offset_comment));
  558|       |
  559|       |  // Parse the vtable first so we know what the rest of the fields in the table
  560|       |  // are.
  561|  2.34M|  const VTable* const vtable =
  562|  2.34M|      GetOrBuildVTable(vtable_offset, table, table_offset);
  563|       |
  564|  2.34M|  if (vtable == nullptr) {
  ------------------
  |  Branch (564:7): [True: 2.21M, False: 133k]
  ------------------
  565|       |    // There is no valid vtable for this table, so we cannot process the rest of
  566|       |    // the table entries.
  567|  2.21M|    return;
  568|  2.21M|  }
  569|       |
  570|       |  // This is the size and length of this table.
  571|   133k|  const uint16_t table_size = vtable->table_size;
  572|   133k|  uint64_t table_end_offset = table_offset + table_size;
  573|       |
  574|   133k|  if (!IsValidOffset(table_end_offset - 1)) {
  ------------------
  |  Branch (574:7): [True: 7.22k, False: 125k]
  ------------------
  575|       |    // We already validated the table size in BuildVTable, but we have to make
  576|       |    // sure we don't use a bad value here.
  577|  7.22k|    table_end_offset = binary_length_;
  578|  7.22k|  }
  579|       |
  580|       |  // We need to iterate over the vtable fields by their offset in the binary,
  581|       |  // not by their IDs. So copy them over to another vector that we can sort on
  582|       |  // the offset_from_table property.
  583|   133k|  std::vector<VTable::Entry> fields;
  584|   785k|  for (const auto& vtable_field : vtable->fields) {
  ------------------
  |  Branch (584:33): [True: 785k, False: 133k]
  ------------------
  585|   785k|    fields.push_back(vtable_field.second);
  586|   785k|  }
  587|       |
  588|   133k|  std::stable_sort(fields.begin(), fields.end(),
  589|   133k|                   [](const VTable::Entry& a, const VTable::Entry& b) {
  590|   133k|                     return a.offset_from_table < b.offset_from_table;
  591|   133k|                   });
  592|       |
  593|       |  // Iterate over all the fields by order of their offset.
  594|   918k|  for (size_t i = 0; i < fields.size(); ++i) {
  ------------------
  |  Branch (594:22): [True: 785k, False: 133k]
  ------------------
  595|   785k|    const reflection::Field* field = fields[i].field;
  596|   785k|    const uint16_t offset_from_table = fields[i].offset_from_table;
  597|       |
  598|   785k|    if (offset_from_table == 0) {
  ------------------
  |  Branch (598:9): [True: 256k, False: 528k]
  ------------------
  599|       |      // Skip non-present fields.
  600|   256k|      continue;
  601|   256k|    }
  602|       |
  603|       |    // The field offsets are relative to the start of the table.
  604|   528k|    const uint64_t field_offset = table_offset + offset_from_table;
  605|       |
  606|   528k|    if (!IsValidOffset(field_offset)) {
  ------------------
  |  Branch (606:9): [True: 33.7k, False: 494k]
  ------------------
  607|       |      // The field offset is larger than the binary, nothing we can do.
  608|  33.7k|      continue;
  609|  33.7k|    }
  610|       |
  611|       |    // We have a vtable entry for a non-existant field, that means its a binary
  612|       |    // generated by a newer schema than we are currently processing.
  613|   494k|    if (field == nullptr) {
  ------------------
  |  Branch (613:9): [True: 280k, False: 214k]
  ------------------
  614|       |      // Calculate the length of this unknown field.
  615|   280k|      const uint64_t unknown_field_length =
  616|       |          // Check if there is another unknown field after this one.
  617|   280k|          ((i + 1 < fields.size())
  ------------------
  |  Branch (617:12): [True: 234k, False: 45.6k]
  ------------------
  618|   280k|               ? table_offset + fields[i + 1].offset_from_table
  619|       |               // Otherwise use the known end of the table.
  620|   280k|               : table_end_offset) -
  621|   280k|          field_offset;
  622|       |
  623|   280k|      if (unknown_field_length == 0) {
  ------------------
  |  Branch (623:11): [True: 75.8k, False: 204k]
  ------------------
  624|  75.8k|        continue;
  625|  75.8k|      }
  626|       |
  627|   204k|      std::string hint;
  628|       |
  629|   204k|      if (unknown_field_length == 4) {
  ------------------
  |  Branch (629:11): [True: 12.3k, False: 192k]
  ------------------
  630|  12.3k|        const auto relative_offset = ReadScalar<uint32_t>(field_offset);
  631|  12.3k|        if (relative_offset.has_value()) {
  ------------------
  |  Branch (631:13): [True: 12.3k, False: 31]
  ------------------
  632|       |          // The field is 4 in length, so it could be an offset? Provide a hint.
  633|  12.3k|          hint += "<possibly an offset? Check Loc: +0x";
  634|  12.3k|          hint += ToHex(field_offset + relative_offset.value());
  635|  12.3k|          hint += ">";
  636|  12.3k|        }
  637|  12.3k|      }
  638|       |
  639|   204k|      BinaryRegionComment unknown_field_comment;
  640|   204k|      unknown_field_comment.type = BinaryRegionCommentType::TableUnknownField;
  641|       |
  642|   204k|      if (!IsValidRead(field_offset, unknown_field_length)) {
  ------------------
  |  Branch (642:11): [True: 34.6k, False: 170k]
  ------------------
  643|  34.6k|        const uint64_t remaining = RemainingBytes(field_offset);
  644|       |
  645|  34.6k|        SetError(unknown_field_comment,
  646|  34.6k|                 BinaryRegionStatus::ERROR_INCOMPLETE_BINARY,
  647|  34.6k|                 std::to_string(unknown_field_length));
  648|       |
  649|  34.6k|        regions.push_back(MakeBinaryRegion(field_offset, remaining,
  650|  34.6k|                                           BinaryRegionType::Unknown, remaining,
  651|  34.6k|                                           0, unknown_field_comment));
  652|  34.6k|        continue;
  653|  34.6k|      }
  654|       |
  655|   170k|      unknown_field_comment.default_value = hint;
  656|       |
  657|   170k|      regions.push_back(MakeBinaryRegion(
  658|   170k|          field_offset, unknown_field_length, BinaryRegionType::Unknown,
  659|   170k|          unknown_field_length, 0, unknown_field_comment));
  660|   170k|      continue;
  661|   204k|    }
  662|       |
  663|   214k|    if (IsScalar(field->type()->base_type())) {
  ------------------
  |  Branch (663:9): [True: 129k, False: 85.2k]
  ------------------
  664|       |      // These are the raw values store in the table.
  665|   129k|      const uint64_t type_size = GetTypeSize(field->type()->base_type());
  666|   129k|      const BinaryRegionType region_type =
  667|   129k|          GetRegionType(field->type()->base_type());
  668|       |
  669|   129k|      BinaryRegionComment scalar_field_comment;
  670|   129k|      scalar_field_comment.type = BinaryRegionCommentType::TableField;
  671|   129k|      scalar_field_comment.name =
  672|   129k|          std::string(field->name()->c_str()) + "` (" +
  673|   129k|          reflection::EnumNameBaseType(field->type()->base_type()) + ")";
  674|       |
  675|   129k|      if (!IsValidRead(field_offset, type_size)) {
  ------------------
  |  Branch (675:11): [True: 413, False: 128k]
  ------------------
  676|    413|        const uint64_t remaining = RemainingBytes(field_offset);
  677|    413|        SetError(scalar_field_comment,
  678|    413|                 BinaryRegionStatus::ERROR_INCOMPLETE_BINARY,
  679|    413|                 std::to_string(type_size));
  680|       |
  681|    413|        regions.push_back(MakeBinaryRegion(field_offset, remaining,
  682|    413|                                           BinaryRegionType::Unknown, remaining,
  683|    413|                                           0, scalar_field_comment));
  684|    413|        continue;
  685|    413|      }
  686|       |
  687|   128k|      if (IsUnionType(field)) {
  ------------------
  |  Branch (687:11): [True: 1.96k, False: 126k]
  ------------------
  688|       |        // This is a type for a union. Validate the value
  689|  1.96k|        const auto enum_value = ReadScalar<uint8_t>(field_offset);
  690|       |
  691|       |        // This should always have a value, due to the IsValidRead check above.
  692|  1.96k|        if (!IsValidUnionValue(field, enum_value.value())) {
  ------------------
  |  Branch (692:13): [True: 888, False: 1.07k]
  ------------------
  693|    888|          SetError(scalar_field_comment,
  694|    888|                   BinaryRegionStatus::ERROR_INVALID_UNION_TYPE);
  695|       |
  696|    888|          regions.push_back(MakeBinaryRegion(field_offset, type_size,
  697|    888|                                             region_type, 0, 0,
  698|    888|                                             scalar_field_comment));
  699|    888|          continue;
  700|    888|        }
  701|  1.96k|      }
  702|       |
  703|   127k|      regions.push_back(MakeBinaryRegion(field_offset, type_size, region_type,
  704|   127k|                                         0, 0, scalar_field_comment));
  705|   127k|      continue;
  706|   128k|    }
  707|       |
  708|       |    // Read the offset
  709|  85.2k|    uint64_t offset = 0;
  710|  85.2k|    uint64_t length = sizeof(uint32_t);
  711|  85.2k|    BinaryRegionType region_type = BinaryRegionType::UOffset;
  712|       |
  713|  85.2k|    if (field->offset64()) {
  ------------------
  |  Branch (713:9): [True: 0, False: 85.2k]
  ------------------
  714|      0|      length = sizeof(uint64_t);
  715|      0|      region_type = BinaryRegionType::UOffset64;
  716|      0|      offset = ReadScalar<uint64_t>(field_offset).value_or(0);
  717|  85.2k|    } else {
  718|  85.2k|      offset = ReadScalar<uint32_t>(field_offset).value_or(0);
  719|  85.2k|    }
  720|       |    // const auto offset_from_field = ReadScalar<uint32_t>(field_offset);
  721|  85.2k|    uint64_t offset_of_next_item = 0;
  722|  85.2k|    BinaryRegionComment offset_field_comment;
  723|  85.2k|    offset_field_comment.type = BinaryRegionCommentType::TableOffsetField;
  724|  85.2k|    offset_field_comment.name = field->name()->c_str();
  725|  85.2k|    const std::string offset_prefix =
  726|  85.2k|        "offset to field `" + std::string(field->name()->c_str()) + "`";
  727|       |
  728|       |    // Validate any field that isn't inline (i.e., non-structs).
  729|  85.2k|    if (!IsInlineField(field)) {
  ------------------
  |  Branch (729:9): [True: 83.9k, False: 1.28k]
  ------------------
  730|  83.9k|      if (offset == 0) {
  ------------------
  |  Branch (730:11): [True: 12.3k, False: 71.6k]
  ------------------
  731|  12.3k|        const uint64_t remaining = RemainingBytes(field_offset);
  732|       |
  733|  12.3k|        SetError(offset_field_comment,
  734|  12.3k|                 BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "4");
  735|       |
  736|  12.3k|        regions.push_back(MakeBinaryRegion(field_offset, remaining,
  737|  12.3k|                                           BinaryRegionType::Unknown, remaining,
  738|  12.3k|                                           0, offset_field_comment));
  739|  12.3k|        continue;
  740|  12.3k|      }
  741|       |
  742|  71.6k|      offset_of_next_item = field_offset + offset;
  743|       |
  744|  71.6k|      if (!IsValidOffset(offset_of_next_item)) {
  ------------------
  |  Branch (744:11): [True: 40.1k, False: 31.4k]
  ------------------
  745|  40.1k|        SetError(offset_field_comment,
  746|  40.1k|                 BinaryRegionStatus::ERROR_OFFSET_OUT_OF_BINARY);
  747|  40.1k|        regions.push_back(MakeBinaryRegion(field_offset, length, region_type, 0,
  748|  40.1k|                                           offset_of_next_item,
  749|  40.1k|                                           offset_field_comment));
  750|  40.1k|        continue;
  751|  40.1k|      }
  752|  71.6k|    }
  753|       |
  754|  32.7k|    switch (field->type()->base_type()) {
  755|  27.1k|      case reflection::BaseType::Obj: {
  ------------------
  |  Branch (755:7): [True: 27.1k, False: 5.59k]
  ------------------
  756|  27.1k|        const reflection::Object* next_object =
  757|  27.1k|            schema_->objects()->Get(field->type()->index());
  758|       |
  759|  27.1k|        if (next_object->is_struct()) {
  ------------------
  |  Branch (759:13): [True: 1.28k, False: 25.8k]
  ------------------
  760|       |          // Structs are stored inline.
  761|  1.28k|          BuildStruct(field_offset, regions, field->name()->c_str(),
  762|  1.28k|                      next_object);
  763|  25.8k|        } else {
  764|  25.8k|          offset_field_comment.default_value = "(table)";
  765|       |
  766|  25.8k|          regions.push_back(MakeBinaryRegion(field_offset, length, region_type,
  767|  25.8k|                                             0, offset_of_next_item,
  768|  25.8k|                                             offset_field_comment));
  769|       |
  770|  25.8k|          BuildTable(offset_of_next_item, BinarySectionType::Table,
  771|  25.8k|                     next_object);
  772|  25.8k|        }
  773|  27.1k|      } break;
  774|       |
  775|    932|      case reflection::BaseType::String: {
  ------------------
  |  Branch (775:7): [True: 932, False: 31.7k]
  ------------------
  776|    932|        offset_field_comment.default_value = "(string)";
  777|    932|        regions.push_back(MakeBinaryRegion(field_offset, length, region_type, 0,
  778|    932|                                           offset_of_next_item,
  779|    932|                                           offset_field_comment));
  780|    932|        BuildString(offset_of_next_item, table, field);
  781|    932|      } break;
  782|       |
  783|  3.84k|      case reflection::BaseType::Vector: {
  ------------------
  |  Branch (783:7): [True: 3.84k, False: 28.8k]
  ------------------
  784|  3.84k|        offset_field_comment.default_value = "(vector)";
  785|  3.84k|        regions.push_back(MakeBinaryRegion(field_offset, length, region_type, 0,
  786|  3.84k|                                           offset_of_next_item,
  787|  3.84k|                                           offset_field_comment));
  788|  3.84k|        BuildVector(offset_of_next_item, table, field, table_offset,
  789|  3.84k|                    vtable->fields);
  790|  3.84k|      } break;
  791|      0|      case reflection::BaseType::Vector64: {
  ------------------
  |  Branch (791:7): [True: 0, False: 32.7k]
  ------------------
  792|      0|        offset_field_comment.default_value = "(vector64)";
  793|      0|        regions.push_back(MakeBinaryRegion(field_offset, length, region_type, 0,
  794|      0|                                           offset_of_next_item,
  795|      0|                                           offset_field_comment));
  796|      0|        BuildVector(offset_of_next_item, table, field, table_offset,
  797|      0|                    vtable->fields);
  798|      0|      } break;
  799|       |
  800|    824|      case reflection::BaseType::Union: {
  ------------------
  |  Branch (800:7): [True: 824, False: 31.8k]
  ------------------
  801|    824|        const uint64_t union_offset = offset_of_next_item;
  802|       |
  803|       |        // The union type field is always one less than the union itself.
  804|    824|        const uint16_t union_type_id = field->id() - 1;
  805|       |
  806|    824|        auto vtable_field = vtable->fields.find(union_type_id);
  807|    824|        if (vtable_field == vtable->fields.end()) {
  ------------------
  |  Branch (807:13): [True: 52, False: 772]
  ------------------
  808|       |          // TODO(dbaileychess): need to capture this error condition.
  809|     52|          break;
  810|     52|        }
  811|    772|        offset_field_comment.default_value = "(union)";
  812|       |
  813|    772|        const uint64_t type_offset =
  814|    772|            table_offset + vtable_field->second.offset_from_table;
  815|       |
  816|    772|        const auto realized_type = ReadScalar<uint8_t>(type_offset);
  817|    772|        if (!realized_type.has_value()) {
  ------------------
  |  Branch (817:13): [True: 153, False: 619]
  ------------------
  818|    153|          const uint64_t remaining = RemainingBytes(type_offset);
  819|    153|          SetError(offset_field_comment,
  820|    153|                   BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "1");
  821|    153|          regions.push_back(MakeBinaryRegion(
  822|    153|              type_offset, remaining, BinaryRegionType::Unknown, remaining, 0,
  823|    153|              offset_field_comment));
  824|    153|          continue;
  825|    153|        }
  826|       |
  827|    619|        if (!IsValidUnionValue(field, realized_type.value())) {
  ------------------
  |  Branch (827:13): [True: 286, False: 333]
  ------------------
  828|       |          // We already export an error in the union type field, so just skip
  829|       |          // building the union itself and it will default to an unreference
  830|       |          // Binary section.
  831|    286|          continue;
  832|    286|        }
  833|       |
  834|    333|        const std::string enum_type =
  835|    333|            BuildUnion(union_offset, realized_type.value(), field);
  836|       |
  837|    333|        offset_field_comment.default_value =
  838|    333|            "(union of type `" + enum_type + "`)";
  839|       |
  840|    333|        regions.push_back(MakeBinaryRegion(field_offset, length, region_type, 0,
  841|    333|                                           union_offset, offset_field_comment));
  842|       |
  843|    333|      } break;
  844|       |
  845|      0|      default:
  ------------------
  |  Branch (845:7): [True: 0, False: 32.7k]
  ------------------
  846|      0|        break;
  847|  32.7k|    }
  848|  32.7k|  }
  849|       |
  850|       |  // Handle the case where there is padding after the last known binary
  851|       |  // region. Calculate where we left off towards the expected end of the
  852|       |  // table.
  853|   133k|  const uint64_t i = regions.back().offset + regions.back().length + 1;
  854|       |
  855|   133k|  if (i < table_end_offset) {
  ------------------
  |  Branch (855:7): [True: 15.7k, False: 117k]
  ------------------
  856|  15.7k|    const uint64_t pad_bytes = table_end_offset - i + 1;
  857|       |
  858|  15.7k|    BinaryRegionComment padding_comment;
  859|  15.7k|    padding_comment.type = BinaryRegionCommentType::Padding;
  860|       |
  861|  15.7k|    regions.push_back(MakeBinaryRegion(i - 1, pad_bytes * sizeof(uint8_t),
  862|  15.7k|                                       BinaryRegionType::Uint8, pad_bytes, 0,
  863|  15.7k|                                       padding_comment));
  864|  15.7k|  }
  865|       |
  866|   133k|  AddSection(table_offset,
  867|   133k|             MakeBinarySection(table->name()->str(), type, std::move(regions)));
  868|   133k|}
_ZN11flatbuffers15BinaryAnnotator11BuildStructEmRNSt3__16vectorINS_12BinaryRegionENS1_9allocatorIS3_EEEENS1_12basic_stringIcNS1_11char_traitsIcEENS4_IcEEEEPKN10reflection6ObjectE:
  873|   147k|                                      const reflection::Object* const object) {
  874|   147k|  if (!object->is_struct()) {
  ------------------
  |  Branch (874:7): [True: 0, False: 147k]
  ------------------
  875|      0|    return struct_offset;
  876|      0|  }
  877|   147k|  uint64_t offset = struct_offset;
  878|       |
  879|       |  // Loop over all the fields in increasing order
  880|   147k|  ForAllFields(object, /*reverse=*/false, [&](const reflection::Field* field) {
  881|   147k|    if (IsScalar(field->type()->base_type())) {
  882|       |      // Structure Field value
  883|   147k|      const uint64_t type_size = GetTypeSize(field->type()->base_type());
  884|   147k|      const BinaryRegionType region_type =
  885|   147k|          GetRegionType(field->type()->base_type());
  886|       |
  887|   147k|      BinaryRegionComment comment;
  888|   147k|      comment.type = BinaryRegionCommentType::StructField;
  889|   147k|      comment.name = referring_field_name + "." + field->name()->str();
  890|   147k|      comment.default_value = "of '" + object->name()->str() + "' (" +
  891|   147k|                              std::string(reflection::EnumNameBaseType(
  892|   147k|                                  field->type()->base_type())) +
  893|   147k|                              ")";
  894|       |
  895|   147k|      if (!IsValidRead(offset, type_size)) {
  896|   147k|        const uint64_t remaining = RemainingBytes(offset);
  897|   147k|        SetError(comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY,
  898|   147k|                 std::to_string(type_size));
  899|   147k|        regions.push_back(MakeBinaryRegion(offset, remaining,
  900|   147k|                                           BinaryRegionType::Unknown, remaining,
  901|   147k|                                           0, comment));
  902|       |
  903|       |        // TODO(dbaileychess): Should I bail out here? This sets offset to the
  904|       |        // end of the binary. So all other reads in the loop should fail.
  905|   147k|        offset += remaining;
  906|   147k|        return;
  907|   147k|      }
  908|       |
  909|   147k|      regions.push_back(
  910|   147k|          MakeBinaryRegion(offset, type_size, region_type, 0, 0, comment));
  911|   147k|      offset += type_size;
  912|   147k|    } else if (field->type()->base_type() == reflection::BaseType::Obj) {
  913|       |      // Structs are stored inline, even when nested.
  914|   147k|      offset = BuildStruct(offset, regions,
  915|   147k|                           referring_field_name + "." + field->name()->str(),
  916|   147k|                           schema_->objects()->Get(field->type()->index()));
  917|   147k|    } else if (field->type()->base_type() == reflection::BaseType::Array) {
  918|   147k|      const bool is_scalar = IsScalar(field->type()->element());
  919|   147k|      const uint64_t type_size = GetTypeSize(field->type()->element());
  920|   147k|      const BinaryRegionType region_type =
  921|   147k|          GetRegionType(field->type()->element());
  922|       |
  923|       |      // Arrays are just repeated structures.
  924|   147k|      for (uint16_t i = 0; i < field->type()->fixed_length(); ++i) {
  925|   147k|        if (is_scalar) {
  926|   147k|          BinaryRegionComment array_comment;
  927|   147k|          array_comment.type = BinaryRegionCommentType::ArrayField;
  928|   147k|          array_comment.name =
  929|   147k|              referring_field_name + "." + field->name()->str();
  930|   147k|          array_comment.index = i;
  931|   147k|          array_comment.default_value =
  932|   147k|              "of '" + object->name()->str() + "' (" +
  933|   147k|              std::string(
  934|   147k|                  reflection::EnumNameBaseType(field->type()->element())) +
  935|   147k|              ")";
  936|       |
  937|   147k|          if (!IsValidRead(offset, type_size)) {
  938|   147k|            const uint64_t remaining = RemainingBytes(offset);
  939|       |
  940|   147k|            SetError(array_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY,
  941|   147k|                     std::to_string(type_size));
  942|       |
  943|   147k|            regions.push_back(MakeBinaryRegion(offset, remaining,
  944|   147k|                                               BinaryRegionType::Unknown,
  945|   147k|                                               remaining, 0, array_comment));
  946|       |
  947|       |            // TODO(dbaileychess): Should I bail out here? This sets offset to
  948|       |            // the end of the binary. So all other reads in the loop should
  949|       |            // fail.
  950|   147k|            offset += remaining;
  951|   147k|            break;
  952|   147k|          }
  953|       |
  954|   147k|          regions.push_back(MakeBinaryRegion(offset, type_size, region_type, 0,
  955|   147k|                                             0, array_comment));
  956|       |
  957|   147k|          offset += type_size;
  958|   147k|        } else {
  959|       |          // Array of Structs.
  960|       |          //
  961|       |          // TODO(dbaileychess): This works, but the comments on the fields lose
  962|       |          // some context. Need to figure a way how to plumb the nested arrays
  963|       |          // comments together that isn't too confusing.
  964|   147k|          offset =
  965|   147k|              BuildStruct(offset, regions,
  966|   147k|                          referring_field_name + "." + field->name()->str(),
  967|   147k|                          schema_->objects()->Get(field->type()->index()));
  968|   147k|        }
  969|   147k|      }
  970|   147k|    }
  971|       |
  972|       |    // Insert any padding after this field.
  973|   147k|    const uint16_t padding = field->padding();
  974|   147k|    if (padding > 0 && IsValidOffset(offset + padding)) {
  975|   147k|      BinaryRegionComment padding_comment;
  976|   147k|      padding_comment.type = BinaryRegionCommentType::Padding;
  977|       |
  978|   147k|      regions.push_back(MakeBinaryRegion(offset, padding,
  979|   147k|                                         BinaryRegionType::Uint8, padding, 0,
  980|   147k|                                         padding_comment));
  981|   147k|      offset += padding;
  982|   147k|    }
  983|   147k|  });
  984|       |
  985|   147k|  return offset;
  986|   147k|}
_ZN11flatbuffers15BinaryAnnotator11BuildStringEmPKN10reflection6ObjectEPKNS1_5FieldE:
  990|  1.21M|                                  const reflection::Field* const field) {
  991|       |  // Check if we have already generated this string section, and this is a
  992|       |  // shared string instance.
  993|  1.21M|  if (ContainsSection(string_offset)) {
  ------------------
  |  Branch (993:7): [True: 1.00M, False: 217k]
  ------------------
  994|  1.00M|    return;
  995|  1.00M|  }
  996|       |
  997|   217k|  std::vector<BinaryRegion> regions;
  998|   217k|  const auto string_length = ReadScalar<uint32_t>(string_offset);
  999|       |
 1000|   217k|  BinaryRegionComment string_length_comment;
 1001|   217k|  string_length_comment.type = BinaryRegionCommentType::StringLength;
 1002|       |
 1003|   217k|  if (!string_length.has_value()) {
  ------------------
  |  Branch (1003:7): [True: 194, False: 217k]
  ------------------
 1004|    194|    const uint64_t remaining = RemainingBytes(string_offset);
 1005|       |
 1006|    194|    SetError(string_length_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY,
 1007|    194|             "4");
 1008|       |
 1009|    194|    regions.push_back(MakeBinaryRegion(string_offset, remaining,
 1010|    194|                                       BinaryRegionType::Unknown, remaining, 0,
 1011|    194|                                       string_length_comment));
 1012|       |
 1013|   217k|  } else {
 1014|   217k|    const uint32_t string_size = string_length.value();
 1015|   217k|    const uint64_t string_end =
 1016|   217k|        string_offset + sizeof(uint32_t) + string_size + sizeof(char);
 1017|       |
 1018|   217k|    if (!IsValidOffset(string_end - 1)) {
  ------------------
  |  Branch (1018:9): [True: 60.4k, False: 157k]
  ------------------
 1019|  60.4k|      SetError(string_length_comment,
 1020|  60.4k|               BinaryRegionStatus::ERROR_LENGTH_TOO_LONG);
 1021|       |
 1022|  60.4k|      regions.push_back(MakeBinaryRegion(string_offset, sizeof(uint32_t),
 1023|  60.4k|                                         BinaryRegionType::Uint32, 0, 0,
 1024|  60.4k|                                         string_length_comment));
 1025|   157k|    } else {
 1026|   157k|      regions.push_back(MakeBinaryRegion(string_offset, sizeof(uint32_t),
 1027|   157k|                                         BinaryRegionType::Uint32, 0, 0,
 1028|   157k|                                         string_length_comment));
 1029|       |
 1030|   157k|      BinaryRegionComment string_comment;
 1031|   157k|      string_comment.type = BinaryRegionCommentType::StringValue;
 1032|       |
 1033|   157k|      regions.push_back(MakeBinaryRegion(string_offset + sizeof(uint32_t),
 1034|   157k|                                         string_size, BinaryRegionType::Char,
 1035|   157k|                                         string_size, 0, string_comment));
 1036|       |
 1037|   157k|      BinaryRegionComment string_terminator_comment;
 1038|   157k|      string_terminator_comment.type =
 1039|   157k|          BinaryRegionCommentType::StringTerminator;
 1040|       |
 1041|   157k|      regions.push_back(MakeBinaryRegion(
 1042|   157k|          string_offset + sizeof(uint32_t) + string_size, sizeof(char),
 1043|   157k|          BinaryRegionType::Char, 0, 0, string_terminator_comment));
 1044|   157k|    }
 1045|   217k|  }
 1046|       |
 1047|   217k|  AddSection(string_offset,
 1048|   217k|             MakeBinarySection(std::string(table->name()->c_str()) + "." +
 1049|   217k|                                   field->name()->c_str(),
 1050|   217k|                               BinarySectionType::String, std::move(regions)));
 1051|   217k|}
_ZN11flatbuffers15BinaryAnnotator11BuildVectorEmPKN10reflection6ObjectEPKNS1_5FieldEmNSt3__13mapItNS0_6VTable5EntryENS8_4lessItEENS8_9allocatorINS8_4pairIKtSB_EEEEEE:
 1056|  3.84k|    const std::map<uint16_t, VTable::Entry> vtable_fields) {
 1057|  3.84k|  if (ContainsSection(vector_offset)) {
  ------------------
  |  Branch (1057:7): [True: 741, False: 3.10k]
  ------------------
 1058|    741|    return;
 1059|    741|  }
 1060|       |
 1061|  3.10k|  BinaryRegionComment vector_length_comment;
 1062|  3.10k|  vector_length_comment.type = BinaryRegionCommentType::VectorLength;
 1063|       |
 1064|  3.10k|  const bool is_64_bit_vector =
 1065|  3.10k|      field->type()->base_type() == reflection::BaseType::Vector64;
 1066|       |
 1067|  3.10k|  flatbuffers::Optional<uint64_t> vector_length;
 1068|  3.10k|  uint32_t vector_length_size_type = 0;
 1069|  3.10k|  BinaryRegionType region_type = BinaryRegionType::Uint32;
 1070|  3.10k|  BinarySectionType section_type = BinarySectionType::Vector;
 1071|       |
 1072|  3.10k|  if (is_64_bit_vector) {
  ------------------
  |  Branch (1072:7): [True: 0, False: 3.10k]
  ------------------
 1073|      0|    auto v = ReadScalar<uint64_t>(vector_offset);
 1074|      0|    if (v.has_value()) {
  ------------------
  |  Branch (1074:9): [True: 0, False: 0]
  ------------------
 1075|      0|      vector_length = v.value();
 1076|      0|    }
 1077|      0|    vector_length_size_type = sizeof(uint64_t);
 1078|      0|    region_type = BinaryRegionType::Uint64;
 1079|      0|    section_type = BinarySectionType::Vector64;
 1080|  3.10k|  } else {
 1081|  3.10k|    auto v = ReadScalar<uint32_t>(vector_offset);
 1082|  3.10k|    if (v.has_value()) {
  ------------------
  |  Branch (1082:9): [True: 2.96k, False: 135]
  ------------------
 1083|  2.96k|      vector_length = v.value();
 1084|  2.96k|    }
 1085|  3.10k|    vector_length_size_type = sizeof(uint32_t);
 1086|  3.10k|    region_type = BinaryRegionType::Uint32;
 1087|  3.10k|    section_type = BinarySectionType::Vector;
 1088|  3.10k|  }
 1089|       |
 1090|  3.10k|  if (!vector_length.has_value()) {
  ------------------
  |  Branch (1090:7): [True: 135, False: 2.96k]
  ------------------
 1091|    135|    const uint64_t remaining = RemainingBytes(vector_offset);
 1092|    135|    SetError(vector_length_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY,
 1093|    135|             "4");
 1094|       |
 1095|    135|    AddSection(
 1096|    135|        vector_offset,
 1097|    135|        MakeSingleRegionBinarySection(
 1098|    135|            std::string(table->name()->c_str()) + "." + field->name()->c_str(),
 1099|    135|            BinarySectionType::Vector,
 1100|    135|            MakeBinaryRegion(vector_offset, remaining,
 1101|    135|                             BinaryRegionType::Unknown, remaining, 0,
 1102|    135|                             vector_length_comment)));
 1103|    135|    return;
 1104|    135|  }
 1105|       |
 1106|       |  // Validate there are enough bytes left in the binary to process all the
 1107|       |  // items.
 1108|  2.96k|  const uint64_t last_item_offset =
 1109|  2.96k|      vector_offset + vector_length_size_type +
 1110|  2.96k|      vector_length.value() * GetElementSize(field);
 1111|       |
 1112|  2.96k|  if (!IsValidOffset(last_item_offset - 1)) {
  ------------------
  |  Branch (1112:7): [True: 472, False: 2.49k]
  ------------------
 1113|    472|    SetError(vector_length_comment, BinaryRegionStatus::ERROR_LENGTH_TOO_LONG);
 1114|    472|    AddSection(
 1115|    472|        vector_offset,
 1116|    472|        MakeSingleRegionBinarySection(
 1117|    472|            std::string(table->name()->c_str()) + "." + field->name()->c_str(),
 1118|    472|            BinarySectionType::Vector,
 1119|    472|            MakeBinaryRegion(vector_offset, vector_length_size_type,
 1120|    472|                             region_type, 0, 0, vector_length_comment)));
 1121|       |
 1122|    472|    return;
 1123|    472|  }
 1124|       |
 1125|  2.49k|  std::vector<BinaryRegion> regions;
 1126|       |
 1127|  2.49k|  regions.push_back(MakeBinaryRegion(vector_offset, vector_length_size_type,
 1128|  2.49k|                                     region_type, 0, 0, vector_length_comment));
 1129|       |  // Consume the vector length offset.
 1130|  2.49k|  uint64_t offset = vector_offset + vector_length_size_type;
 1131|       |
 1132|  2.49k|  switch (field->type()->element()) {
 1133|  1.26k|    case reflection::BaseType::Obj: {
  ------------------
  |  Branch (1133:5): [True: 1.26k, False: 1.22k]
  ------------------
 1134|  1.26k|      const reflection::Object* object =
 1135|  1.26k|          schema_->objects()->Get(field->type()->index());
 1136|       |
 1137|  1.26k|      if (object->is_struct()) {
  ------------------
  |  Branch (1137:11): [True: 104, False: 1.16k]
  ------------------
 1138|       |        // Vector of structs
 1139|   141k|        for (size_t i = 0; i < vector_length.value(); ++i) {
  ------------------
  |  Branch (1139:28): [True: 141k, False: 104]
  ------------------
 1140|       |          // Structs are inline to the vector.
 1141|   141k|          const uint64_t next_offset =
 1142|   141k|              BuildStruct(offset, regions, "[" + NumToString(i) + "]", object);
 1143|   141k|          if (next_offset == offset) {
  ------------------
  |  Branch (1143:15): [True: 0, False: 141k]
  ------------------
 1144|      0|            break;
 1145|      0|          }
 1146|   141k|          offset = next_offset;
 1147|   141k|        }
 1148|  1.16k|      } else {
 1149|       |        // Vector of objects
 1150|  10.9M|        for (size_t i = 0; i < vector_length.value(); ++i) {
  ------------------
  |  Branch (1150:28): [True: 10.9M, False: 1.16k]
  ------------------
 1151|  10.9M|          BinaryRegionComment vector_object_comment;
 1152|  10.9M|          vector_object_comment.type =
 1153|  10.9M|              BinaryRegionCommentType::VectorTableValue;
 1154|  10.9M|          vector_object_comment.index = i;
 1155|       |
 1156|  10.9M|          const auto table_relative_offset = ReadScalar<uint32_t>(offset);
 1157|  10.9M|          if (!table_relative_offset.has_value()) {
  ------------------
  |  Branch (1157:15): [True: 0, False: 10.9M]
  ------------------
 1158|      0|            const uint64_t remaining = RemainingBytes(offset);
 1159|      0|            SetError(vector_object_comment,
 1160|      0|                     BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "4");
 1161|       |
 1162|      0|            regions.push_back(
 1163|      0|                MakeBinaryRegion(offset, remaining, BinaryRegionType::Unknown,
 1164|      0|                                 remaining, 0, vector_object_comment));
 1165|      0|            break;
 1166|      0|          }
 1167|       |
 1168|       |          // The table offset is relative from the offset location itself.
 1169|  10.9M|          const uint64_t table_offset = offset + table_relative_offset.value();
 1170|       |
 1171|  10.9M|          if (!IsValidOffset(table_offset)) {
  ------------------
  |  Branch (1171:15): [True: 5.01M, False: 5.94M]
  ------------------
 1172|  5.01M|            SetError(vector_object_comment,
 1173|  5.01M|                     BinaryRegionStatus::ERROR_OFFSET_OUT_OF_BINARY);
 1174|  5.01M|            regions.push_back(MakeBinaryRegion(
 1175|  5.01M|                offset, sizeof(uint32_t), BinaryRegionType::UOffset, 0,
 1176|  5.01M|                table_offset, vector_object_comment));
 1177|       |
 1178|  5.01M|            offset += sizeof(uint32_t);
 1179|  5.01M|            continue;
 1180|  5.01M|          }
 1181|       |
 1182|  5.94M|          if (table_offset == parent_table_offset) {
  ------------------
  |  Branch (1182:15): [True: 0, False: 5.94M]
  ------------------
 1183|      0|            SetError(vector_object_comment,
 1184|      0|                     BinaryRegionStatus::ERROR_CYCLE_DETECTED);
 1185|       |            // A cycle detected where a table vector field is pointing to
 1186|       |            // itself. This should only happen in corrupted files.
 1187|      0|            regions.push_back(MakeBinaryRegion(
 1188|      0|                offset, sizeof(uint32_t), BinaryRegionType::UOffset, 0,
 1189|      0|                table_offset, vector_object_comment));
 1190|       |
 1191|      0|            offset += sizeof(uint32_t);
 1192|      0|            continue;
 1193|      0|          }
 1194|       |
 1195|  5.94M|          regions.push_back(MakeBinaryRegion(
 1196|  5.94M|              offset, sizeof(uint32_t), BinaryRegionType::UOffset, 0,
 1197|  5.94M|              table_offset, vector_object_comment));
 1198|       |
 1199|       |          // Consume the offset to the table.
 1200|  5.94M|          offset += sizeof(uint32_t);
 1201|       |
 1202|  5.94M|          BuildTable(table_offset, BinarySectionType::Table, object);
 1203|  5.94M|        }
 1204|  1.16k|      }
 1205|  1.26k|    } break;
 1206|    368|    case reflection::BaseType::String: {
  ------------------
  |  Branch (1206:5): [True: 368, False: 2.12k]
  ------------------
 1207|       |      // Vector of strings
 1208|  2.44M|      for (size_t i = 0; i < vector_length.value(); ++i) {
  ------------------
  |  Branch (1208:26): [True: 2.44M, False: 368]
  ------------------
 1209|  2.44M|        BinaryRegionComment vector_object_comment;
 1210|  2.44M|        vector_object_comment.type = BinaryRegionCommentType::VectorStringValue;
 1211|  2.44M|        vector_object_comment.index = i;
 1212|       |
 1213|  2.44M|        const auto string_relative_offset = ReadScalar<uint32_t>(offset);
 1214|  2.44M|        if (!string_relative_offset.has_value()) {
  ------------------
  |  Branch (1214:13): [True: 0, False: 2.44M]
  ------------------
 1215|      0|          const uint64_t remaining = RemainingBytes(offset);
 1216|       |
 1217|      0|          SetError(vector_object_comment,
 1218|      0|                   BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "4");
 1219|       |
 1220|      0|          regions.push_back(
 1221|      0|              MakeBinaryRegion(offset, remaining, BinaryRegionType::Unknown,
 1222|      0|                               remaining, 0, vector_object_comment));
 1223|      0|          break;
 1224|      0|        }
 1225|       |
 1226|       |        // The string offset is relative from the offset location itself.
 1227|  2.44M|        const uint64_t string_offset = offset + string_relative_offset.value();
 1228|       |
 1229|  2.44M|        if (!IsValidOffset(string_offset)) {
  ------------------
  |  Branch (1229:13): [True: 1.22M, False: 1.21M]
  ------------------
 1230|  1.22M|          SetError(vector_object_comment,
 1231|  1.22M|                   BinaryRegionStatus::ERROR_OFFSET_OUT_OF_BINARY);
 1232|  1.22M|          regions.push_back(MakeBinaryRegion(
 1233|  1.22M|              offset, sizeof(uint32_t), BinaryRegionType::UOffset, 0,
 1234|  1.22M|              string_offset, vector_object_comment));
 1235|       |
 1236|  1.22M|          offset += sizeof(uint32_t);
 1237|  1.22M|          continue;
 1238|  1.22M|        }
 1239|       |
 1240|  1.21M|        regions.push_back(MakeBinaryRegion(
 1241|  1.21M|            offset, sizeof(uint32_t), BinaryRegionType::UOffset, 0,
 1242|  1.21M|            string_offset, vector_object_comment));
 1243|       |
 1244|  1.21M|        BuildString(string_offset, table, field);
 1245|       |
 1246|  1.21M|        offset += sizeof(uint32_t);
 1247|  1.21M|      }
 1248|    368|    } break;
 1249|    592|    case reflection::BaseType::Union: {
  ------------------
  |  Branch (1249:5): [True: 592, False: 1.90k]
  ------------------
 1250|       |      // Vector of unions
 1251|       |      // Unions have both their realized type (uint8_t for now) that are
 1252|       |      // stored separately. These are stored in the field->index() - 1
 1253|       |      // location.
 1254|    592|      const uint16_t union_type_vector_id = field->id() - 1;
 1255|       |
 1256|    592|      auto vtable_entry = vtable_fields.find(union_type_vector_id);
 1257|    592|      if (vtable_entry == vtable_fields.end()) {
  ------------------
  |  Branch (1257:11): [True: 4, False: 588]
  ------------------
 1258|       |        // TODO(dbaileychess): need to capture this error condition.
 1259|      4|        break;
 1260|      4|      }
 1261|       |
 1262|    588|      const uint64_t union_type_vector_field_offset =
 1263|    588|          parent_table_offset + vtable_entry->second.offset_from_table;
 1264|       |
 1265|    588|      const auto union_type_vector_field_relative_offset =
 1266|    588|          ReadScalar<uint16_t>(union_type_vector_field_offset);
 1267|       |
 1268|    588|      if (!union_type_vector_field_relative_offset.has_value()) {
  ------------------
  |  Branch (1268:11): [True: 43, False: 545]
  ------------------
 1269|     43|        const uint64_t remaining = RemainingBytes(offset);
 1270|     43|        BinaryRegionComment vector_union_comment;
 1271|     43|        vector_union_comment.type = BinaryRegionCommentType::VectorUnionValue;
 1272|     43|        SetError(vector_union_comment,
 1273|     43|                 BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "2");
 1274|       |
 1275|     43|        regions.push_back(MakeBinaryRegion(offset, remaining,
 1276|     43|                                           BinaryRegionType::Unknown, remaining,
 1277|     43|                                           0, vector_union_comment));
 1278|       |
 1279|     43|        break;
 1280|     43|      }
 1281|       |
 1282|       |      // Get the offset to the first type (the + sizeof(uint32_t) is to skip
 1283|       |      // over the vector length which we already know). Validation happens
 1284|       |      // within the loop below.
 1285|    545|      const uint64_t union_type_vector_data_offset =
 1286|    545|          union_type_vector_field_offset +
 1287|    545|          union_type_vector_field_relative_offset.value() + sizeof(uint32_t);
 1288|       |
 1289|  3.87M|      for (size_t i = 0; i < vector_length.value(); ++i) {
  ------------------
  |  Branch (1289:26): [True: 3.87M, False: 545]
  ------------------
 1290|  3.87M|        BinaryRegionComment comment;
 1291|  3.87M|        comment.type = BinaryRegionCommentType::VectorUnionValue;
 1292|  3.87M|        comment.index = i;
 1293|       |
 1294|  3.87M|        const auto union_relative_offset = ReadScalar<uint32_t>(offset);
 1295|  3.87M|        if (!union_relative_offset.has_value()) {
  ------------------
  |  Branch (1295:13): [True: 0, False: 3.87M]
  ------------------
 1296|      0|          const uint64_t remaining = RemainingBytes(offset);
 1297|       |
 1298|      0|          SetError(comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "4");
 1299|       |
 1300|      0|          regions.push_back(MakeBinaryRegion(offset, remaining,
 1301|      0|                                             BinaryRegionType::Unknown,
 1302|      0|                                             remaining, 0, comment));
 1303|       |
 1304|      0|          break;
 1305|      0|        }
 1306|       |
 1307|       |        // The union offset is relative from the offset location itself.
 1308|  3.87M|        const uint64_t union_offset = offset + union_relative_offset.value();
 1309|       |
 1310|  3.87M|        if (!IsValidOffset(union_offset)) {
  ------------------
  |  Branch (1310:13): [True: 3.58M, False: 284k]
  ------------------
 1311|  3.58M|          SetError(comment, BinaryRegionStatus::ERROR_OFFSET_OUT_OF_BINARY);
 1312|       |
 1313|  3.58M|          regions.push_back(MakeBinaryRegion(offset, sizeof(uint32_t),
 1314|  3.58M|                                             BinaryRegionType::UOffset, 0,
 1315|  3.58M|                                             union_offset, comment));
 1316|  3.58M|          continue;
 1317|  3.58M|        }
 1318|       |
 1319|   284k|        const auto realized_type =
 1320|   284k|            ReadScalar<uint8_t>(union_type_vector_data_offset + i);
 1321|       |
 1322|   284k|        if (!realized_type.has_value()) {
  ------------------
  |  Branch (1322:13): [True: 37.4k, False: 247k]
  ------------------
 1323|  37.4k|          SetError(comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "1");
 1324|  37.4k|          regions.push_back(MakeBinaryRegion(
 1325|  37.4k|              offset, 0, BinaryRegionType::Unknown, 0, 0, comment));
 1326|  37.4k|          continue;
 1327|  37.4k|        }
 1328|       |
 1329|   247k|        if (!IsValidUnionValue(vtable_entry->second.field->type()->index(),
  ------------------
  |  Branch (1329:13): [True: 31.4k, False: 215k]
  ------------------
 1330|   247k|                               realized_type.value())) {
 1331|       |          // We already export an error in the union type field, so just skip
 1332|       |          // building the union itself and it will default to an unreference
 1333|       |          // Binary section.
 1334|  31.4k|          offset += sizeof(uint32_t);
 1335|  31.4k|          continue;
 1336|  31.4k|        }
 1337|       |
 1338|   215k|        const std::string enum_type =
 1339|   215k|            BuildUnion(union_offset, realized_type.value(), field);
 1340|       |
 1341|   215k|        comment.default_value = "(`" + enum_type + "`)";
 1342|   215k|        regions.push_back(MakeBinaryRegion(offset, sizeof(uint32_t),
 1343|   215k|                                           BinaryRegionType::UOffset, 0,
 1344|   215k|                                           union_offset, comment));
 1345|       |
 1346|   215k|        offset += sizeof(uint32_t);
 1347|   215k|      }
 1348|    545|    } break;
 1349|    265|    default: {
  ------------------
  |  Branch (1349:5): [True: 265, False: 2.22k]
  ------------------
 1350|    265|      if (IsScalar(field->type()->element())) {
  ------------------
  |  Branch (1350:11): [True: 265, False: 0]
  ------------------
 1351|    265|        const BinaryRegionType binary_region_type =
 1352|    265|            GetRegionType(field->type()->element());
 1353|       |
 1354|    265|        const uint64_t type_size = GetTypeSize(field->type()->element());
 1355|       |
 1356|       |        // TODO(dbaileychess): It might be nicer to user the
 1357|       |        // BinaryRegion.array_length field to indicate this.
 1358|  4.17M|        for (size_t i = 0; i < vector_length.value(); ++i) {
  ------------------
  |  Branch (1358:28): [True: 4.17M, False: 265]
  ------------------
 1359|  4.17M|          BinaryRegionComment vector_scalar_comment;
 1360|  4.17M|          vector_scalar_comment.type = BinaryRegionCommentType::VectorValue;
 1361|  4.17M|          vector_scalar_comment.index = i;
 1362|       |
 1363|  4.17M|          if (!IsValidRead(offset, type_size)) {
  ------------------
  |  Branch (1363:15): [True: 0, False: 4.17M]
  ------------------
 1364|      0|            const uint64_t remaining = RemainingBytes(offset);
 1365|       |
 1366|      0|            SetError(vector_scalar_comment,
 1367|      0|                     BinaryRegionStatus::ERROR_INCOMPLETE_BINARY,
 1368|      0|                     std::to_string(type_size));
 1369|       |
 1370|      0|            regions.push_back(
 1371|      0|                MakeBinaryRegion(offset, remaining, BinaryRegionType::Unknown,
 1372|      0|                                 remaining, 0, vector_scalar_comment));
 1373|      0|            break;
 1374|      0|          }
 1375|       |
 1376|  4.17M|          if (IsUnionType(field->type()->element())) {
  ------------------
  |  Branch (1376:15): [True: 4.06M, False: 111k]
  ------------------
 1377|       |            // This is a type for a union. Validate the value
 1378|  4.06M|            const auto enum_value = ReadScalar<uint8_t>(offset);
 1379|       |
 1380|       |            // This should always have a value, due to the IsValidRead check
 1381|       |            // above.
 1382|  4.06M|            if (!IsValidUnionValue(field->type()->index(),
  ------------------
  |  Branch (1382:17): [True: 1.50M, False: 2.55M]
  ------------------
 1383|  4.06M|                                   enum_value.value())) {
 1384|  1.50M|              SetError(vector_scalar_comment,
 1385|  1.50M|                       BinaryRegionStatus::ERROR_INVALID_UNION_TYPE);
 1386|  1.50M|              regions.push_back(MakeBinaryRegion(offset, type_size,
 1387|  1.50M|                                                 binary_region_type, 0, 0,
 1388|  1.50M|                                                 vector_scalar_comment));
 1389|  1.50M|              offset += type_size;
 1390|  1.50M|              continue;
 1391|  1.50M|            }
 1392|  4.06M|          }
 1393|       |
 1394|  2.66M|          regions.push_back(MakeBinaryRegion(offset, type_size,
 1395|  2.66M|                                             binary_region_type, 0, 0,
 1396|  2.66M|                                             vector_scalar_comment));
 1397|  2.66M|          offset += type_size;
 1398|  2.66M|        }
 1399|    265|      }
 1400|    265|    } break;
 1401|  2.49k|  }
 1402|  2.49k|  AddSection(vector_offset,
 1403|  2.49k|             MakeBinarySection(std::string(table->name()->c_str()) + "." +
 1404|  2.49k|                                   field->name()->c_str(),
 1405|  2.49k|                               section_type, std::move(regions)));
 1406|  2.49k|}
_ZN11flatbuffers15BinaryAnnotator10BuildUnionEmhPKN10reflection5FieldE:
 1410|   216k|                                        const reflection::Field* const field) {
 1411|   216k|  const reflection::Enum* next_enum =
 1412|   216k|      schema_->enums()->Get(field->type()->index());
 1413|       |
 1414|   216k|  const reflection::EnumVal* enum_val = next_enum->values()->Get(realized_type);
 1415|       |
 1416|   216k|  if (ContainsSection(union_offset)) {
  ------------------
  |  Branch (1416:7): [True: 10.0k, False: 206k]
  ------------------
 1417|  10.0k|    return enum_val->name()->c_str();
 1418|  10.0k|  }
 1419|       |
 1420|   206k|  const reflection::Type* union_type = enum_val->union_type();
 1421|       |
 1422|   206k|  if (union_type->base_type() == reflection::BaseType::Obj) {
  ------------------
  |  Branch (1422:7): [True: 1.73k, False: 204k]
  ------------------
 1423|  1.73k|    const reflection::Object* object =
 1424|  1.73k|        schema_->objects()->Get(union_type->index());
 1425|       |
 1426|  1.73k|    if (object->is_struct()) {
  ------------------
  |  Branch (1426:9): [True: 46, False: 1.68k]
  ------------------
 1427|       |      // Union of vectors point to a new Binary section
 1428|     46|      std::vector<BinaryRegion> regions;
 1429|       |
 1430|     46|      BuildStruct(union_offset, regions, field->name()->c_str(), object);
 1431|       |
 1432|     46|      AddSection(
 1433|     46|          union_offset,
 1434|     46|          MakeBinarySection(std::string(object->name()->c_str()) + "." +
 1435|     46|                                field->name()->c_str(),
 1436|     46|                            BinarySectionType::Union, std::move(regions)));
 1437|  1.68k|    } else {
 1438|  1.68k|      BuildTable(union_offset, BinarySectionType::Table, object);
 1439|  1.68k|    }
 1440|  1.73k|  }
 1441|       |  // TODO(dbaileychess): handle the other union types.
 1442|       |
 1443|   206k|  return enum_val->name()->c_str();
 1444|   216k|}
_ZN11flatbuffers15BinaryAnnotator17FixMissingRegionsEv:
 1446|  3.31k|void BinaryAnnotator::FixMissingRegions() {
 1447|  3.31k|  std::vector<BinaryRegion> regions_to_insert;
 1448|  2.89M|  for (auto& current_section : sections_) {
  ------------------
  |  Branch (1448:30): [True: 2.89M, False: 3.31k]
  ------------------
 1449|  2.89M|    BinarySection& section = current_section.second;
 1450|  2.89M|    if (section.regions.empty()) {
  ------------------
  |  Branch (1450:9): [True: 0, False: 2.89M]
  ------------------
 1451|       |      // TODO(dbaileychess): is this possible?
 1452|      0|      continue;
 1453|      0|    }
 1454|       |
 1455|  2.89M|    uint64_t offset = section.regions[0].offset + section.regions[0].length;
 1456|  25.7M|    for (size_t i = 1; i < section.regions.size(); ++i) {
  ------------------
  |  Branch (1456:24): [True: 22.8M, False: 2.89M]
  ------------------
 1457|  22.8M|      BinaryRegion& region = section.regions[i];
 1458|       |
 1459|  22.8M|      const uint64_t next_offset = region.offset;
 1460|  22.8M|      if (!IsValidOffset(next_offset)) {
  ------------------
  |  Branch (1460:11): [True: 1.52k, False: 22.8M]
  ------------------
 1461|       |        // TODO(dbaileychess): figure out how we get into this situation.
 1462|  1.52k|        continue;
 1463|  1.52k|      }
 1464|       |
 1465|  22.8M|      if (offset < next_offset) {
  ------------------
  |  Branch (1465:11): [True: 156k, False: 22.7M]
  ------------------
 1466|   156k|        const uint64_t padding_bytes = next_offset - offset;
 1467|       |
 1468|   156k|        BinaryRegionComment comment;
 1469|   156k|        comment.type = BinaryRegionCommentType::Padding;
 1470|       |
 1471|   156k|        if (IsNonZeroRegion(offset, padding_bytes, binary_)) {
  ------------------
  |  Branch (1471:13): [True: 134k, False: 21.4k]
  ------------------
 1472|   134k|          SetError(comment, BinaryRegionStatus::WARN_NO_REFERENCES);
 1473|   134k|          regions_to_insert.push_back(
 1474|   134k|              MakeBinaryRegion(offset, padding_bytes, BinaryRegionType::Unknown,
 1475|   134k|                               padding_bytes, 0, comment));
 1476|   134k|        } else {
 1477|  21.4k|          regions_to_insert.push_back(
 1478|  21.4k|              MakeBinaryRegion(offset, padding_bytes, BinaryRegionType::Uint8,
 1479|  21.4k|                               padding_bytes, 0, comment));
 1480|  21.4k|        }
 1481|   156k|      }
 1482|  22.8M|      offset = next_offset + region.length;
 1483|  22.8M|    }
 1484|       |
 1485|  2.89M|    if (!regions_to_insert.empty()) {
  ------------------
  |  Branch (1485:9): [True: 82.7k, False: 2.81M]
  ------------------
 1486|  82.7k|      section.regions.insert(section.regions.end(), regions_to_insert.begin(),
 1487|  82.7k|                             regions_to_insert.end());
 1488|  82.7k|      std::stable_sort(section.regions.begin(), section.regions.end(),
 1489|  82.7k|                       BinaryRegionSort);
 1490|  82.7k|      regions_to_insert.clear();
 1491|  82.7k|    }
 1492|  2.89M|  }
 1493|  3.31k|}
_ZN11flatbuffers15BinaryAnnotator18FixMissingSectionsEv:
 1495|  3.31k|void BinaryAnnotator::FixMissingSections() {
 1496|  3.31k|  uint64_t offset = 0;
 1497|       |
 1498|  3.31k|  std::vector<BinarySection> sections_to_insert;
 1499|       |
 1500|  2.89M|  for (auto& current_section : sections_) {
  ------------------
  |  Branch (1500:30): [True: 2.89M, False: 3.31k]
  ------------------
 1501|  2.89M|    BinarySection& section = current_section.second;
 1502|  2.89M|    const uint64_t section_start_offset = current_section.first;
 1503|  2.89M|    const uint64_t section_end_offset =
 1504|  2.89M|        section.regions.back().offset + section.regions.back().length;
 1505|       |
 1506|  2.89M|    if (offset < section_start_offset) {
  ------------------
  |  Branch (1506:9): [True: 2.49M, False: 402k]
  ------------------
 1507|       |      // We are at an offset that is less then the current section.
 1508|  2.49M|      const uint64_t pad_bytes = section_start_offset - offset + 1;
 1509|       |
 1510|  2.49M|      sections_to_insert.push_back(
 1511|  2.49M|          GenerateMissingSection(offset - 1, pad_bytes, binary_));
 1512|  2.49M|    }
 1513|  2.89M|    offset = section_end_offset + 1;
 1514|  2.89M|  }
 1515|       |
 1516|       |  // Handle the case where there are still bytes left in the binary that are
 1517|       |  // unaccounted for.
 1518|  3.31k|  if (offset < binary_length_) {
  ------------------
  |  Branch (1518:7): [True: 1.51k, False: 1.80k]
  ------------------
 1519|  1.51k|    const uint64_t pad_bytes = binary_length_ - offset + 1;
 1520|  1.51k|    sections_to_insert.push_back(
 1521|  1.51k|        GenerateMissingSection(offset - 1, pad_bytes, binary_));
 1522|  1.51k|  }
 1523|       |
 1524|  2.49M|  for (const BinarySection& section_to_insert : sections_to_insert) {
  ------------------
  |  Branch (1524:47): [True: 2.49M, False: 3.31k]
  ------------------
 1525|  2.49M|    AddSection(section_to_insert.regions[0].offset, section_to_insert);
 1526|  2.49M|  }
 1527|  3.31k|}
_ZN11flatbuffers15BinaryAnnotator15ContainsSectionEm:
 1529|  9.75M|bool BinaryAnnotator::ContainsSection(const uint64_t offset) {
 1530|  9.75M|  auto it = sections_.lower_bound(offset);
 1531|       |  // If the section is found, check that it is exactly equal its offset.
 1532|  9.75M|  if (it != sections_.end() && it->first == offset) {
  ------------------
  |  Branch (1532:7): [True: 9.41M, False: 336k]
  |  Branch (1532:7): [True: 208k, False: 9.54M]
  |  Branch (1532:32): [True: 208k, False: 9.21M]
  ------------------
 1533|   208k|    return true;
 1534|   208k|  }
 1535|       |
 1536|       |  // If this was the first section, there are no other previous sections to
 1537|       |  // check.
 1538|  9.54M|  if (it == sections_.begin()) {
  ------------------
  |  Branch (1538:7): [True: 0, False: 9.54M]
  ------------------
 1539|      0|    return false;
 1540|      0|  }
 1541|       |
 1542|       |  // Go back one section.
 1543|  9.54M|  --it;
 1544|       |
 1545|       |  // And check that if the offset is covered by the section.
 1546|  9.54M|  return offset >= it->first && offset < it->second.regions.back().offset +
  ------------------
  |  Branch (1546:10): [True: 9.54M, False: 0]
  |  Branch (1546:33): [True: 4.22M, False: 5.31M]
  ------------------
 1547|  9.54M|                                             it->second.regions.back().length;
 1548|  9.54M|}
_ZNK11flatbuffers15BinaryAnnotator9RootTableEv:
 1550|  6.56k|const reflection::Object* BinaryAnnotator::RootTable() const {
 1551|  6.56k|  if (!root_table_.empty()) {
  ------------------
  |  Branch (1551:7): [True: 0, False: 6.56k]
  ------------------
 1552|      0|    return schema_->objects()->LookupByKey(root_table_);
 1553|      0|  }
 1554|  6.56k|  return schema_->root_table();
 1555|  6.56k|}
binary_annotator.cpp:_ZN11flatbuffers12_GLOBAL__N_116MakeBinaryRegionEmmNS_16BinaryRegionTypeEmmNS_19BinaryRegionCommentE:
   32|  31.1M|    BinaryRegionComment comment = {}) {
   33|  31.1M|  BinaryRegion region;
   34|  31.1M|  region.offset = offset;
   35|  31.1M|  region.length = length;
   36|  31.1M|  region.type = type;
   37|  31.1M|  region.array_length = array_length;
   38|  31.1M|  region.points_to_offset = points_to_offset;
   39|  31.1M|  region.comment = std::move(comment);
   40|  31.1M|  return region;
   41|  31.1M|}
binary_annotator.cpp:_ZN11flatbuffers12_GLOBAL__N_18SetErrorERNS_19BinaryRegionCommentENS_18BinaryRegionStatusENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE:
   23|  14.8M|                     std::string message = "") {
   24|  14.8M|  comment.status = status;
   25|  14.8M|  comment.status_message = message;
   26|  14.8M|}
binary_annotator.cpp:_ZN11flatbuffers12_GLOBAL__N_117IsPrintableRegionEmmPKh:
   72|  3.31k|                              const uint8_t* const binary) {
   73|  4.19k|  for (uint64_t i = offset; i < offset + length; ++i) {
  ------------------
  |  Branch (73:29): [True: 4.18k, False: 14]
  ------------------
   74|  4.18k|    if (!isprint(binary[i])) {
  ------------------
  |  Branch (74:9): [True: 3.30k, False: 879]
  ------------------
   75|  3.30k|      return false;
   76|  3.30k|    }
   77|  4.18k|  }
   78|     14|  return true;
   79|  3.31k|}
binary_annotator.cpp:_ZN11flatbuffers12_GLOBAL__N_117MakeBinarySectionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17BinarySectionTypeENS1_6vectorINS_12BinaryRegionENS5_ISC_EEEE:
   45|  5.39M|                                       std::vector<BinaryRegion> regions) {
   46|  5.39M|  BinarySection section;
   47|  5.39M|  section.name = name;
   48|  5.39M|  section.type = type;
   49|  5.39M|  section.regions = std::move(regions);
   50|  5.39M|  return section;
   51|  5.39M|}
binary_annotator.cpp:_ZN11flatbuffers12_GLOBAL__N_129MakeSingleRegionBinarySectionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17BinarySectionTypeERKNS_12BinaryRegionE:
   55|  2.42M|                                                   const BinaryRegion& region) {
   56|  2.42M|  std::vector<BinaryRegion> regions;
   57|  2.42M|  regions.push_back(region);
   58|  2.42M|  return MakeBinarySection(name, type, std::move(regions));
   59|  2.42M|}
binary_annotator.cpp:_ZN11flatbuffers12_GLOBAL__N_115IsNonZeroRegionEmmPKh:
   62|  2.65M|                            const uint8_t* const binary) {
   63|  13.6M|  for (uint64_t i = offset; i < offset + length; ++i) {
  ------------------
  |  Branch (63:29): [True: 11.7M, False: 1.89M]
  ------------------
   64|  11.7M|    if (binary[i] != 0) {
  ------------------
  |  Branch (64:9): [True: 753k, False: 10.9M]
  ------------------
   65|   753k|      return true;
   66|   753k|    }
   67|  11.7M|  }
   68|  1.89M|  return false;
   69|  2.65M|}
binary_annotator.cpp:_ZN11flatbuffers12_GLOBAL__N_116BinaryRegionSortERKNS_12BinaryRegionES3_:
   18|  23.3M|static bool BinaryRegionSort(const BinaryRegion& a, const BinaryRegion& b) {
   19|  23.3M|  return a.offset < b.offset;
   20|  23.3M|}
binary_annotator.cpp:_ZN11flatbuffers12_GLOBAL__N_122GenerateMissingSectionEmmPKh:
   83|  2.49M|                                            const uint8_t* const binary) {
   84|  2.49M|  std::vector<BinaryRegion> regions;
   85|       |
   86|       |  // Check if the region is all zeros or not, as that can tell us if it is
   87|       |  // padding or not.
   88|  2.49M|  if (IsNonZeroRegion(offset, length, binary)) {
  ------------------
  |  Branch (88:7): [True: 619k, False: 1.87M]
  ------------------
   89|       |    // Some of the padding bytes are non-zero, so this might be an unknown
   90|       |    // section of the binary.
   91|       |    // TODO(dbaileychess): We could be a bit smarter with different sized
   92|       |    // alignments. For now, the 8 byte check encompasses all the smaller
   93|       |    // alignments.
   94|   619k|    BinaryRegionComment comment;
   95|   619k|    comment.type = BinaryRegionCommentType::Unknown;
   96|   619k|    if (length >= 8) {
  ------------------
  |  Branch (96:9): [True: 399k, False: 219k]
  ------------------
   97|   399k|      SetError(comment, BinaryRegionStatus::WARN_NO_REFERENCES);
   98|   399k|    } else {
   99|   219k|      SetError(comment, BinaryRegionStatus::WARN_CORRUPTED_PADDING);
  100|   219k|    }
  101|       |
  102|   619k|    regions.push_back(MakeBinaryRegion(offset, length * sizeof(uint8_t),
  103|   619k|                                       BinaryRegionType::Unknown, length, 0,
  104|   619k|                                       comment));
  105|       |
  106|   619k|    return MakeBinarySection("no known references", BinarySectionType::Unknown,
  107|   619k|                             std::move(regions));
  108|   619k|  }
  109|       |
  110|  1.87M|  BinaryRegionComment comment;
  111|  1.87M|  comment.type = BinaryRegionCommentType::Padding;
  112|  1.87M|  if (length >= 8) {
  ------------------
  |  Branch (112:7): [True: 8.68k, False: 1.86M]
  ------------------
  113|  8.68k|    SetError(comment, BinaryRegionStatus::WARN_PADDING_LENGTH);
  114|  8.68k|  }
  115|       |
  116|       |  // This region is most likely padding.
  117|  1.87M|  regions.push_back(MakeBinaryRegion(offset, length * sizeof(uint8_t),
  118|  1.87M|                                     BinaryRegionType::Uint8, length, 0,
  119|  1.87M|                                     comment));
  120|       |
  121|  1.87M|  return MakeBinarySection("", BinarySectionType::Padding, std::move(regions));
  122|  2.49M|}
binary_annotator.cpp:_ZZN11flatbuffers15BinaryAnnotator16GetOrBuildVTableEmPKN10reflection6ObjectEmENK3$_0clEPKNS1_5FieldE:
  363|   435k|  ForAllFields(table, /*reverse=*/false, [&](const reflection::Field* field) {
  364|   435k|    const uint64_t field_offset = offset_start + field->id() * sizeof(uint16_t);
  365|       |
  366|   435k|    if (field_offset >= vtable_offset + vtable_size) {
  ------------------
  |  Branch (366:9): [True: 96.8k, False: 338k]
  ------------------
  367|       |      // This field_offset is too large for this vtable, so it must come from a
  368|       |      // newer schema than the binary was create with or the binary writer did
  369|       |      // not write it. For either case, it is safe to ignore.
  370|       |
  371|       |      // TODO(dbaileychess): We could show which fields are not set an their
  372|       |      // default values if we want. We just need a way to make it obvious that
  373|       |      // it isn't part of the buffer.
  374|  96.8k|      return;
  375|  96.8k|    }
  376|       |
  377|   338k|    BinaryRegionComment field_comment;
  378|   338k|    field_comment.type = BinaryRegionCommentType::VTableFieldOffset;
  379|   338k|    field_comment.name = std::string(field->name()->c_str()) +
  380|   338k|                         "` (id: " + std::to_string(field->id()) + ")";
  381|       |
  382|   338k|    const auto offset_from_table = ReadScalar<uint16_t>(field_offset);
  383|       |
  384|   338k|    if (!offset_from_table.has_value()) {
  ------------------
  |  Branch (384:9): [True: 95, False: 338k]
  ------------------
  385|     95|      const uint64_t remaining = RemainingBytes(field_offset);
  386|       |
  387|     95|      SetError(field_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "2");
  388|     95|      regions.push_back(MakeBinaryRegion(field_offset, remaining,
  389|     95|                                         BinaryRegionType::Unknown, remaining,
  390|     95|                                         0, field_comment));
  391|       |
  392|     95|      return;
  393|     95|    }
  394|       |
  395|   338k|    if (!IsValidOffset(offset_of_referring_table + offset_from_table.value() -
  ------------------
  |  Branch (395:9): [True: 29.1k, False: 308k]
  ------------------
  396|   338k|                       1)) {
  397|  29.1k|      SetError(field_comment, BinaryRegionStatus::ERROR_OFFSET_OUT_OF_BINARY);
  398|  29.1k|      regions.push_back(MakeBinaryRegion(field_offset, sizeof(uint16_t),
  399|  29.1k|                                         BinaryRegionType::VOffset, 0, 0,
  400|  29.1k|                                         field_comment));
  401|  29.1k|      return;
  402|  29.1k|    }
  403|       |
  404|   308k|    VTable::Entry entry;
  405|   308k|    entry.field = field;
  406|   308k|    entry.offset_from_table = offset_from_table.value();
  407|   308k|    fields.insert(std::make_pair(field->id(), entry));
  408|       |
  409|   308k|    std::string default_label;
  410|   308k|    if (offset_from_table.value() == 0) {
  ------------------
  |  Branch (410:9): [True: 104k, False: 204k]
  ------------------
  411|       |      // Not present, so could be default or be optional.
  412|   104k|      if (field->required()) {
  ------------------
  |  Branch (412:11): [True: 0, False: 104k]
  ------------------
  413|      0|        SetError(field_comment,
  414|      0|                 BinaryRegionStatus::ERROR_REQUIRED_FIELD_NOT_PRESENT);
  415|       |        // If this is a required field, make it known this is an error.
  416|      0|        regions.push_back(MakeBinaryRegion(field_offset, sizeof(uint16_t),
  417|      0|                                           BinaryRegionType::VOffset, 0, 0,
  418|      0|                                           field_comment));
  419|      0|        return;
  420|   104k|      } else {
  421|       |        // Its an optional field, so get the default value and interpret and
  422|       |        // provided an annotation for it.
  423|   104k|        if (IsScalar(field->type()->base_type())) {
  ------------------
  |  Branch (423:13): [True: 82.9k, False: 21.2k]
  ------------------
  424|  82.9k|          default_label += "<defaults to ";
  425|  82.9k|          default_label += IsFloat(field->type()->base_type())
  ------------------
  |  Branch (425:28): [True: 74.1k, False: 8.77k]
  ------------------
  426|  82.9k|                               ? std::to_string(field->default_real())
  427|  82.9k|                               : std::to_string(field->default_integer());
  428|  82.9k|          default_label += "> (";
  429|  82.9k|        } else {
  430|  21.2k|          default_label += "<null> (";
  431|  21.2k|        }
  432|   104k|        default_label +=
  433|   104k|            reflection::EnumNameBaseType(field->type()->base_type());
  434|   104k|        default_label += ")";
  435|   104k|      }
  436|   104k|    }
  437|   308k|    field_comment.default_value = default_label;
  438|       |
  439|   308k|    regions.push_back(MakeBinaryRegion(field_offset, sizeof(uint16_t),
  440|   308k|                                       BinaryRegionType::VOffset, 0, 0,
  441|   308k|                                       field_comment));
  442|       |
  443|   308k|    fields_processed++;
  444|   308k|  });
binary_annotator.cpp:_ZZN11flatbuffers15BinaryAnnotator10BuildTableEmNS_17BinarySectionTypeEPKN10reflection6ObjectEENK3$_0clERKNS0_6VTable5EntryESA_:
  589|  1.95M|                   [](const VTable::Entry& a, const VTable::Entry& b) {
  590|  1.95M|                     return a.offset_from_table < b.offset_from_table;
  591|  1.95M|                   });
binary_annotator.cpp:_ZZN11flatbuffers15BinaryAnnotator11BuildStructEmRNSt3__16vectorINS_12BinaryRegionENS1_9allocatorIS3_EEEENS1_12basic_stringIcNS1_11char_traitsIcEENS4_IcEEEEPKN10reflection6ObjectEENK3$_0clEPKNSD_5FieldE:
  880|   294k|  ForAllFields(object, /*reverse=*/false, [&](const reflection::Field* field) {
  881|   294k|    if (IsScalar(field->type()->base_type())) {
  ------------------
  |  Branch (881:9): [True: 290k, False: 3.91k]
  ------------------
  882|       |      // Structure Field value
  883|   290k|      const uint64_t type_size = GetTypeSize(field->type()->base_type());
  884|   290k|      const BinaryRegionType region_type =
  885|   290k|          GetRegionType(field->type()->base_type());
  886|       |
  887|   290k|      BinaryRegionComment comment;
  888|   290k|      comment.type = BinaryRegionCommentType::StructField;
  889|   290k|      comment.name = referring_field_name + "." + field->name()->str();
  890|   290k|      comment.default_value = "of '" + object->name()->str() + "' (" +
  891|   290k|                              std::string(reflection::EnumNameBaseType(
  892|   290k|                                  field->type()->base_type())) +
  893|   290k|                              ")";
  894|       |
  895|   290k|      if (!IsValidRead(offset, type_size)) {
  ------------------
  |  Branch (895:11): [True: 1.27k, False: 289k]
  ------------------
  896|  1.27k|        const uint64_t remaining = RemainingBytes(offset);
  897|  1.27k|        SetError(comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY,
  898|  1.27k|                 std::to_string(type_size));
  899|  1.27k|        regions.push_back(MakeBinaryRegion(offset, remaining,
  900|  1.27k|                                           BinaryRegionType::Unknown, remaining,
  901|  1.27k|                                           0, comment));
  902|       |
  903|       |        // TODO(dbaileychess): Should I bail out here? This sets offset to the
  904|       |        // end of the binary. So all other reads in the loop should fail.
  905|  1.27k|        offset += remaining;
  906|  1.27k|        return;
  907|  1.27k|      }
  908|       |
  909|   289k|      regions.push_back(
  910|   289k|          MakeBinaryRegion(offset, type_size, region_type, 0, 0, comment));
  911|   289k|      offset += type_size;
  912|   289k|    } else if (field->type()->base_type() == reflection::BaseType::Obj) {
  ------------------
  |  Branch (912:16): [True: 1.28k, False: 2.62k]
  ------------------
  913|       |      // Structs are stored inline, even when nested.
  914|  1.28k|      offset = BuildStruct(offset, regions,
  915|  1.28k|                           referring_field_name + "." + field->name()->str(),
  916|  1.28k|                           schema_->objects()->Get(field->type()->index()));
  917|  2.62k|    } else if (field->type()->base_type() == reflection::BaseType::Array) {
  ------------------
  |  Branch (917:16): [True: 2.62k, False: 0]
  ------------------
  918|  2.62k|      const bool is_scalar = IsScalar(field->type()->element());
  919|  2.62k|      const uint64_t type_size = GetTypeSize(field->type()->element());
  920|  2.62k|      const BinaryRegionType region_type =
  921|  2.62k|          GetRegionType(field->type()->element());
  922|       |
  923|       |      // Arrays are just repeated structures.
  924|  9.69k|      for (uint16_t i = 0; i < field->type()->fixed_length(); ++i) {
  ------------------
  |  Branch (924:28): [True: 7.38k, False: 2.31k]
  ------------------
  925|  7.38k|        if (is_scalar) {
  ------------------
  |  Branch (925:13): [True: 3.43k, False: 3.94k]
  ------------------
  926|  3.43k|          BinaryRegionComment array_comment;
  927|  3.43k|          array_comment.type = BinaryRegionCommentType::ArrayField;
  928|  3.43k|          array_comment.name =
  929|  3.43k|              referring_field_name + "." + field->name()->str();
  930|  3.43k|          array_comment.index = i;
  931|  3.43k|          array_comment.default_value =
  932|  3.43k|              "of '" + object->name()->str() + "' (" +
  933|  3.43k|              std::string(
  934|  3.43k|                  reflection::EnumNameBaseType(field->type()->element())) +
  935|  3.43k|              ")";
  936|       |
  937|  3.43k|          if (!IsValidRead(offset, type_size)) {
  ------------------
  |  Branch (937:15): [True: 315, False: 3.12k]
  ------------------
  938|    315|            const uint64_t remaining = RemainingBytes(offset);
  939|       |
  940|    315|            SetError(array_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY,
  941|    315|                     std::to_string(type_size));
  942|       |
  943|    315|            regions.push_back(MakeBinaryRegion(offset, remaining,
  944|    315|                                               BinaryRegionType::Unknown,
  945|    315|                                               remaining, 0, array_comment));
  946|       |
  947|       |            // TODO(dbaileychess): Should I bail out here? This sets offset to
  948|       |            // the end of the binary. So all other reads in the loop should
  949|       |            // fail.
  950|    315|            offset += remaining;
  951|    315|            break;
  952|    315|          }
  953|       |
  954|  3.12k|          regions.push_back(MakeBinaryRegion(offset, type_size, region_type, 0,
  955|  3.12k|                                             0, array_comment));
  956|       |
  957|  3.12k|          offset += type_size;
  958|  3.94k|        } else {
  959|       |          // Array of Structs.
  960|       |          //
  961|       |          // TODO(dbaileychess): This works, but the comments on the fields lose
  962|       |          // some context. Need to figure a way how to plumb the nested arrays
  963|       |          // comments together that isn't too confusing.
  964|  3.94k|          offset =
  965|  3.94k|              BuildStruct(offset, regions,
  966|  3.94k|                          referring_field_name + "." + field->name()->str(),
  967|  3.94k|                          schema_->objects()->Get(field->type()->index()));
  968|  3.94k|        }
  969|  7.38k|      }
  970|  2.62k|    }
  971|       |
  972|       |    // Insert any padding after this field.
  973|   293k|    const uint16_t padding = field->padding();
  974|   293k|    if (padding > 0 && IsValidOffset(offset + padding)) {
  ------------------
  |  Branch (974:9): [True: 1.31k, False: 291k]
  |  Branch (974:24): [True: 969, False: 345]
  ------------------
  975|    969|      BinaryRegionComment padding_comment;
  976|    969|      padding_comment.type = BinaryRegionCommentType::Padding;
  977|       |
  978|    969|      regions.push_back(MakeBinaryRegion(offset, padding,
  979|    969|                                         BinaryRegionType::Uint8, padding, 0,
  980|    969|                                         padding_comment));
  981|    969|      offset += padding;
  982|    969|    }
  983|   293k|  });

_ZN11flatbuffers15BinaryAnnotatorC2EPKhmS2_mb:
  289|  3.32k|      : bfbs_(bfbs),
  290|  3.32k|        bfbs_length_(bfbs_length),
  291|  3.32k|        schema_(reflection::GetSchema(bfbs)),
  292|  3.32k|        root_table_(""),
  293|  3.32k|        binary_(binary),
  294|  3.32k|        binary_length_(binary_length),
  295|  3.32k|        is_size_prefixed_(is_size_prefixed) {}
_ZNK11flatbuffers15BinaryAnnotator13IsValidOffsetEm:
  355|  79.0M|  inline bool IsValidOffset(const uint64_t offset) const {
  356|  79.0M|    return offset < binary_length_;
  357|  79.0M|  }
_ZNK11flatbuffers15BinaryAnnotator11IsValidReadEmm:
  366|  32.5M|  inline bool IsValidRead(const uint64_t offset, const uint64_t length) const {
  367|  32.5M|    return length < binary_length_ && IsValidOffset(offset + length - 1);
  ------------------
  |  Branch (367:12): [True: 32.5M, False: 31.6k]
  |  Branch (367:39): [True: 32.5M, False: 43.7k]
  ------------------
  368|  32.5M|  }
_ZNK11flatbuffers15BinaryAnnotator14RemainingBytesEm:
  372|  50.0k|  uint64_t RemainingBytes(const uint64_t offset) const {
  373|  50.0k|    return IsValidOffset(offset) ? binary_length_ - offset : 0;
  ------------------
  |  Branch (373:12): [True: 48.4k, False: 1.52k]
  ------------------
  374|  50.0k|  }
_ZN11flatbuffers15BinaryAnnotator10AddSectionEmRKNS_13BinarySectionE:
  388|  5.27M|  void AddSection(const uint64_t offset, const BinarySection& section) {
  389|  5.27M|    sections_.insert(std::make_pair(offset, section));
  390|  5.27M|  }
_ZN11flatbuffers15BinaryAnnotator13IsInlineFieldEPKN10reflection5FieldE:
  392|  85.2k|  bool IsInlineField(const reflection::Field* const field) {
  393|  85.2k|    if (field->type()->base_type() == reflection::BaseType::Obj) {
  ------------------
  |  Branch (393:9): [True: 73.4k, False: 11.7k]
  ------------------
  394|  73.4k|      return schema_->objects()->Get(field->type()->index())->is_struct();
  395|  73.4k|    }
  396|  11.7k|    return IsScalar(field->type()->base_type());
  397|  85.2k|  }
_ZN11flatbuffers15BinaryAnnotator11IsUnionTypeEN10reflection8BaseTypeE:
  399|  4.30M|  bool IsUnionType(const reflection::BaseType type) {
  400|  4.30M|    return (type == reflection::BaseType::UType ||
  ------------------
  |  Branch (400:13): [True: 4.06M, False: 238k]
  ------------------
  401|   238k|            type == reflection::BaseType::Union);
  ------------------
  |  Branch (401:13): [True: 619, False: 237k]
  ------------------
  402|  4.30M|  }
_ZN11flatbuffers15BinaryAnnotator11IsUnionTypeEPKN10reflection5FieldE:
  404|   131k|  bool IsUnionType(const reflection::Field* const field) {
  405|   131k|    return IsUnionType(field->type()->base_type()) &&
  ------------------
  |  Branch (405:12): [True: 4.55k, False: 126k]
  ------------------
  406|  4.55k|           field->type()->index() >= 0;
  ------------------
  |  Branch (406:12): [True: 4.55k, False: 0]
  ------------------
  407|   131k|  }
_ZN11flatbuffers15BinaryAnnotator17IsValidUnionValueEPKN10reflection5FieldEh:
  410|  2.58k|                         const uint8_t value) {
  411|  2.58k|    return IsUnionType(field) &&
  ------------------
  |  Branch (411:12): [True: 2.58k, False: 0]
  ------------------
  412|  2.58k|           IsValidUnionValue(field->type()->index(), value);
  ------------------
  |  Branch (412:12): [True: 1.41k, False: 1.17k]
  ------------------
  413|  2.58k|  }
_ZN11flatbuffers15BinaryAnnotator17IsValidUnionValueEjh:
  415|  4.31M|  bool IsValidUnionValue(const uint32_t enum_id, const uint8_t value) {
  416|  4.31M|    if (enum_id >= schema_->enums()->size()) {
  ------------------
  |  Branch (416:9): [True: 0, False: 4.31M]
  ------------------
  417|      0|      return false;
  418|      0|    }
  419|       |
  420|  4.31M|    const reflection::Enum* enum_def = schema_->enums()->Get(enum_id);
  421|       |
  422|  4.31M|    if (enum_def == nullptr) {
  ------------------
  |  Branch (422:9): [True: 0, False: 4.31M]
  ------------------
  423|      0|      return false;
  424|      0|    }
  425|       |
  426|  4.31M|    return value < enum_def->values()->size();
  427|  4.31M|  }
_ZN11flatbuffers15BinaryAnnotator14GetElementSizeEPKN10reflection5FieldE:
  429|  2.96k|  uint64_t GetElementSize(const reflection::Field* const field) {
  430|  2.96k|    if (IsScalar(field->type()->element())) {
  ------------------
  |  Branch (430:9): [True: 430, False: 2.53k]
  ------------------
  431|    430|      return GetTypeSize(field->type()->element());
  432|    430|    }
  433|       |
  434|  2.53k|    switch (field->type()->element()) {
  435|  1.46k|      case reflection::BaseType::Obj: {
  ------------------
  |  Branch (435:7): [True: 1.46k, False: 1.07k]
  ------------------
  436|  1.46k|        auto obj = schema_->objects()->Get(field->type()->index());
  437|  1.46k|        return obj->is_struct() ? obj->bytesize() : sizeof(uint32_t);
  ------------------
  |  Branch (437:16): [True: 148, False: 1.31k]
  ------------------
  438|      0|      }
  439|  1.07k|      default:
  ------------------
  |  Branch (439:7): [True: 1.07k, False: 1.46k]
  ------------------
  440|  1.07k|        return sizeof(uint32_t);
  441|  2.53k|    }
  442|  2.53k|  }
binary_annotator.cpp:_ZN11flatbuffersL13GetRegionTypeEN10reflection8BaseTypeE:
  206|   422k|inline static BinaryRegionType GetRegionType(reflection::BaseType base_type) {
  207|   422k|  switch (base_type) {
  208|  2.14k|    case reflection::UType:
  ------------------
  |  Branch (208:5): [True: 2.14k, False: 420k]
  ------------------
  209|  2.14k|      return BinaryRegionType::UType;
  210|    580|    case reflection::Bool:
  ------------------
  |  Branch (210:5): [True: 580, False: 421k]
  ------------------
  211|    580|      return BinaryRegionType::Uint8;
  212|  5.39k|    case reflection::Byte:
  ------------------
  |  Branch (212:5): [True: 5.39k, False: 417k]
  ------------------
  213|  5.39k|      return BinaryRegionType::Uint8;
  214|  3.95k|    case reflection::UByte:
  ------------------
  |  Branch (214:5): [True: 3.95k, False: 418k]
  ------------------
  215|  3.95k|      return BinaryRegionType::Uint8;
  216|      0|    case reflection::Short:
  ------------------
  |  Branch (216:5): [True: 0, False: 422k]
  ------------------
  217|      0|      return BinaryRegionType::Int16;
  218|     85|    case reflection::UShort:
  ------------------
  |  Branch (218:5): [True: 85, False: 422k]
  ------------------
  219|     85|      return BinaryRegionType::Uint16;
  220|  9.08k|    case reflection::Int:
  ------------------
  |  Branch (220:5): [True: 9.08k, False: 413k]
  ------------------
  221|  9.08k|      return BinaryRegionType::Uint32;
  222|      0|    case reflection::UInt:
  ------------------
  |  Branch (222:5): [True: 0, False: 422k]
  ------------------
  223|      0|      return BinaryRegionType::Uint32;
  224|  1.61k|    case reflection::Long:
  ------------------
  |  Branch (224:5): [True: 1.61k, False: 420k]
  ------------------
  225|  1.61k|      return BinaryRegionType::Int64;
  226|      0|    case reflection::ULong:
  ------------------
  |  Branch (226:5): [True: 0, False: 422k]
  ------------------
  227|      0|      return BinaryRegionType::Uint64;
  228|  41.3k|    case reflection::Float:
  ------------------
  |  Branch (228:5): [True: 41.3k, False: 381k]
  ------------------
  229|  41.3k|      return BinaryRegionType::Float;
  230|   357k|    case reflection::Double:
  ------------------
  |  Branch (230:5): [True: 357k, False: 65.5k]
  ------------------
  231|   357k|      return BinaryRegionType::Double;
  232|  1.31k|    default:
  ------------------
  |  Branch (232:5): [True: 1.31k, False: 421k]
  ------------------
  233|  1.31k|      return BinaryRegionType::Unknown;
  234|   422k|  }
  235|   422k|}
_ZNK11flatbuffers15BinaryAnnotator10ReadScalarIjEENSt3__18optionalIT_EEm:
  377|  17.6M|  flatbuffers::Optional<T> ReadScalar(const uint64_t offset) const {
  378|  17.6M|    if (!IsValidRead<T>(offset)) {
  ------------------
  |  Branch (378:9): [True: 662, False: 17.5M]
  ------------------
  379|    662|      return flatbuffers::nullopt;
  380|    662|    }
  381|       |
  382|  17.5M|    return flatbuffers::ReadScalar<T>(binary_ + offset);
  383|  17.6M|  }
_ZNK11flatbuffers15BinaryAnnotator11IsValidReadIjEEbm:
  362|  17.6M|  inline bool IsValidRead(const uint64_t offset) const {
  363|  17.6M|    return IsValidRead(offset, sizeof(T));
  364|  17.6M|  }
_ZNK11flatbuffers15BinaryAnnotator10ReadScalarItEENSt3__18optionalIT_EEm:
  377|  3.17M|  flatbuffers::Optional<T> ReadScalar(const uint64_t offset) const {
  378|  3.17M|    if (!IsValidRead<T>(offset)) {
  ------------------
  |  Branch (378:9): [True: 168, False: 3.17M]
  ------------------
  379|    168|      return flatbuffers::nullopt;
  380|    168|    }
  381|       |
  382|  3.17M|    return flatbuffers::ReadScalar<T>(binary_ + offset);
  383|  3.17M|  }
_ZNK11flatbuffers15BinaryAnnotator11IsValidReadItEEbm:
  362|  3.17M|  inline bool IsValidRead(const uint64_t offset) const {
  363|  3.17M|    return IsValidRead(offset, sizeof(T));
  364|  3.17M|  }
_ZNK11flatbuffers15BinaryAnnotator10ReadScalarIiEENSt3__18optionalIT_EEm:
  377|  2.64M|  flatbuffers::Optional<T> ReadScalar(const uint64_t offset) const {
  378|  2.64M|    if (!IsValidRead<T>(offset)) {
  ------------------
  |  Branch (378:9): [True: 328, False: 2.64M]
  ------------------
  379|    328|      return flatbuffers::nullopt;
  380|    328|    }
  381|       |
  382|  2.64M|    return flatbuffers::ReadScalar<T>(binary_ + offset);
  383|  2.64M|  }
_ZNK11flatbuffers15BinaryAnnotator11IsValidReadIiEEbm:
  362|  2.64M|  inline bool IsValidRead(const uint64_t offset) const {
  363|  2.64M|    return IsValidRead(offset, sizeof(T));
  364|  2.64M|  }
binary_annotator.cpp:_ZN11flatbuffersL5ToHexImEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEET_m:
   61|  12.3k|static inline std::string ToHex(T i, size_t width = sizeof(T)) {
   62|  12.3k|  std::stringstream stream;
   63|  12.3k|  stream << std::hex << std::uppercase << std::setfill('0')
   64|  12.3k|         << std::setw(static_cast<int>(width)) << i;
   65|  12.3k|  return stream.str();
   66|  12.3k|}
_ZNK11flatbuffers15BinaryAnnotator10ReadScalarIhEENSt3__18optionalIT_EEm:
  377|  4.35M|  flatbuffers::Optional<T> ReadScalar(const uint64_t offset) const {
  378|  4.35M|    if (!IsValidRead<T>(offset)) {
  ------------------
  |  Branch (378:9): [True: 37.5k, False: 4.31M]
  ------------------
  379|  37.5k|      return flatbuffers::nullopt;
  380|  37.5k|    }
  381|       |
  382|  4.31M|    return flatbuffers::ReadScalar<T>(binary_ + offset);
  383|  4.35M|  }
_ZNK11flatbuffers15BinaryAnnotator11IsValidReadIhEEbm:
  362|  4.35M|  inline bool IsValidRead(const uint64_t offset) const {
  363|  4.35M|    return IsValidRead(offset, sizeof(T));
  364|  4.35M|  }

_ZN11flatbuffers12ForAllFieldsEPKN10reflection6ObjectEbNSt3__18functionIFvPKNS0_5FieldEEEE:
  380|   274k|                  std::function<void(const reflection::Field*)> func) {
  381|   274k|  std::vector<uint32_t> field_to_id_map;
  382|   274k|  field_to_id_map.resize(object->fields()->size());
  383|       |
  384|       |  // Create the mapping of field ID to the index into the vector.
  385|  1.00M|  for (uint32_t i = 0; i < object->fields()->size(); ++i) {
  ------------------
  |  Branch (385:24): [True: 729k, False: 274k]
  ------------------
  386|   729k|    auto field = object->fields()->Get(i);
  387|   729k|    field_to_id_map[field->id()] = i;
  388|   729k|  }
  389|       |
  390|  1.00M|  for (size_t i = 0; i < field_to_id_map.size(); ++i) {
  ------------------
  |  Branch (390:22): [True: 729k, False: 274k]
  ------------------
  391|   729k|    func(object->fields()->Get(
  392|   729k|        field_to_id_map[reverse ? field_to_id_map.size() - (i + 1) : i]));
  ------------------
  |  Branch (392:25): [True: 0, False: 729k]
  ------------------
  393|   729k|  }
  394|   274k|}

_ZN11flatbuffers8LoadFileEPKcbPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  217|      2|bool LoadFile(const char* name, bool binary, std::string* buf) {
  218|      2|  FLATBUFFERS_ASSERT(g_load_file_function);
  219|      2|  return g_load_file_function(name, binary, buf);
  220|      2|}
_ZN11flatbuffers9DirExistsEPKc:
  227|      2|bool DirExists(const char* name) {
  228|       |  // clang-format off
  229|       |
  230|       |  #ifdef _WIN32
  231|       |    #define flatbuffers_stat _stat
  232|       |    #define FLATBUFFERS_S_IFDIR _S_IFDIR
  233|       |  #else
  234|      2|    #define flatbuffers_stat stat
  235|      2|    #define FLATBUFFERS_S_IFDIR S_IFDIR
  236|      2|  #endif
  237|       |  // clang-format on
  238|      2|  struct flatbuffers_stat file_info;
  239|      2|  if (flatbuffers_stat(name, &file_info) != 0) return false;
  ------------------
  |  |  234|      2|    #define flatbuffers_stat stat
  ------------------
  |  Branch (239:7): [True: 0, False: 2]
  ------------------
  240|      2|  return (file_info.st_mode & FLATBUFFERS_S_IFDIR) != 0;
  ------------------
  |  |  235|      2|    #define FLATBUFFERS_S_IFDIR S_IFDIR
  ------------------
  241|      2|}
_ZN11flatbuffers13ClassicLocaleC2Ev:
  416|      2|    : locale_(newlocale(LC_ALL, "C", nullptr)) {}
util.cpp:_ZN11flatbuffers12_GLOBAL__N_111LoadFileRawEPKcbPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   66|      2|static bool LoadFileRaw(const char* name, bool binary, std::string* buf) {
   67|      2|  if (DirExists(name)) return false;
  ------------------
  |  Branch (67:7): [True: 0, False: 2]
  ------------------
   68|      2|  std::ifstream ifs(name, binary ? std::ifstream::binary : std::ifstream::in);
  ------------------
  |  Branch (68:27): [True: 2, False: 0]
  ------------------
   69|      2|  if (!ifs.is_open()) return false;
  ------------------
  |  Branch (69:7): [True: 0, False: 2]
  ------------------
   70|      2|  if (binary) {
  ------------------
  |  Branch (70:7): [True: 2, False: 0]
  ------------------
   71|       |    // The fastest way to read a file into a string.
   72|      2|    ifs.seekg(0, std::ios::end);
   73|      2|    auto size = ifs.tellg();
   74|      2|    (*buf).resize(static_cast<size_t>(size));
   75|      2|    ifs.seekg(0, std::ios::beg);
   76|      2|    ifs.read(&(*buf)[0], (*buf).size());
   77|      2|  } else {
   78|       |    // This is slower, but works correctly on all platforms for text files.
   79|      0|    std::ostringstream oss;
   80|      0|    oss << ifs.rdbuf();
   81|      0|    *buf = oss.str();
   82|      0|  }
   83|      2|  return !ifs.bad();
   84|      2|}

_Z14TestFileExistsNSt3__14__fs10filesystem4pathE:
   12|      2|bool TestFileExists(std::filesystem::path file_path) {
   13|      2|  if (file_path.has_filename() && std::filesystem::exists(file_path))
  ------------------
  |  Branch (13:7): [True: 2, False: 0]
  |  Branch (13:35): [True: 2, False: 0]
  ------------------
   14|      2|    return true;
   15|       |
   16|      0|  TEST_OUTPUT_LINE("@DEBUG: file '%s' not found", file_path.string().c_str());
  ------------------
  |  |   16|      0|      do { printf(__VA_ARGS__); printf("\n"); } while(!flatbuffers::IsConstTrue(true))
  |  |  ------------------
  |  |  |  Branch (16:55): [Folded, False: 0]
  |  |  ------------------
  ------------------
   17|      0|  for (const auto& entry :
  ------------------
  |  Branch (17:26): [True: 0, False: 0]
  ------------------
   18|      0|       std::filesystem::directory_iterator(file_path.parent_path())) {
   19|      0|    TEST_OUTPUT_LINE("@DEBUG: parent path entry: '%s'",
  ------------------
  |  |   16|      0|      do { printf(__VA_ARGS__); printf("\n"); } while(!flatbuffers::IsConstTrue(true))
  |  |  ------------------
  |  |  |  Branch (16:55): [Folded, False: 0]
  |  |  ------------------
  ------------------
   20|      0|                     entry.path().string().c_str());
   21|      0|  }
   22|      0|  return false;
   23|      2|}
_Z16LoadBinarySchemaPKc:
   25|      2|std::string LoadBinarySchema(const char* file_name) {
   26|      2|  const auto file_path = exe_path_.parent_path() / file_name;
   27|      2|  TEST_EQ(true, TestFileExists(file_path));
  ------------------
  |  |   19|      2|#define TEST_EQ(exp, val) TestEq(exp, val, "'" #exp "' != '" #val "'", __FILE__, __LINE__, "")
  ------------------
   28|      2|  std::string schemafile;
   29|      2|  TEST_EQ(true,
  ------------------
  |  |   19|      2|#define TEST_EQ(exp, val) TestEq(exp, val, "'" #exp "' != '" #val "'", __FILE__, __LINE__, "")
  ------------------
   30|      2|          flatbuffers::LoadFile(file_path.string().c_str(), true, &schemafile));
   31|       |
   32|      2|  flatbuffers::Verifier verifier(
   33|      2|      reinterpret_cast<const uint8_t*>(schemafile.c_str()), schemafile.size());
   34|      2|  TEST_EQ(true, reflection::VerifySchemaBuffer(verifier));
  ------------------
  |  |   19|      2|#define TEST_EQ(exp, val) TestEq(exp, val, "'" #exp "' != '" #val "'", __FILE__, __LINE__, "")
  ------------------
   35|      2|  return schemafile;
   36|      2|}
LLVMFuzzerInitialize:
   38|      2|extern "C" int LLVMFuzzerInitialize(int*, char*** argv) {
   39|      2|  exe_path_ = (*argv)[0];
   40|      2|  static const std::string schema_file =
   41|      2|      LoadBinarySchema("annotated_binary.bfbs");
   42|      2|  schema_bfbs_ = reinterpret_cast<const uint8_t*>(schema_file.c_str());
   43|      2|  schema_bfbs_length_ = schema_file.size();
   44|      2|  return 0;
   45|      2|}
LLVMFuzzerTestOneInput:
   47|  3.32k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   48|  3.32k|  flatbuffers::BinaryAnnotator annotator(schema_bfbs_, schema_bfbs_length_,
   49|  3.32k|                                         data, size, false);
   50|       |
   51|  3.32k|  annotator.Annotate();
   52|  3.32k|  return 0;
   53|  3.32k|}

_Z6TestEqIbbEvT_T0_PKcS3_iS3_:
   94|      6|            const char* func) {
   95|      6|  if (static_cast<U>(expval) != val) {
  ------------------
  |  Branch (95:7): [True: 0, False: 6]
  ------------------
   96|      0|    TestFail(flatbuffers::NumToString(scalar_as_underlying(expval)).c_str(),
   97|      0|             flatbuffers::NumToString(scalar_as_underlying(val)).c_str(), exp,
   98|      0|             file, line, func);
   99|      0|  }
  100|      6|}