_ZN11flatbuffers10ReadScalarIjEET_PKv:
  426|  8.89M|T ReadScalar(const void *p) {
  427|  8.89M|  return EndianScalar(*reinterpret_cast<const T *>(p));
  428|  8.89M|}
_ZN11flatbuffers12EndianScalarIjEET_S1_:
  415|  12.2M|template<typename T> T EndianScalar(T t) {
  416|  12.2M|  #if FLATBUFFERS_LITTLEENDIAN
  417|  12.2M|    return t;
  418|       |  #else
  419|       |    return EndianSwap(t);
  420|       |  #endif
  421|  12.2M|}
_ZN11flatbuffers10ReadScalarIiEET_PKv:
  426|  54.6M|T ReadScalar(const void *p) {
  427|  54.6M|  return EndianScalar(*reinterpret_cast<const T *>(p));
  428|  54.6M|}
_ZN11flatbuffers12EndianScalarIiEET_S1_:
  415|  54.6M|template<typename T> T EndianScalar(T t) {
  416|  54.6M|  #if FLATBUFFERS_LITTLEENDIAN
  417|  54.6M|    return t;
  418|       |  #else
  419|       |    return EndianSwap(t);
  420|       |  #endif
  421|  54.6M|}
_ZN11flatbuffers10ReadScalarItEET_PKv:
  426|  72.1M|T ReadScalar(const void *p) {
  427|  72.1M|  return EndianScalar(*reinterpret_cast<const T *>(p));
  428|  72.1M|}
_ZN11flatbuffers12EndianScalarItEET_S1_:
  415|  72.1M|template<typename T> T EndianScalar(T t) {
  416|  72.1M|  #if FLATBUFFERS_LITTLEENDIAN
  417|  72.1M|    return t;
  418|       |  #else
  419|       |    return EndianSwap(t);
  420|       |  #endif
  421|  72.1M|}
_ZN11flatbuffers10ReadScalarIhEET_PKv:
  426|  3.32M|T ReadScalar(const void *p) {
  427|  3.32M|  return EndianScalar(*reinterpret_cast<const T *>(p));
  428|  3.32M|}
_ZN11flatbuffers12EndianScalarIhEET_S1_:
  415|  3.32M|template<typename T> T EndianScalar(T t) {
  416|  3.32M|  #if FLATBUFFERS_LITTLEENDIAN
  417|  3.32M|    return t;
  418|       |  #else
  419|       |    return EndianSwap(t);
  420|       |  #endif
  421|  3.32M|}
_ZN11flatbuffers10ReadScalarImEET_PKv:
  426|  5.06k|T ReadScalar(const void *p) {
  427|  5.06k|  return EndianScalar(*reinterpret_cast<const T *>(p));
  428|  5.06k|}
_ZN11flatbuffers12EndianScalarImEET_S1_:
  415|  5.06k|template<typename T> T EndianScalar(T t) {
  416|  5.06k|  #if FLATBUFFERS_LITTLEENDIAN
  417|  5.06k|    return t;
  418|       |  #else
  419|       |    return EndianSwap(t);
  420|       |  #endif
  421|  5.06k|}

_ZN11flatbuffers19BufferHasIdentifierEPKvPKcb:
  168|  5.34k|                                bool size_prefixed = false) {
  169|  5.34k|  return strncmp(GetBufferIdentifier(buf, size_prefixed), identifier,
  170|  5.34k|                 flatbuffers::kFileIdentifierLength) == 0;
  171|  5.34k|}
_ZN11flatbuffers19GetBufferIdentifierEPKvb:
  161|  5.34k|                                       bool size_prefixed = false) {
  162|  5.34k|  return reinterpret_cast<const char *>(buf) +
  163|  5.34k|         ((size_prefixed) ? 2 * sizeof(uoffset_t) : sizeof(uoffset_t));
  ------------------
  |  Branch (163:11): [True: 0, False: 5.34k]
  ------------------
  164|  5.34k|}
_ZN11flatbuffers14IndirectHelperINS_6OffsetINS_6StringEEEE4ReadEPKhj:
  115|   114k|  static return_type Read(const uint8_t *const p, const offset_type i) {
  116|       |    // Offsets are relative to themselves, so first update the pointer to
  117|       |    // point to the offset location.
  118|   114k|    const uint8_t *const offset_location = p + i * element_stride;
  119|       |
  120|       |    // Then read the scalar value of the offset (which may be 32 or 64-bits) and
  121|       |    // then determine the relative location from the offset location.
  122|   114k|    return reinterpret_cast<return_type>(
  123|   114k|        offset_location + ReadScalar<offset_type>(offset_location));
  124|   114k|  }
_ZN11flatbuffers14IndirectHelperINS_6OffsetIN6MyGame7Example7MonsterEEEE4ReadEPKhj:
  115|   385k|  static return_type Read(const uint8_t *const p, const offset_type i) {
  116|       |    // Offsets are relative to themselves, so first update the pointer to
  117|       |    // point to the offset location.
  118|   385k|    const uint8_t *const offset_location = p + i * element_stride;
  119|       |
  120|       |    // Then read the scalar value of the offset (which may be 32 or 64-bits) and
  121|       |    // then determine the relative location from the offset location.
  122|   385k|    return reinterpret_cast<return_type>(
  123|   385k|        offset_location + ReadScalar<offset_type>(offset_location));
  124|   385k|  }
_ZN11flatbuffers14IndirectHelperINS_6OffsetIN6MyGame7Example10ReferrableEEEE4ReadEPKhj:
  115|   899k|  static return_type Read(const uint8_t *const p, const offset_type i) {
  116|       |    // Offsets are relative to themselves, so first update the pointer to
  117|       |    // point to the offset location.
  118|   899k|    const uint8_t *const offset_location = p + i * element_stride;
  119|       |
  120|       |    // Then read the scalar value of the offset (which may be 32 or 64-bits) and
  121|       |    // then determine the relative location from the offset location.
  122|   899k|    return reinterpret_cast<return_type>(
  123|   899k|        offset_location + ReadScalar<offset_type>(offset_location));
  124|   899k|  }
_ZN11flatbuffers14IndirectHelperINS_6OffsetIN6MyGame7Example4StatEEEE4ReadEPKhj:
  115|  30.4k|  static return_type Read(const uint8_t *const p, const offset_type i) {
  116|       |    // Offsets are relative to themselves, so first update the pointer to
  117|       |    // point to the offset location.
  118|  30.4k|    const uint8_t *const offset_location = p + i * element_stride;
  119|       |
  120|       |    // Then read the scalar value of the offset (which may be 32 or 64-bits) and
  121|       |    // then determine the relative location from the offset location.
  122|  30.4k|    return reinterpret_cast<return_type>(
  123|  30.4k|        offset_location + ReadScalar<offset_type>(offset_location));
  124|  30.4k|  }

_ZN11flexbuffers22VerifyNestedFlexBufferEPKN11flatbuffers6VectorIhjEERNS0_8VerifierE:
   28|   512k|    flatbuffers::Verifier &verifier) {
   29|   512k|  if (!nested) return true;
  ------------------
  |  Branch (29:7): [True: 509k, False: 3.09k]
  ------------------
   30|  3.09k|  return verifier.Check(flexbuffers::VerifyBuffer(
   31|  3.09k|      nested->data(), nested->size(), verifier.GetFlexReuseTracker()));
   32|   512k|}

_ZN11flexbuffers12VerifyBufferEPKhmPNSt3__16vectorIhNS2_9allocatorIhEEEE:
 1927|  3.09k|                         std::vector<uint8_t> *reuse_tracker = nullptr) {
 1928|  3.09k|  Verifier verifier(buf, buf_len, reuse_tracker);
 1929|  3.09k|  return verifier.VerifyBuffer();
 1930|  3.09k|}
_ZN11flexbuffers8VerifierC2EPKhmPNSt3__16vectorIhNS3_9allocatorIhEEEEbm:
 1722|  3.09k|        reuse_tracker_(reuse_tracker) {
 1723|  3.09k|    FLATBUFFERS_ASSERT(size_ < FLATBUFFERS_MAX_BUFFER_SIZE);
 1724|  3.09k|    if (reuse_tracker_) {
  ------------------
  |  Branch (1724:9): [True: 0, False: 3.09k]
  ------------------
 1725|      0|      reuse_tracker_->clear();
 1726|      0|      reuse_tracker_->resize(size_, PackedType(BIT_WIDTH_8, FBT_NULL));
 1727|      0|    }
 1728|  3.09k|  }
_ZN11flexbuffers8Verifier12VerifyBufferEv:
 1904|  3.09k|  bool VerifyBuffer() {
 1905|  3.09k|    if (!Check(size_ >= 3)) return false;
  ------------------
  |  Branch (1905:9): [True: 8, False: 3.08k]
  ------------------
 1906|  3.08k|    auto end = buf_ + size_;
 1907|  3.08k|    auto byte_width = *--end;
 1908|  3.08k|    auto packed_type = *--end;
 1909|  3.08k|    return VerifyByteWidth(byte_width) && Check(end - buf_ >= byte_width) &&
  ------------------
  |  Branch (1909:12): [True: 3.05k, False: 36]
  |  Branch (1909:43): [True: 3.05k, False: 2]
  ------------------
 1910|  3.08k|           VerifyRef(Reference(end - byte_width, byte_width, packed_type));
  ------------------
  |  Branch (1910:12): [True: 2.24k, False: 806]
  ------------------
 1911|  3.09k|  }
_ZNK11flexbuffers8Verifier5CheckEb:
 1732|  7.18M|  bool Check(bool ok) const {
 1733|       |    // clang-format off
 1734|       |    #ifdef FLATBUFFERS_DEBUG_VERIFICATION_FAILURE
 1735|       |      FLATBUFFERS_ASSERT(ok);
 1736|       |    #endif
 1737|       |    // clang-format on
 1738|  7.18M|    return ok;
 1739|  7.18M|  }
_ZN11flexbuffers8Verifier15VerifyByteWidthEm:
 1758|  1.07M|  bool VerifyByteWidth(size_t width) {
 1759|  1.07M|    return Check(width == 1 || width == 2 || width == 4 || width == 8);
  ------------------
  |  Branch (1759:18): [True: 982k, False: 88.4k]
  |  Branch (1759:32): [True: 14.7k, False: 73.6k]
  |  Branch (1759:46): [True: 8.77k, False: 64.9k]
  |  Branch (1759:60): [True: 64.7k, False: 136]
  ------------------
 1760|  1.07M|  }
_ZN11flexbuffers8Verifier9VerifyRefENS_9ReferenceE:
 1851|  1.06M|  bool VerifyRef(Reference r) {
 1852|       |    // r.parent_width_ and r.data_ already verified.
 1853|  1.06M|    if (!VerifyByteWidth(r.byte_width_) || !VerifyType(r.type_)) {
  ------------------
  |  Branch (1853:9): [True: 0, False: 1.06M]
  |  Branch (1853:44): [True: 31, False: 1.06M]
  ------------------
 1854|     31|      return false;
 1855|     31|    }
 1856|  1.06M|    if (IsInline(r.type_)) {
  ------------------
  |  Branch (1856:9): [True: 186k, False: 879k]
  ------------------
 1857|       |      // Inline scalars, don't require further verification.
 1858|   186k|      return true;
 1859|   186k|    }
 1860|       |    // All remaining types are an offset.
 1861|   879k|    auto off = ReadUInt64(r.data_, r.parent_width_);
 1862|   879k|    if (!VerifyOffset(off, r.data_)) return false;
  ------------------
  |  Branch (1862:9): [True: 138, False: 879k]
  ------------------
 1863|   879k|    auto p = r.Indirect();
 1864|   879k|    if (!VerifyAlignment(p, r.byte_width_)) return false;
  ------------------
  |  Branch (1864:9): [True: 43, False: 879k]
  ------------------
 1865|   879k|    switch (r.type_) {
 1866|    990|      case FBT_INDIRECT_INT:
  ------------------
  |  Branch (1866:7): [True: 990, False: 878k]
  ------------------
 1867|  2.52k|      case FBT_INDIRECT_UINT:
  ------------------
  |  Branch (1867:7): [True: 1.53k, False: 877k]
  ------------------
 1868|  5.08k|      case FBT_INDIRECT_FLOAT: return VerifyFromPointer(p, r.byte_width_);
  ------------------
  |  Branch (1868:7): [True: 2.55k, False: 876k]
  ------------------
 1869|   211k|      case FBT_KEY: return VerifyKey(p);
  ------------------
  |  Branch (1869:7): [True: 211k, False: 668k]
  ------------------
 1870|  5.30k|      case FBT_MAP:
  ------------------
  |  Branch (1870:7): [True: 5.30k, False: 874k]
  ------------------
 1871|  5.30k|        return VerifyVector(r, p, FBT_NULL) && VerifyKeys(p, r.byte_width_);
  ------------------
  |  Branch (1871:16): [True: 1.74k, False: 3.55k]
  |  Branch (1871:48): [True: 1.50k, False: 242]
  ------------------
 1872|   633k|      case FBT_VECTOR: return VerifyVector(r, p, FBT_NULL);
  ------------------
  |  Branch (1872:7): [True: 633k, False: 245k]
  ------------------
 1873|  1.28k|      case FBT_VECTOR_INT: return VerifyVector(r, p, FBT_INT);
  ------------------
  |  Branch (1873:7): [True: 1.28k, False: 878k]
  ------------------
 1874|  1.36k|      case FBT_VECTOR_BOOL:
  ------------------
  |  Branch (1874:7): [True: 1.36k, False: 878k]
  ------------------
 1875|  1.87k|      case FBT_VECTOR_UINT: return VerifyVector(r, p, FBT_UINT);
  ------------------
  |  Branch (1875:7): [True: 508, False: 879k]
  ------------------
 1876|  1.57k|      case FBT_VECTOR_FLOAT: return VerifyVector(r, p, FBT_FLOAT);
  ------------------
  |  Branch (1876:7): [True: 1.57k, False: 877k]
  ------------------
 1877|  2.87k|      case FBT_VECTOR_KEY: return VerifyVector(r, p, FBT_KEY);
  ------------------
  |  Branch (1877:7): [True: 2.87k, False: 876k]
  ------------------
 1878|    742|      case FBT_VECTOR_STRING_DEPRECATED:
  ------------------
  |  Branch (1878:7): [True: 742, False: 878k]
  ------------------
 1879|       |        // Use of FBT_KEY here intentional, see elsewhere.
 1880|    742|        return VerifyVector(r, p, FBT_KEY);
 1881|    507|      case FBT_BLOB: return VerifyVector(r, p, FBT_UINT);
  ------------------
  |  Branch (1881:7): [True: 507, False: 879k]
  ------------------
 1882|  1.99k|      case FBT_STRING:
  ------------------
  |  Branch (1882:7): [True: 1.99k, False: 877k]
  ------------------
 1883|  1.99k|        return VerifyVector(r, p, FBT_UINT) &&
  ------------------
  |  Branch (1883:16): [True: 1.96k, False: 29]
  ------------------
 1884|  1.99k|               VerifyTerminator(String(p, r.byte_width_));
  ------------------
  |  Branch (1884:16): [True: 1.96k, False: 3]
  ------------------
 1885|  1.72k|      case FBT_VECTOR_INT2:
  ------------------
  |  Branch (1885:7): [True: 1.72k, False: 877k]
  ------------------
 1886|  2.69k|      case FBT_VECTOR_UINT2:
  ------------------
  |  Branch (1886:7): [True: 968, False: 878k]
  ------------------
 1887|  3.45k|      case FBT_VECTOR_FLOAT2:
  ------------------
  |  Branch (1887:7): [True: 763, False: 878k]
  ------------------
 1888|  4.59k|      case FBT_VECTOR_INT3:
  ------------------
  |  Branch (1888:7): [True: 1.13k, False: 878k]
  ------------------
 1889|  5.43k|      case FBT_VECTOR_UINT3:
  ------------------
  |  Branch (1889:7): [True: 836, False: 878k]
  ------------------
 1890|  9.68k|      case FBT_VECTOR_FLOAT3:
  ------------------
  |  Branch (1890:7): [True: 4.25k, False: 875k]
  ------------------
 1891|  10.5k|      case FBT_VECTOR_INT4:
  ------------------
  |  Branch (1891:7): [True: 892, False: 878k]
  ------------------
 1892|  11.9k|      case FBT_VECTOR_UINT4:
  ------------------
  |  Branch (1892:7): [True: 1.39k, False: 878k]
  ------------------
 1893|  13.2k|      case FBT_VECTOR_FLOAT4: {
  ------------------
  |  Branch (1893:7): [True: 1.30k, False: 878k]
  ------------------
 1894|  13.2k|        uint8_t len = 0;
 1895|  13.2k|        auto vtype = ToFixedTypedVectorElementType(r.type_, &len);
 1896|  13.2k|        if (!VerifyType(vtype)) return false;
  ------------------
  |  Branch (1896:13): [True: 0, False: 13.2k]
  ------------------
 1897|  13.2k|        return VerifyFromPointer(p, static_cast<size_t>(r.byte_width_) * len);
 1898|  13.2k|      }
 1899|      7|      default: return false;
  ------------------
  |  Branch (1899:7): [True: 7, False: 879k]
  ------------------
 1900|   879k|    }
 1901|   879k|  }
_ZN11flexbuffers8Verifier10VerifyTypeEi:
 1762|  1.07M|  bool VerifyType(int type) { return Check(type >= 0 && type < FBT_MAX_TYPE); }
  ------------------
  |  Branch (1762:44): [True: 1.07M, False: 0]
  |  Branch (1762:57): [True: 1.07M, False: 31]
  ------------------
_ZN11flexbuffers8IsInlineENS_4TypeE:
   89|  1.07M|inline bool IsInline(Type t) { return t <= FBT_FLOAT || t == FBT_BOOL; }
  ------------------
  |  Branch (89:39): [True: 193k, False: 879k]
  |  Branch (89:57): [True: 273, False: 879k]
  ------------------
_ZN11flexbuffers10ReadUInt64EPKhh:
  154|  3.06M|inline uint64_t ReadUInt64(const uint8_t *data, uint8_t byte_width) {
  155|       |  // This is the "hottest" function (all offset lookups use this), so worth
  156|       |  // optimizing if possible.
  157|       |  // TODO: GCC apparently replaces memcpy by a rep movsb, but only if count is a
  158|       |  // constant, which here it isn't. Test if memcpy is still faster than
  159|       |  // the conditionals in ReadSizedScalar. Can also use inline asm.
  160|       |
  161|       |  // clang-format off
  162|       |  #if defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)
  163|       |  // This is 64-bit Windows only, __movsb does not work on 32-bit Windows.
  164|       |    uint64_t u = 0;
  165|       |    __movsb(reinterpret_cast<uint8_t *>(&u),
  166|       |            reinterpret_cast<const uint8_t *>(data), byte_width);
  167|       |    return flatbuffers::EndianScalar(u);
  168|       |  #else
  169|  3.06M|    return ReadSizedScalar<uint64_t, uint8_t, uint16_t, uint32_t, uint64_t>(
  170|  3.06M|             data, byte_width);
  171|  3.06M|  #endif
  172|       |  // clang-format on
  173|  3.06M|}
_ZN11flexbuffers15ReadSizedScalarImhtjmEET_PKhh:
  139|  3.06M|R ReadSizedScalar(const uint8_t *data, uint8_t byte_width) {
  140|  3.06M|  return byte_width < 4
  ------------------
  |  Branch (140:10): [True: 3.04M, False: 11.3k]
  ------------------
  141|  3.06M|             ? (byte_width < 2
  ------------------
  |  Branch (141:17): [True: 2.79M, False: 251k]
  ------------------
  142|  3.04M|                    ? static_cast<R>(flatbuffers::ReadScalar<T1>(data))
  143|  3.04M|                    : static_cast<R>(flatbuffers::ReadScalar<T2>(data)))
  144|  3.06M|             : (byte_width < 8
  ------------------
  |  Branch (144:17): [True: 6.33k, False: 5.06k]
  ------------------
  145|  11.3k|                    ? static_cast<R>(flatbuffers::ReadScalar<T4>(data))
  146|  11.3k|                    : static_cast<R>(flatbuffers::ReadScalar<T8>(data)));
  147|  3.06M|}
_ZN11flexbuffers8Verifier12VerifyOffsetEmPKh:
 1764|   881k|  bool VerifyOffset(uint64_t off, const uint8_t *p) {
 1765|   881k|    return Check(off <= static_cast<uint64_t>(size_)) &&
  ------------------
  |  Branch (1765:12): [True: 881k, False: 165]
  ------------------
 1766|   881k|           off <= static_cast<uint64_t>(p - buf_);
  ------------------
  |  Branch (1766:12): [True: 881k, False: 46]
  ------------------
 1767|   881k|  }
_ZNK11flexbuffers9Reference8IndirectEv:
  790|   879k|  const uint8_t *Indirect() const {
  791|   879k|    return flexbuffers::Indirect(data_, parent_width_);
  792|   879k|  }
_ZN11flexbuffers8IndirectEPKhh:
  180|   879k|inline const uint8_t *Indirect(const uint8_t *offset, uint8_t byte_width) {
  181|   879k|  return offset - ReadUInt64(offset, byte_width);
  182|   879k|}
_ZNK11flexbuffers8Verifier15VerifyAlignmentEPKhm:
 1769|   879k|  bool VerifyAlignment(const uint8_t *p, size_t size) const {
 1770|   879k|    auto o = static_cast<size_t>(p - buf_);
 1771|   879k|    return Check((o & (size - 1)) == 0 || !check_alignment_);
  ------------------
  |  Branch (1771:18): [True: 879k, False: 43]
  |  Branch (1771:43): [True: 0, False: 43]
  ------------------
 1772|   879k|  }
_ZN11flexbuffers8Verifier17VerifyFromPointerEPKhm:
 1749|  1.31M|  bool VerifyFromPointer(const uint8_t *p, size_t len) {
 1750|  1.31M|    auto o = static_cast<size_t>(p - buf_);
 1751|  1.31M|    return VerifyFrom(o, len);
 1752|  1.31M|  }
_ZNK11flexbuffers8Verifier10VerifyFromEmm:
 1742|  1.31M|  bool VerifyFrom(size_t elem, size_t elem_len) const {
 1743|  1.31M|    return Check(elem_len < size_ && elem <= size_ - elem_len);
  ------------------
  |  Branch (1743:18): [True: 1.31M, False: 180]
  |  Branch (1743:38): [True: 1.31M, False: 40]
  ------------------
 1744|  1.31M|  }
_ZN11flexbuffers8Verifier9VerifyKeyEPKh:
 1837|   211k|  bool VerifyKey(const uint8_t *p) {
 1838|   211k|    FLEX_CHECK_VERIFIED(p, PackedType(BIT_WIDTH_8, FBT_KEY));
  ------------------
  |  | 1776|   211k|  if (reuse_tracker_) {                                         \
  |  |  ------------------
  |  |  |  Branch (1776:7): [True: 0, False: 211k]
  |  |  ------------------
  |  | 1777|      0|    auto packed_type = PACKED_TYPE;                             \
  |  | 1778|      0|    auto existing = (*reuse_tracker_)[P - buf_];                \
  |  | 1779|      0|    if (existing == packed_type) return true;                   \
  |  |  ------------------
  |  |  |  Branch (1779:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 1780|      0|    /* Fail verification if already set with different type! */ \
  |  | 1781|      0|    if (!Check(existing == 0)) return false;                    \
  |  |  ------------------
  |  |  |  Branch (1781:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 1782|      0|    (*reuse_tracker_)[P - buf_] = packed_type;                  \
  |  | 1783|      0|  }
  ------------------
 1839|  1.89M|    while (p < buf_ + size_)
  ------------------
  |  Branch (1839:12): [True: 1.89M, False: 0]
  ------------------
 1840|  1.89M|      if (*p++) return true;
  ------------------
  |  Branch (1840:11): [True: 211k, False: 1.68M]
  ------------------
 1841|      0|    return false;
 1842|   211k|  }
_ZN11flexbuffers8Verifier12VerifyVectorENS_9ReferenceEPKhNS_4TypeE:
 1785|   651k|  bool VerifyVector(Reference r, const uint8_t *p, Type elem_type) {
 1786|       |    // Any kind of nesting goes thru this function, so guard against that
 1787|       |    // here, both with simple nesting checks, and the reuse tracker if on.
 1788|   651k|    depth_++;
 1789|   651k|    num_vectors_++;
 1790|   651k|    if (!Check(depth_ <= max_depth_ && num_vectors_ <= max_vectors_))
  ------------------
  |  Branch (1790:9): [True: 178, False: 651k]
  |  Branch (1790:16): [True: 651k, False: 13]
  |  Branch (1790:40): [True: 651k, False: 165]
  ------------------
 1791|    178|      return false;
 1792|   651k|    auto size_byte_width = r.byte_width_;
 1793|   651k|    if (!VerifyBeforePointer(p, size_byte_width)) return false;
  ------------------
  |  Branch (1793:9): [True: 6, False: 651k]
  ------------------
 1794|   651k|    FLEX_CHECK_VERIFIED(p - size_byte_width,
  ------------------
  |  | 1776|   651k|  if (reuse_tracker_) {                                         \
  |  |  ------------------
  |  |  |  Branch (1776:7): [True: 0, False: 651k]
  |  |  ------------------
  |  | 1777|      0|    auto packed_type = PACKED_TYPE;                             \
  |  | 1778|      0|    auto existing = (*reuse_tracker_)[P - buf_];                \
  |  | 1779|      0|    if (existing == packed_type) return true;                   \
  |  |  ------------------
  |  |  |  Branch (1779:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 1780|      0|    /* Fail verification if already set with different type! */ \
  |  | 1781|      0|    if (!Check(existing == 0)) return false;                    \
  |  |  ------------------
  |  |  |  Branch (1781:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 1782|      0|    (*reuse_tracker_)[P - buf_] = packed_type;                  \
  |  | 1783|      0|  }
  ------------------
 1795|   651k|                        PackedType(Builder::WidthB(size_byte_width), r.type_));
 1796|   651k|    auto sized = Sized(p, size_byte_width);
 1797|   651k|    auto num_elems = sized.size();
 1798|   651k|    auto elem_byte_width = r.type_ == FBT_STRING || r.type_ == FBT_BLOB
  ------------------
  |  Branch (1798:28): [True: 1.99k, False: 649k]
  |  Branch (1798:53): [True: 505, False: 648k]
  ------------------
 1799|   651k|                               ? uint8_t(1)
 1800|   651k|                               : r.byte_width_;
 1801|   651k|    auto max_elems = SIZE_MAX / elem_byte_width;
 1802|   651k|    if (!Check(num_elems < max_elems))
  ------------------
  |  Branch (1802:9): [True: 8, False: 651k]
  ------------------
 1803|      8|      return false;  // Protect against byte_size overflowing.
 1804|   651k|    auto byte_size = num_elems * elem_byte_width;
 1805|   651k|    if (!VerifyFromPointer(p, byte_size)) return false;
  ------------------
  |  Branch (1805:9): [True: 186, False: 651k]
  ------------------
 1806|   651k|    if (elem_type == FBT_NULL) {
  ------------------
  |  Branch (1806:9): [True: 639k, False: 12.1k]
  ------------------
 1807|       |      // Verify type bytes after the vector.
 1808|   639k|      if (!VerifyFromPointer(p + byte_size, num_elems)) return false;
  ------------------
  |  Branch (1808:11): [True: 10, False: 639k]
  ------------------
 1809|   639k|      auto v = Vector(p, size_byte_width);
 1810|  1.48M|      for (size_t i = 0; i < num_elems; i++)
  ------------------
  |  Branch (1810:26): [True: 854k, False: 634k]
  ------------------
 1811|   854k|        if (!VerifyRef(v[i])) return false;
  ------------------
  |  Branch (1811:13): [True: 4.99k, False: 849k]
  ------------------
 1812|   639k|    } else if (elem_type == FBT_KEY) {
  ------------------
  |  Branch (1812:16): [True: 5.11k, False: 7.06k]
  ------------------
 1813|  5.11k|      auto v = TypedVector(p, elem_byte_width, FBT_KEY);
 1814|   214k|      for (size_t i = 0; i < num_elems; i++)
  ------------------
  |  Branch (1814:26): [True: 208k, False: 5.07k]
  ------------------
 1815|   208k|        if (!VerifyRef(v[i])) return false;
  ------------------
  |  Branch (1815:13): [True: 39, False: 208k]
  ------------------
 1816|  7.06k|    } else {
 1817|  7.06k|      FLATBUFFERS_ASSERT(IsInline(elem_type));
 1818|  7.06k|    }
 1819|   646k|    depth_--;
 1820|   646k|    return true;
 1821|   651k|  }
_ZN11flexbuffers8Verifier19VerifyBeforePointerEPKhm:
 1753|   653k|  bool VerifyBeforePointer(const uint8_t *p, size_t len) {
 1754|   653k|    auto o = static_cast<size_t>(p - buf_);
 1755|   653k|    return VerifyBefore(o, len);
 1756|   653k|  }
_ZNK11flexbuffers8Verifier12VerifyBeforeEmm:
 1745|   653k|  bool VerifyBefore(size_t elem, size_t elem_len) const {
 1746|   653k|    return Check(elem_len <= elem);
 1747|   653k|  }
_ZN11flexbuffers5SizedC2EPKhh:
  227|  1.29M|      : Object(data, byte_width), size_(read_size()) {}
_ZN11flexbuffers6ObjectC2EPKhh:
  215|  1.29M|      : data_(data), byte_width_(byte_width) {}
_ZNK11flexbuffers5Sized9read_sizeEv:
  233|  1.29M|  size_t read_size() const {
  234|  1.29M|    return static_cast<size_t>(ReadUInt64(data_ - byte_width_, byte_width_));
  235|  1.29M|  }
_ZNK11flexbuffers5Sized4sizeEv:
  231|  1.71M|  size_t size() const { return size_; }
_ZN11flexbuffers6VectorC2EPKhh:
  275|   639k|  Vector(const uint8_t *data, uint8_t byte_width) : Sized(data, byte_width) {}
_ZNK11flexbuffers6VectorixEm:
  875|   854k|inline Reference Vector::operator[](size_t i) const {
  876|   854k|  auto len = size();
  877|   854k|  if (i >= len) return Reference(nullptr, 1, NullPackedType());
  ------------------
  |  Branch (877:7): [True: 0, False: 854k]
  ------------------
  878|   854k|  auto packed_type = (data_ + len * byte_width_)[i];
  879|   854k|  auto elem = data_ + i * byte_width_;
  880|   854k|  return Reference(elem, byte_width_, packed_type);
  881|   854k|}
_ZN11flexbuffers11TypedVectorC2EPKhhNS_4TypeE:
  289|  5.11k|      : Sized(data, byte_width), type_(element_type) {}
_ZNK11flexbuffers11TypedVectorixEm:
  883|   208k|inline Reference TypedVector::operator[](size_t i) const {
  884|   208k|  auto len = size();
  885|   208k|  if (i >= len) return Reference(nullptr, 1, NullPackedType());
  ------------------
  |  Branch (885:7): [True: 0, False: 208k]
  ------------------
  886|   208k|  auto elem = data_ + i * byte_width_;
  887|   208k|  return Reference(elem, byte_width_, 1, type_);
  888|   208k|}
_ZN11flexbuffers9ReferenceC2EPKhhhNS_4TypeE:
  407|   210k|        type_(type) {}
_ZN11flexbuffers8Verifier10VerifyKeysEPKhh:
 1823|  1.74k|  bool VerifyKeys(const uint8_t *p, uint8_t byte_width) {
 1824|       |    // The vector part of the map has already been verified.
 1825|  1.74k|    const size_t num_prefixed_fields = 3;
 1826|  1.74k|    if (!VerifyBeforePointer(p, byte_width * num_prefixed_fields)) return false;
  ------------------
  |  Branch (1826:9): [True: 2, False: 1.74k]
  ------------------
 1827|  1.74k|    p -= byte_width * num_prefixed_fields;
 1828|  1.74k|    auto off = ReadUInt64(p, byte_width);
 1829|  1.74k|    if (!VerifyOffset(off, p)) return false;
  ------------------
  |  Branch (1829:9): [True: 73, False: 1.67k]
  ------------------
 1830|  1.67k|    auto key_byte_with =
 1831|  1.67k|        static_cast<uint8_t>(ReadUInt64(p + byte_width, byte_width));
 1832|  1.67k|    if (!VerifyByteWidth(key_byte_with)) return false;
  ------------------
  |  Branch (1832:9): [True: 100, False: 1.57k]
  ------------------
 1833|  1.57k|    return VerifyVector(Reference(p, byte_width, key_byte_with, FBT_VECTOR_KEY),
 1834|  1.57k|                        p - off, FBT_KEY);
 1835|  1.67k|  }
_ZN11flexbuffers8Verifier16VerifyTerminatorERKNS_6StringE:
 1846|  1.96k|  bool VerifyTerminator(const String &s) {
 1847|  1.96k|    return VerifyFromPointer(reinterpret_cast<const uint8_t *>(s.c_str()),
 1848|  1.96k|                             s.size() + 1);
 1849|  1.96k|  }
_ZNK11flexbuffers6String5c_strEv:
  250|  1.96k|  const char *c_str() const { return reinterpret_cast<const char *>(data_); }
_ZN11flexbuffers6StringC2EPKhh:
  244|  1.96k|  String(const uint8_t *data, uint8_t byte_width) : Sized(data, byte_width) {}
_ZN11flexbuffers29ToFixedTypedVectorElementTypeENS_4TypeEPh:
  120|  13.2k|inline Type ToFixedTypedVectorElementType(Type t, uint8_t *len) {
  121|  13.2k|  FLATBUFFERS_ASSERT(IsFixedTypedVector(t));
  122|      0|  auto fixed_type = t - FBT_VECTOR_INT2;
  123|  13.2k|  *len = static_cast<uint8_t>(fixed_type / 3 +
  124|  13.2k|                              2);  // 3 types each, starting from length 2.
  125|  13.2k|  return static_cast<Type>(fixed_type % 3 + FBT_INT);
  126|  13.2k|}
_ZN11flexbuffers18IsFixedTypedVectorENS_4TypeE:
  100|  13.2k|inline bool IsFixedTypedVector(Type t) {
  101|  13.2k|  return t >= FBT_VECTOR_INT2 && t <= FBT_VECTOR_FLOAT4;
  ------------------
  |  Branch (101:10): [True: 13.2k, False: 0]
  |  Branch (101:34): [True: 13.2k, False: 0]
  ------------------
  102|  13.2k|}
_ZN11flexbuffers9ReferenceC2EPKhhh:
  413|   857k|        type_(static_cast<Type>(packed_type >> 2)) {}

_ZNK11flatbuffers5Table16VerifyTableStartERNS_8VerifierE:
  119|  1.93M|  bool VerifyTableStart(Verifier &verifier) const {
  120|  1.93M|    return verifier.VerifyTableStart(data_);
  121|  1.93M|  }
_ZNK11flatbuffers5Table11VerifyFieldIN6MyGame7Example4Vec3EEEbRKNS_8VerifierEtm:
  126|   515k|                   size_t align) const {
  127|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  128|       |    // VerifyTable().
  129|   515k|    auto field_offset = GetOptionalFieldOffset(field);
  130|       |    // Check the actual field.
  131|   515k|    return !field_offset || verifier.VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (131:12): [True: 511k, False: 4.68k]
  |  Branch (131:29): [True: 4.63k, False: 49]
  ------------------
  132|   515k|  }
_ZNK11flatbuffers5Table22GetOptionalFieldOffsetEt:
   35|  52.7M|  voffset_t GetOptionalFieldOffset(voffset_t field) const {
   36|       |    // The vtable offset is always at the start.
   37|  52.7M|    auto vtable = GetVTable();
   38|       |    // The first element is the size of the vtable (fields + type id + itself).
   39|  52.7M|    auto vtsize = ReadScalar<voffset_t>(vtable);
   40|       |    // If the field we're accessing is outside the vtable, we're reading older
   41|       |    // data, so it's the same as if the offset was 0 (not present).
   42|  52.7M|    return field < vtsize ? ReadScalar<voffset_t>(vtable + field) : 0;
  ------------------
  |  Branch (42:12): [True: 15.3M, False: 37.3M]
  ------------------
   43|  52.7M|  }
_ZNK11flatbuffers5Table9GetVTableEv:
   29|  52.7M|  const uint8_t *GetVTable() const {
   30|  52.7M|    return data_ - ReadScalar<soffset_t>(data_);
   31|  52.7M|  }
_ZNK11flatbuffers5Table11VerifyFieldIsEEbRKNS_8VerifierEtm:
  126|  1.03M|                   size_t align) const {
  127|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  128|       |    // VerifyTable().
  129|  1.03M|    auto field_offset = GetOptionalFieldOffset(field);
  130|       |    // Check the actual field.
  131|  1.03M|    return !field_offset || verifier.VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (131:12): [True: 522k, False: 509k]
  |  Branch (131:29): [True: 509k, False: 49]
  ------------------
  132|  1.03M|  }
_ZNK11flatbuffers5Table20VerifyOffsetRequiredIjEEbRKNS_8VerifierEt:
  151|   515k|  bool VerifyOffsetRequired(const Verifier &verifier, voffset_t field) const {
  152|   515k|    auto field_offset = GetOptionalFieldOffset(field);
  153|   515k|    return verifier.Check(field_offset != 0) &&
  ------------------
  |  Branch (153:12): [True: 515k, False: 114]
  ------------------
  154|   515k|           verifier.VerifyOffset<OffsetT>(data_, field_offset);
  ------------------
  |  Branch (154:12): [True: 515k, False: 103]
  ------------------
  155|   515k|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6StringEjEET_t:
   58|   669k|  P GetPointer(voffset_t field) const {
   59|   669k|    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
   60|   669k|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6StringEjEET_t:
   51|   669k|  P GetPointer(voffset_t field) {
   52|   669k|    auto field_offset = GetOptionalFieldOffset(field);
   53|   669k|    auto p = data_ + field_offset;
   54|   669k|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (54:12): [True: 519k, False: 150k]
  ------------------
   55|   669k|                        : nullptr;
   56|   669k|  }
_ZNK11flatbuffers5Table12VerifyOffsetIjEEbRKNS_8VerifierEt:
  145|  13.4M|  bool VerifyOffset(const Verifier &verifier, voffset_t field) const {
  146|  13.4M|    auto field_offset = GetOptionalFieldOffset(field);
  147|  13.4M|    return !field_offset || verifier.VerifyOffset<OffsetT>(data_, field_offset);
  ------------------
  |  Branch (147:12): [True: 11.4M, False: 1.96M]
  |  Branch (147:29): [True: 1.96M, False: 709]
  ------------------
  148|  13.4M|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorIhjEEjEET_t:
   58|  4.09M|  P GetPointer(voffset_t field) const {
   59|  4.09M|    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
   60|  4.09M|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorIhjEEjEET_t:
   51|  4.09M|  P GetPointer(voffset_t field) {
   52|  4.09M|    auto field_offset = GetOptionalFieldOffset(field);
   53|  4.09M|    auto p = data_ + field_offset;
   54|  4.09M|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (54:12): [True: 518k, False: 3.58M]
  ------------------
   55|  4.09M|                        : nullptr;
   56|  4.09M|  }
_ZNK11flatbuffers5Table11VerifyFieldIhEEbRKNS_8VerifierEtm:
  126|  2.56M|                   size_t align) const {
  127|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  128|       |    // VerifyTable().
  129|  2.56M|    auto field_offset = GetOptionalFieldOffset(field);
  130|       |    // Check the actual field.
  131|  2.56M|    return !field_offset || verifier.VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (131:12): [True: 1.90M, False: 666k]
  |  Branch (131:29): [True: 666k, False: 182]
  ------------------
  132|  2.56M|  }
_ZNK11flatbuffers5Table10GetPointerIPKvjEET_t:
   58|  1.53M|  P GetPointer(voffset_t field) const {
   59|  1.53M|    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
   60|  1.53M|  }
_ZN11flatbuffers5Table10GetPointerIPKvjEET_t:
   51|  1.53M|  P GetPointer(voffset_t field) {
   52|  1.53M|    auto field_offset = GetOptionalFieldOffset(field);
   53|  1.53M|    auto p = data_ + field_offset;
   54|  1.53M|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (54:12): [True: 260k, False: 1.27M]
  ------------------
   55|  1.53M|                        : nullptr;
   56|  1.53M|  }
_ZNK11flatbuffers5Table8GetFieldIhEET_tS2_:
   45|  1.53M|  template<typename T> T GetField(voffset_t field, T defaultval) const {
   46|  1.53M|    auto field_offset = GetOptionalFieldOffset(field);
   47|  1.53M|    return field_offset ? ReadScalar<T>(data_ + field_offset) : defaultval;
  ------------------
  |  Branch (47:12): [True: 527k, False: 1.00M]
  ------------------
   48|  1.53M|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorIPKN6MyGame7Example4TestEjEEjEET_t:
   58|  1.02M|  P GetPointer(voffset_t field) const {
   59|  1.02M|    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
   60|  1.02M|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorIPKN6MyGame7Example4TestEjEEjEET_t:
   51|  1.02M|  P GetPointer(voffset_t field) {
   52|  1.02M|    auto field_offset = GetOptionalFieldOffset(field);
   53|  1.02M|    auto p = data_ + field_offset;
   54|  1.02M|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (54:12): [True: 268k, False: 758k]
  ------------------
   55|  1.02M|                        : nullptr;
   56|  1.02M|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetINS_6StringEEEjEEjEET_t:
   58|  2.05M|  P GetPointer(voffset_t field) const {
   59|  2.05M|    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
   60|  2.05M|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetINS_6StringEEEjEEjEET_t:
   51|  2.05M|  P GetPointer(voffset_t field) {
   52|  2.05M|    auto field_offset = GetOptionalFieldOffset(field);
   53|  2.05M|    auto p = data_ + field_offset;
   54|  2.05M|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (54:12): [True: 18.9k, False: 2.03M]
  ------------------
   55|  2.05M|                        : nullptr;
   56|  2.05M|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN6MyGame7Example7MonsterEEEjEEjEET_t:
   58|  1.02M|  P GetPointer(voffset_t field) const {
   59|  1.02M|    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
   60|  1.02M|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN6MyGame7Example7MonsterEEEjEEjEET_t:
   51|  1.02M|  P GetPointer(voffset_t field) {
   52|  1.02M|    auto field_offset = GetOptionalFieldOffset(field);
   53|  1.02M|    auto p = data_ + field_offset;
   54|  1.02M|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (54:12): [True: 509k, False: 520k]
  ------------------
   55|  1.02M|                        : nullptr;
   56|  1.02M|  }
_ZNK11flatbuffers5Table10GetPointerIPKN6MyGame7Example7MonsterEjEET_t:
   58|   513k|  P GetPointer(voffset_t field) const {
   59|   513k|    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
   60|   513k|  }
_ZN11flatbuffers5Table10GetPointerIPKN6MyGame7Example7MonsterEjEET_t:
   51|   513k|  P GetPointer(voffset_t field) {
   52|   513k|    auto field_offset = GetOptionalFieldOffset(field);
   53|   513k|    auto p = data_ + field_offset;
   54|   513k|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (54:12): [True: 122k, False: 390k]
  ------------------
   55|   513k|                        : nullptr;
   56|   513k|  }
_ZNK11flatbuffers5Table11VerifyFieldItEEbRKNS_8VerifierEtm:
  126|   153k|                   size_t align) const {
  127|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  128|       |    // VerifyTable().
  129|   153k|    auto field_offset = GetOptionalFieldOffset(field);
  130|       |    // Check the actual field.
  131|   153k|    return !field_offset || verifier.VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (131:12): [True: 150k, False: 3.01k]
  |  Branch (131:29): [True: 3.00k, False: 15]
  ------------------
  132|   153k|  }
_ZNK11flatbuffers5Table10GetPointerIPKN6MyGame7Example4StatEjEET_t:
   58|   512k|  P GetPointer(voffset_t field) const {
   59|   512k|    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
   60|   512k|  }
_ZN11flatbuffers5Table10GetPointerIPKN6MyGame7Example4StatEjEET_t:
   51|   512k|  P GetPointer(voffset_t field) {
   52|   512k|    auto field_offset = GetOptionalFieldOffset(field);
   53|   512k|    auto p = data_ + field_offset;
   54|   512k|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (54:12): [True: 123k, False: 389k]
  ------------------
   55|   512k|                        : nullptr;
   56|   512k|  }
_ZNK11flatbuffers5Table11VerifyFieldIiEEbRKNS_8VerifierEtm:
  126|  1.02M|                   size_t align) const {
  127|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  128|       |    // VerifyTable().
  129|  1.02M|    auto field_offset = GetOptionalFieldOffset(field);
  130|       |    // Check the actual field.
  131|  1.02M|    return !field_offset || verifier.VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (131:12): [True: 1.02M, False: 3.85k]
  |  Branch (131:29): [True: 3.80k, False: 44]
  ------------------
  132|  1.02M|  }
_ZNK11flatbuffers5Table11VerifyFieldIjEEbRKNS_8VerifierEtm:
  126|  1.02M|                   size_t align) const {
  127|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  128|       |    // VerifyTable().
  129|  1.02M|    auto field_offset = GetOptionalFieldOffset(field);
  130|       |    // Check the actual field.
  131|  1.02M|    return !field_offset || verifier.VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (131:12): [True: 766k, False: 258k]
  |  Branch (131:29): [True: 258k, False: 60]
  ------------------
  132|  1.02M|  }
_ZNK11flatbuffers5Table11VerifyFieldIlEEbRKNS_8VerifierEtm:
  126|  1.17M|                   size_t align) const {
  127|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  128|       |    // VerifyTable().
  129|  1.17M|    auto field_offset = GetOptionalFieldOffset(field);
  130|       |    // Check the actual field.
  131|  1.17M|    return !field_offset || verifier.VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (131:12): [True: 1.17M, False: 6.33k]
  |  Branch (131:29): [True: 6.25k, False: 86]
  ------------------
  132|  1.17M|  }
_ZNK11flatbuffers5Table11VerifyFieldImEEbRKNS_8VerifierEtm:
  126|  4.47M|                   size_t align) const {
  127|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  128|       |    // VerifyTable().
  129|  4.47M|    auto field_offset = GetOptionalFieldOffset(field);
  130|       |    // Check the actual field.
  131|  4.47M|    return !field_offset || verifier.VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (131:12): [True: 4.21M, False: 265k]
  |  Branch (131:29): [True: 265k, False: 134]
  ------------------
  132|  4.47M|  }
_ZNK11flatbuffers5Table11VerifyFieldIfEEbRKNS_8VerifierEtm:
  126|  5.10M|                   size_t align) const {
  127|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  128|       |    // VerifyTable().
  129|  5.10M|    auto field_offset = GetOptionalFieldOffset(field);
  130|       |    // Check the actual field.
  131|  5.10M|    return !field_offset || verifier.VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (131:12): [True: 5.09M, False: 13.0k]
  |  Branch (131:29): [True: 12.9k, False: 84]
  ------------------
  132|  5.10M|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorIPKN6MyGame7Example7AbilityEjEEjEET_t:
   58|   512k|  P GetPointer(voffset_t field) const {
   59|   512k|    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
   60|   512k|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorIPKN6MyGame7Example7AbilityEjEEjEET_t:
   51|   512k|  P GetPointer(voffset_t field) {
   52|   512k|    auto field_offset = GetOptionalFieldOffset(field);
   53|   512k|    auto p = data_ + field_offset;
   54|   512k|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (54:12): [True: 7.75k, False: 504k]
  ------------------
   55|   512k|                        : nullptr;
   56|   512k|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorIljEEjEET_t:
   58|   511k|  P GetPointer(voffset_t field) const {
   59|   511k|    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
   60|   511k|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorIljEEjEET_t:
   51|   511k|  P GetPointer(voffset_t field) {
   52|   511k|    auto field_offset = GetOptionalFieldOffset(field);
   53|   511k|    auto p = data_ + field_offset;
   54|   511k|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (54:12): [True: 12.4k, False: 498k]
  ------------------
   55|   511k|                        : nullptr;
   56|   511k|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorIdjEEjEET_t:
   58|   511k|  P GetPointer(voffset_t field) const {
   59|   511k|    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
   60|   511k|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorIdjEEjEET_t:
   51|   511k|  P GetPointer(voffset_t field) {
   52|   511k|    auto field_offset = GetOptionalFieldOffset(field);
   53|   511k|    auto p = data_ + field_offset;
   54|   511k|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (54:12): [True: 12.2k, False: 498k]
  ------------------
   55|   511k|                        : nullptr;
   56|   511k|  }
_ZNK11flatbuffers5Table10GetPointerIPKN6MyGame17InParentNamespaceEjEET_t:
   58|   511k|  P GetPointer(voffset_t field) const {
   59|   511k|    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
   60|   511k|  }
_ZN11flatbuffers5Table10GetPointerIPKN6MyGame17InParentNamespaceEjEET_t:
   51|   511k|  P GetPointer(voffset_t field) {
   52|   511k|    auto field_offset = GetOptionalFieldOffset(field);
   53|   511k|    auto p = data_ + field_offset;
   54|   511k|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (54:12): [True: 117k, False: 393k]
  ------------------
   55|   511k|                        : nullptr;
   56|   511k|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN6MyGame7Example10ReferrableEEEjEEjEET_t:
   58|  2.04M|  P GetPointer(voffset_t field) const {
   59|  2.04M|    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
   60|  2.04M|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN6MyGame7Example10ReferrableEEEjEEjEET_t:
   51|  2.04M|  P GetPointer(voffset_t field) {
   52|  2.04M|    auto field_offset = GetOptionalFieldOffset(field);
   53|  2.04M|    auto p = data_ + field_offset;
   54|  2.04M|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (54:12): [True: 478k, False: 1.56M]
  ------------------
   55|  2.04M|                        : nullptr;
   56|  2.04M|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorImjEEjEET_t:
   58|  1.53M|  P GetPointer(voffset_t field) const {
   59|  1.53M|    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
   60|  1.53M|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorImjEEjEET_t:
   51|  1.53M|  P GetPointer(voffset_t field) {
   52|  1.53M|    auto field_offset = GetOptionalFieldOffset(field);
   53|  1.53M|    auto p = data_ + field_offset;
   54|  1.53M|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (54:12): [True: 18.3k, False: 1.51M]
  ------------------
   55|  1.53M|                        : nullptr;
   56|  1.53M|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorIN6MyGame7Example5ColorEjEEjEET_t:
   58|   510k|  P GetPointer(voffset_t field) const {
   59|   510k|    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
   60|   510k|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorIN6MyGame7Example5ColorEjEEjEET_t:
   51|   510k|  P GetPointer(voffset_t field) {
   52|   510k|    auto field_offset = GetOptionalFieldOffset(field);
   53|   510k|    auto p = data_ + field_offset;
   54|   510k|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (54:12): [True: 2.36k, False: 507k]
  ------------------
   55|   510k|                        : nullptr;
   56|   510k|  }
_ZNK11flatbuffers5Table11VerifyFieldIaEEbRKNS_8VerifierEtm:
  126|   510k|                   size_t align) const {
  127|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  128|       |    // VerifyTable().
  129|   510k|    auto field_offset = GetOptionalFieldOffset(field);
  130|       |    // Check the actual field.
  131|   510k|    return !field_offset || verifier.VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (131:12): [True: 507k, False: 2.70k]
  |  Branch (131:29): [True: 2.65k, False: 43]
  ------------------
  132|   510k|  }
_ZNK11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN6MyGame7Example4StatEEEjEEjEET_t:
   58|  1.02M|  P GetPointer(voffset_t field) const {
   59|  1.02M|    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
   60|  1.02M|  }
_ZN11flatbuffers5Table10GetPointerIPKNS_6VectorINS_6OffsetIN6MyGame7Example4StatEEEjEEjEET_t:
   51|  1.02M|  P GetPointer(voffset_t field) {
   52|  1.02M|    auto field_offset = GetOptionalFieldOffset(field);
   53|  1.02M|    auto p = data_ + field_offset;
   54|  1.02M|    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
  ------------------
  |  Branch (54:12): [True: 3.64k, False: 1.01M]
  ------------------
   55|  1.02M|                        : nullptr;
   56|  1.02M|  }
_ZNK11flatbuffers5Table11VerifyFieldIN6MyGame7Example4TestEEEbRKNS_8VerifierEtm:
  126|   509k|                   size_t align) const {
  127|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  128|       |    // VerifyTable().
  129|   509k|    auto field_offset = GetOptionalFieldOffset(field);
  130|       |    // Check the actual field.
  131|   509k|    return !field_offset || verifier.VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (131:12): [True: 508k, False: 1.14k]
  |  Branch (131:29): [True: 1.11k, False: 27]
  ------------------
  132|   509k|  }
_ZNK11flatbuffers5Table11VerifyFieldIdEEbRKNS_8VerifierEtm:
  126|   509k|                   size_t align) const {
  127|       |    // Calling GetOptionalFieldOffset should be safe now thanks to
  128|       |    // VerifyTable().
  129|   509k|    auto field_offset = GetOptionalFieldOffset(field);
  130|       |    // Check the actual field.
  131|   509k|    return !field_offset || verifier.VerifyField<T>(data_, field_offset, align);
  ------------------
  |  Branch (131:12): [True: 508k, False: 1.60k]
  |  Branch (131:29): [True: 1.58k, False: 20]
  ------------------
  132|   509k|  }

_ZNK11flatbuffers6VectorINS_6OffsetINS_6StringEEEjE4sizeEv:
  164|   237k|  SizeT size() const { return EndianScalar(length_); }
_ZNK11flatbuffers6VectorINS_6OffsetINS_6StringEEEjE3GetEj:
  175|   114k|  return_type Get(SizeT i) const {
  176|   114k|    FLATBUFFERS_ASSERT(i < size());
  177|      0|    return IndirectHelper<T>::Read(Data(), i);
  178|   114k|  }
_ZNK11flatbuffers6VectorINS_6OffsetINS_6StringEEEjE4DataEv:
  253|   114k|  const uint8_t *Data() const {
  254|   114k|    return reinterpret_cast<const uint8_t *>(&length_ + 1);
  255|   114k|  }
_ZNK11flatbuffers6VectorINS_6OffsetIN6MyGame7Example7MonsterEEEjE4sizeEv:
  164|  1.02M|  SizeT size() const { return EndianScalar(length_); }
_ZNK11flatbuffers6VectorINS_6OffsetIN6MyGame7Example7MonsterEEEjE3GetEj:
  175|   385k|  return_type Get(SizeT i) const {
  176|   385k|    FLATBUFFERS_ASSERT(i < size());
  177|      0|    return IndirectHelper<T>::Read(Data(), i);
  178|   385k|  }
_ZNK11flatbuffers6VectorINS_6OffsetIN6MyGame7Example7MonsterEEEjE4DataEv:
  253|   385k|  const uint8_t *Data() const {
  254|   385k|    return reinterpret_cast<const uint8_t *>(&length_ + 1);
  255|   385k|  }
_ZNK11flatbuffers6VectorIhjE4sizeEv:
  164|  4.91k|  SizeT size() const { return EndianScalar(length_); }
_ZNK11flatbuffers6VectorIhjE4dataEv:
  260|  3.98k|  const T *data() const { return reinterpret_cast<const T *>(Data()); }
_ZNK11flatbuffers6VectorIhjE4DataEv:
  253|  3.98k|  const uint8_t *Data() const {
  254|  3.98k|    return reinterpret_cast<const uint8_t *>(&length_ + 1);
  255|  3.98k|  }
_ZNK11flatbuffers6VectorINS_6OffsetIN6MyGame7Example10ReferrableEEEjE4sizeEv:
  164|  2.03M|  SizeT size() const { return EndianScalar(length_); }
_ZNK11flatbuffers6VectorINS_6OffsetIN6MyGame7Example10ReferrableEEEjE3GetEj:
  175|   899k|  return_type Get(SizeT i) const {
  176|   899k|    FLATBUFFERS_ASSERT(i < size());
  177|      0|    return IndirectHelper<T>::Read(Data(), i);
  178|   899k|  }
_ZNK11flatbuffers6VectorINS_6OffsetIN6MyGame7Example10ReferrableEEEjE4DataEv:
  253|   899k|  const uint8_t *Data() const {
  254|   899k|    return reinterpret_cast<const uint8_t *>(&length_ + 1);
  255|   899k|  }
_ZNK11flatbuffers6VectorINS_6OffsetIN6MyGame7Example4StatEEEjE4sizeEv:
  164|  62.5k|  SizeT size() const { return EndianScalar(length_); }
_ZNK11flatbuffers6VectorINS_6OffsetIN6MyGame7Example4StatEEEjE3GetEj:
  175|  30.4k|  return_type Get(SizeT i) const {
  176|  30.4k|    FLATBUFFERS_ASSERT(i < size());
  177|      0|    return IndirectHelper<T>::Read(Data(), i);
  178|  30.4k|  }
_ZNK11flatbuffers6VectorINS_6OffsetIN6MyGame7Example4StatEEEjE4DataEv:
  253|  30.4k|  const uint8_t *Data() const {
  254|  30.4k|    return reinterpret_cast<const uint8_t *>(&length_ + 1);
  255|  30.4k|  }

_ZN11flatbuffers8VerifierC2EPKhmjjb:
   59|  5.35k|        }()) {}
_ZZN11flatbuffers8VerifierC1EPKhmjjbENKUlvE_clEv:
   53|  5.35k|      : Verifier(buf, buf_len, [&] {
   54|  5.35k|          Options opts;
   55|  5.35k|          opts.max_depth = max_depth;
   56|  5.35k|          opts.max_tables = max_tables;
   57|  5.35k|          opts.check_alignment = check_alignment;
   58|  5.35k|          return opts;
   59|  5.35k|        }()) {}
_ZN11flatbuffers8VerifierC2EPKhmRKNS0_7OptionsE:
   45|  6.24k|      : buf_(buf), size_(buf_len), opts_(opts) {
   46|  6.24k|    FLATBUFFERS_ASSERT(size_ < opts.max_size);
   47|  6.24k|  }
_ZN11flatbuffers8Verifier12VerifyBufferIN6MyGame7Example7MonsterEEEbPKc:
  242|  6.24k|  template<typename T> bool VerifyBuffer(const char *const identifier) {
  243|  6.24k|    return VerifyBufferFromStart<T>(identifier, 0);
  244|  6.24k|  }
_ZN11flatbuffers8Verifier21VerifyBufferFromStartIN6MyGame7Example7MonsterEEEbPKcm:
  199|  6.24k|  bool VerifyBufferFromStart(const char *const identifier, const size_t start) {
  200|       |    // Buffers have to be of some size to be valid. The reason it is a runtime
  201|       |    // check instead of static_assert, is that nested flatbuffers go through
  202|       |    // this call and their size is determined at runtime.
  203|  6.24k|    if (!Check(size_ >= FLATBUFFERS_MIN_BUFFER_SIZE)) return false;
  ------------------
  |  |  347|  6.24k|#define FLATBUFFERS_MIN_BUFFER_SIZE sizeof(uoffset_t) + sizeof(soffset_t) + \
  |  |  348|  6.24k|   sizeof(uint16_t) + sizeof(uint16_t)
  ------------------
  |  Branch (203:9): [True: 8, False: 6.23k]
  ------------------
  204|       |
  205|       |    // If an identifier is provided, check that we have a buffer
  206|  6.23k|    if (identifier && !Check((size_ >= 2 * sizeof(flatbuffers::uoffset_t) &&
  ------------------
  |  Branch (206:9): [True: 5.34k, False: 893]
  |  Branch (206:23): [True: 37, False: 5.30k]
  |  Branch (206:31): [True: 5.34k, False: 0]
  ------------------
  207|  5.34k|                              BufferHasIdentifier(buf_ + start, identifier)))) {
  ------------------
  |  Branch (207:31): [True: 5.30k, False: 37]
  ------------------
  208|     37|      return false;
  209|     37|    }
  210|       |
  211|       |    // Call T::Verify, which must be in the generated code for this type.
  212|  6.20k|    const auto o = VerifyOffset<uoffset_t>(start);
  213|  6.20k|    return Check(o != 0) &&
  ------------------
  |  Branch (213:12): [True: 6.03k, False: 161]
  ------------------
  214|  6.20k|           reinterpret_cast<const T *>(buf_ + start + o)->Verify(*this)
  ------------------
  |  Branch (214:12): [True: 1.29k, False: 4.74k]
  ------------------
  215|       |    // clang-format off
  216|       |    #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
  217|       |           && GetComputedSize()
  218|       |    #endif
  219|  6.23k|        ;
  220|       |    // clang-format on
  221|  6.23k|  }
_ZNK11flatbuffers8Verifier5CheckEb:
   62|  41.1M|  bool Check(const bool ok) const {
   63|       |    // clang-format off
   64|       |    #ifdef FLATBUFFERS_DEBUG_VERIFICATION_FAILURE
   65|       |       if (opts_.assert) { FLATBUFFERS_ASSERT(ok); }
   66|       |    #endif
   67|       |    #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
   68|       |      if (!ok)
   69|       |        upper_bound_ = 0;
   70|       |    #endif
   71|       |    // clang-format on
   72|  41.1M|    return ok;
   73|  41.1M|  }
_ZNK11flatbuffers8Verifier12VerifyOffsetIjiEEmm:
  256|  2.49M|  size_t VerifyOffset(const size_t start) const {
  257|  2.49M|    if (!Verify<OffsetT>(start)) return 0;
  ------------------
  |  Branch (257:9): [True: 394, False: 2.49M]
  ------------------
  258|  2.49M|    const auto o = ReadScalar<OffsetT>(buf_ + start);
  259|       |    // May not point to itself.
  260|  2.49M|    if (!Check(o != 0)) return 0;
  ------------------
  |  Branch (260:9): [True: 81, False: 2.49M]
  ------------------
  261|       |    // Can't wrap around larger than the max size.
  262|  2.49M|    if (!Check(static_cast<SOffsetT>(o) >= 0)) return 0;
  ------------------
  |  Branch (262:9): [True: 225, False: 2.49M]
  ------------------
  263|       |    // Must be inside the buffer to create a pointer from it (pointer outside
  264|       |    // buffer is UB).
  265|  2.49M|    if (!Verify(start + o, 1)) return 0;
  ------------------
  |  Branch (265:9): [True: 273, False: 2.49M]
  ------------------
  266|  2.49M|    return o;
  267|  2.49M|  }
_ZNK11flatbuffers8Verifier6VerifyIjEEbm:
   92|  4.46M|  template<typename T> bool Verify(const size_t elem) const {
   93|  4.46M|    return VerifyAlignment(elem, sizeof(T)) && Verify(elem, sizeof(T));
  ------------------
  |  Branch (93:12): [True: 4.46M, False: 436]
  |  Branch (93:48): [True: 4.46M, False: 340]
  ------------------
   94|  4.46M|  }
_ZNK11flatbuffers8Verifier15VerifyAlignmentEmm:
   87|  12.0M|  bool VerifyAlignment(const size_t elem, const size_t align) const {
   88|  12.0M|    return Check((elem & (align - 1)) == 0 || !opts_.check_alignment);
  ------------------
  |  Branch (88:18): [True: 12.0M, False: 893]
  |  Branch (88:47): [True: 0, False: 893]
  ------------------
   89|  12.0M|  }
_ZNK11flatbuffers8Verifier6VerifyEmm:
   76|  17.1M|  bool Verify(const size_t elem, const size_t elem_len) const {
   77|       |    // clang-format off
   78|       |    #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
   79|       |      auto upper_bound = elem + elem_len;
   80|       |      if (upper_bound_ < upper_bound)
   81|       |        upper_bound_ =  upper_bound;
   82|       |    #endif
   83|       |    // clang-format on
   84|  17.1M|    return Check(elem_len < size_ && elem <= size_ - elem_len);
  ------------------
  |  Branch (84:18): [True: 17.1M, False: 784]
  |  Branch (84:38): [True: 17.1M, False: 1.57k]
  ------------------
   85|  17.1M|  }
_ZN11flatbuffers8Verifier16VerifyTableStartEPKh:
  181|  1.93M|  bool VerifyTableStart(const uint8_t *const table) {
  182|       |    // Check the vtable offset.
  183|  1.93M|    const auto tableo = static_cast<size_t>(table - buf_);
  184|  1.93M|    if (!Verify<soffset_t>(tableo)) return false;
  ------------------
  |  Branch (184:9): [True: 341, False: 1.93M]
  ------------------
  185|       |    // This offset may be signed, but doing the subtraction unsigned always
  186|       |    // gives the result we want.
  187|  1.93M|    const auto vtableo =
  188|  1.93M|        tableo - static_cast<size_t>(ReadScalar<soffset_t>(table));
  189|       |    // Check the vtable size field, then check vtable fits in its entirety.
  190|  1.93M|    if (!(VerifyComplexity() && Verify<voffset_t>(vtableo) &&
  ------------------
  |  Branch (190:11): [True: 1.93M, False: 2]
  |  Branch (190:33): [True: 1.93M, False: 148]
  ------------------
  191|  1.93M|          VerifyAlignment(ReadScalar<voffset_t>(buf_ + vtableo),
  ------------------
  |  Branch (191:11): [True: 1.93M, False: 15]
  ------------------
  192|  1.93M|                          sizeof(voffset_t))))
  193|    165|      return false;
  194|  1.93M|    const auto vsize = ReadScalar<voffset_t>(buf_ + vtableo);
  195|  1.93M|    return Check((vsize & 1) == 0) && Verify(vtableo, vsize);
  ------------------
  |  Branch (195:12): [True: 1.93M, False: 0]
  |  Branch (195:39): [True: 1.93M, False: 19]
  ------------------
  196|  1.93M|  }
_ZNK11flatbuffers8Verifier6VerifyIiEEbm:
   92|  1.93M|  template<typename T> bool Verify(const size_t elem) const {
   93|  1.93M|    return VerifyAlignment(elem, sizeof(T)) && Verify(elem, sizeof(T));
  ------------------
  |  Branch (93:12): [True: 1.93M, False: 95]
  |  Branch (93:48): [True: 1.93M, False: 246]
  ------------------
   94|  1.93M|  }
_ZN11flatbuffers8Verifier16VerifyComplexityEv:
  277|  1.93M|  bool VerifyComplexity() {
  278|  1.93M|    depth_++;
  279|  1.93M|    num_tables_++;
  280|  1.93M|    return Check(depth_ <= opts_.max_depth && num_tables_ <= opts_.max_tables);
  ------------------
  |  Branch (280:18): [True: 1.93M, False: 1]
  |  Branch (280:47): [True: 1.93M, False: 1]
  ------------------
  281|  1.93M|  }
_ZNK11flatbuffers8Verifier6VerifyItEEbm:
   92|  1.93M|  template<typename T> bool Verify(const size_t elem) const {
   93|  1.93M|    return VerifyAlignment(elem, sizeof(T)) && Verify(elem, sizeof(T));
  ------------------
  |  Branch (93:12): [True: 1.93M, False: 42]
  |  Branch (93:48): [True: 1.93M, False: 106]
  ------------------
   94|  1.93M|  }
_ZNK11flatbuffers8Verifier11VerifyFieldIN6MyGame7Example4Vec3EEEbPKhtm:
  109|  4.68k|                   const size_t align) const {
  110|  4.68k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  111|  4.68k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (111:12): [True: 4.67k, False: 13]
  |  Branch (111:41): [True: 4.63k, False: 36]
  ------------------
  112|  4.68k|  }
_ZNK11flatbuffers8Verifier11VerifyFieldIsEEbPKhtm:
  109|   509k|                   const size_t align) const {
  110|   509k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  111|   509k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (111:12): [True: 509k, False: 12]
  |  Branch (111:41): [True: 509k, False: 37]
  ------------------
  112|   509k|  }
_ZNK11flatbuffers8Verifier12VerifyOffsetIjEEmPKht:
  270|  2.48M|  size_t VerifyOffset(const uint8_t *const base, const voffset_t start) const {
  271|  2.48M|    return VerifyOffset<OffsetT>(static_cast<size_t>(base - buf_) + start);
  272|  2.48M|  }
_ZNK11flatbuffers8Verifier12VerifyStringEPKNS_6StringE:
  133|   783k|  bool VerifyString(const String *const str) const {
  134|   783k|    size_t end;
  135|   783k|    return !str || (VerifyVectorOrString<uoffset_t>(
  ------------------
  |  Branch (135:12): [True: 150k, False: 633k]
  |  Branch (135:21): [True: 633k, False: 384]
  ------------------
  136|   633k|                        reinterpret_cast<const uint8_t *>(str), 1, &end) &&
  137|   633k|                    Verify(end, 1) &&           // Must have terminator
  ------------------
  |  Branch (137:21): [True: 633k, False: 28]
  ------------------
  138|   633k|                    Check(buf_[end] == '\0'));  // Terminating byte must be 0.
  ------------------
  |  Branch (138:21): [True: 633k, False: 68]
  ------------------
  139|   783k|  }
_ZNK11flatbuffers8Verifier20VerifyVectorOrStringIjEEbPKhmPm:
  144|  1.97M|                            size_t *const end = nullptr) const {
  145|  1.97M|    const auto vec_offset = static_cast<size_t>(vec - buf_);
  146|       |    // Check we can read the size field.
  147|  1.97M|    if (!Verify<LenT>(vec_offset)) return false;
  ------------------
  |  Branch (147:9): [True: 382, False: 1.97M]
  ------------------
  148|       |    // Check the whole array. If this is a string, the byte past the array must
  149|       |    // be 0.
  150|  1.97M|    const LenT size = ReadScalar<LenT>(vec);
  151|  1.97M|    const auto max_elems = opts_.max_size / elem_size;
  152|  1.97M|    if (!Check(size < max_elems))
  ------------------
  |  Branch (152:9): [True: 134, False: 1.97M]
  ------------------
  153|    134|      return false;  // Protect against byte_size overflowing.
  154|  1.97M|    const auto byte_size = sizeof(LenT) + elem_size * size;
  155|  1.97M|    if (end) *end = vec_offset + byte_size;
  ------------------
  |  Branch (155:9): [True: 633k, False: 1.34M]
  ------------------
  156|  1.97M|    return Verify(vec_offset, byte_size);
  157|  1.97M|  }
_ZNK11flatbuffers8Verifier12VerifyVectorIJEhjEEbPKNS_6VectorIT0_T1_EE:
  121|  2.56M|  bool VerifyVector(const Vector<T, LenT> *const vec) const {
  122|  2.56M|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (122:12): [True: 2.04M, False: 514k]
  |  Branch (122:20): [True: 513k, False: 155]
  ------------------
  123|   514k|                       reinterpret_cast<const uint8_t *>(vec), sizeof(T));
  124|  2.56M|  }
_ZNK11flatbuffers8Verifier11VerifyFieldIhEEbPKhtm:
  109|   666k|                   const size_t align) const {
  110|   666k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  111|   666k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (111:12): [True: 666k, False: 0]
  |  Branch (111:41): [True: 666k, False: 182]
  ------------------
  112|   666k|  }
_ZN11flatbuffers8Verifier11VerifyTableIN6MyGame7Example23TestSimpleTableWithEnumEEEbPKT_:
  115|  97.4k|  template<typename T> bool VerifyTable(const T *const table) {
  116|  97.4k|    return !table || table->Verify(*this);
  ------------------
  |  Branch (116:12): [True: 95.0k, False: 2.31k]
  |  Branch (116:22): [True: 2.27k, False: 38]
  ------------------
  117|  97.4k|  }
_ZN11flatbuffers8Verifier11VerifyTableIN6MyGame8Example27MonsterEEEbPKT_:
  115|   249k|  template<typename T> bool VerifyTable(const T *const table) {
  116|   249k|    return !table || table->Verify(*this);
  ------------------
  |  Branch (116:12): [True: 1.50k, False: 248k]
  |  Branch (116:22): [True: 248k, False: 3]
  ------------------
  117|   249k|  }
_ZNK11flatbuffers8Verifier12VerifyVectorIJEN6MyGame7Example4TestEjEEbPKNS_6VectorIPKT0_T1_EE:
  128|  1.02M|  bool VerifyVector(const Vector<const T *, LenT> *const vec) const {
  129|  1.02M|    return VerifyVector(reinterpret_cast<const Vector<T, LenT> *>(vec));
  130|  1.02M|  }
_ZNK11flatbuffers8Verifier12VerifyVectorIJEN6MyGame7Example4TestEjEEbPKNS_6VectorIT0_T1_EE:
  121|  1.02M|  bool VerifyVector(const Vector<T, LenT> *const vec) const {
  122|  1.02M|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (122:12): [True: 758k, False: 268k]
  |  Branch (122:20): [True: 268k, False: 79]
  ------------------
  123|   268k|                       reinterpret_cast<const uint8_t *>(vec), sizeof(T));
  124|  1.02M|  }
_ZNK11flatbuffers8Verifier12VerifyVectorIJENS_6OffsetINS_6StringEEEjEEbPKNS_6VectorIT0_T1_EE:
  121|  1.02M|  bool VerifyVector(const Vector<T, LenT> *const vec) const {
  122|  1.02M|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (122:12): [True: 1.01M, False: 9.51k]
  |  Branch (122:20): [True: 9.40k, False: 114]
  ------------------
  123|  9.51k|                       reinterpret_cast<const uint8_t *>(vec), sizeof(T));
  124|  1.02M|  }
_ZNK11flatbuffers8Verifier21VerifyVectorOfStringsEPKNS_6VectorINS_6OffsetINS_6StringEEEjEE:
  160|  1.02M|  bool VerifyVectorOfStrings(const Vector<Offset<String>> *const vec) const {
  161|  1.02M|    if (vec) {
  ------------------
  |  Branch (161:9): [True: 9.40k, False: 1.01M]
  ------------------
  162|   123k|      for (uoffset_t i = 0; i < vec->size(); i++) {
  ------------------
  |  Branch (162:29): [True: 114k, False: 9.19k]
  ------------------
  163|   114k|        if (!VerifyString(vec->Get(i))) return false;
  ------------------
  |  Branch (163:13): [True: 207, False: 114k]
  ------------------
  164|   114k|      }
  165|  9.40k|    }
  166|  1.02M|    return true;
  167|  1.02M|  }
_ZNK11flatbuffers8Verifier12VerifyVectorIJENS_6OffsetIN6MyGame7Example7MonsterEEEjEEbPKNS_6VectorIT0_T1_EE:
  121|   514k|  bool VerifyVector(const Vector<T, LenT> *const vec) const {
  122|   514k|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (122:12): [True: 260k, False: 254k]
  |  Branch (122:20): [True: 254k, False: 86]
  ------------------
  123|   254k|                       reinterpret_cast<const uint8_t *>(vec), sizeof(T));
  124|   514k|  }
_ZN11flatbuffers8Verifier20VerifyVectorOfTablesIN6MyGame7Example7MonsterEEEbPKNS_6VectorINS_6OffsetIT_EEjEE:
  171|   514k|  bool VerifyVectorOfTables(const Vector<Offset<T>> *const vec) {
  172|   514k|    if (vec) {
  ------------------
  |  Branch (172:9): [True: 254k, False: 260k]
  ------------------
  173|   638k|      for (uoffset_t i = 0; i < vec->size(); i++) {
  ------------------
  |  Branch (173:29): [True: 385k, False: 253k]
  ------------------
  174|   385k|        if (!vec->Get(i)->Verify(*this)) return false;
  ------------------
  |  Branch (174:13): [True: 1.24k, False: 384k]
  ------------------
  175|   385k|      }
  176|   254k|    }
  177|   513k|    return true;
  178|   514k|  }
_ZN11flatbuffers8Verifier11VerifyTableIN6MyGame7Example7MonsterEEEbPKT_:
  115|   517k|  template<typename T> bool VerifyTable(const T *const table) {
  116|   517k|    return !table || table->Verify(*this);
  ------------------
  |  Branch (116:12): [True: 392k, False: 124k]
  |  Branch (116:22): [True: 124k, False: 558]
  ------------------
  117|   517k|  }
_ZN11flatbuffers8Verifier22VerifyNestedFlatBufferIN6MyGame7Example7MonsterEJEjEEbPKNS_6VectorIhT1_EEPKc:
  225|  1.02M|                              const char *const identifier) {
  226|       |    // Caller opted out of this.
  227|  1.02M|    if (!opts_.check_nested_flatbuffers) return true;
  ------------------
  |  Branch (227:9): [True: 0, False: 1.02M]
  ------------------
  228|       |
  229|       |    // An empty buffer is OK as it indicates not present.
  230|  1.02M|    if (!buf) return true;
  ------------------
  |  Branch (230:9): [True: 1.02M, False: 924]
  ------------------
  231|       |
  232|       |    // If there is a nested buffer, it must be greater than the min size.
  233|    924|    if (!Check(buf->size() >= FLATBUFFERS_MIN_BUFFER_SIZE)) return false;
  ------------------
  |  |  347|    924|#define FLATBUFFERS_MIN_BUFFER_SIZE sizeof(uoffset_t) + sizeof(soffset_t) + \
  |  |  348|    924|   sizeof(uint16_t) + sizeof(uint16_t)
  ------------------
  |  Branch (233:9): [True: 31, False: 893]
  ------------------
  234|       |
  235|    893|    Verifier nested_verifier(buf->data(), buf->size(), opts_);
  236|    893|    return nested_verifier.VerifyBuffer<T>(identifier);
  237|    924|  }
_ZN11flatbuffers8Verifier11VerifyTableIN6MyGame7Example4StatEEEbPKT_:
  115|   512k|  template<typename T> bool VerifyTable(const T *const table) {
  116|   512k|    return !table || table->Verify(*this);
  ------------------
  |  Branch (116:12): [True: 389k, False: 123k]
  |  Branch (116:22): [True: 123k, False: 276]
  ------------------
  117|   512k|  }
_ZNK11flatbuffers8Verifier11VerifyFieldItEEbPKhtm:
  109|  3.01k|                   const size_t align) const {
  110|  3.01k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  111|  3.01k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (111:12): [True: 3.00k, False: 12]
  |  Branch (111:41): [True: 3.00k, False: 3]
  ------------------
  112|  3.01k|  }
_ZNK11flatbuffers8Verifier11VerifyFieldIiEEbPKhtm:
  109|  3.85k|                   const size_t align) const {
  110|  3.85k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  111|  3.85k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (111:12): [True: 3.83k, False: 22]
  |  Branch (111:41): [True: 3.80k, False: 22]
  ------------------
  112|  3.85k|  }
_ZNK11flatbuffers8Verifier11VerifyFieldIjEEbPKhtm:
  109|   258k|                   const size_t align) const {
  110|   258k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  111|   258k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (111:12): [True: 258k, False: 33]
  |  Branch (111:41): [True: 258k, False: 27]
  ------------------
  112|   258k|  }
_ZNK11flatbuffers8Verifier11VerifyFieldIlEEbPKhtm:
  109|  6.33k|                   const size_t align) const {
  110|  6.33k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  111|  6.33k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (111:12): [True: 6.28k, False: 50]
  |  Branch (111:41): [True: 6.25k, False: 36]
  ------------------
  112|  6.33k|  }
_ZNK11flatbuffers8Verifier11VerifyFieldImEEbPKhtm:
  109|   265k|                   const size_t align) const {
  110|   265k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  111|   265k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (111:12): [True: 265k, False: 87]
  |  Branch (111:41): [True: 265k, False: 47]
  ------------------
  112|   265k|  }
_ZNK11flatbuffers8Verifier11VerifyFieldIfEEbPKhtm:
  109|  13.0k|                   const size_t align) const {
  110|  13.0k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  111|  13.0k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (111:12): [True: 12.9k, False: 45]
  |  Branch (111:41): [True: 12.9k, False: 39]
  ------------------
  112|  13.0k|  }
_ZNK11flatbuffers8Verifier12VerifyVectorIJEN6MyGame7Example7AbilityEjEEbPKNS_6VectorIPKT0_T1_EE:
  128|   512k|  bool VerifyVector(const Vector<const T *, LenT> *const vec) const {
  129|   512k|    return VerifyVector(reinterpret_cast<const Vector<T, LenT> *>(vec));
  130|   512k|  }
_ZNK11flatbuffers8Verifier12VerifyVectorIJEN6MyGame7Example7AbilityEjEEbPKNS_6VectorIT0_T1_EE:
  121|   512k|  bool VerifyVector(const Vector<T, LenT> *const vec) const {
  122|   512k|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (122:12): [True: 504k, False: 7.75k]
  |  Branch (122:20): [True: 7.70k, False: 50]
  ------------------
  123|  7.75k|                       reinterpret_cast<const uint8_t *>(vec), sizeof(T));
  124|   512k|  }
_ZN11flatbuffers8Verifier19GetFlexReuseTrackerEv:
  306|  3.09k|  std::vector<uint8_t> *GetFlexReuseTracker() { return flex_reuse_tracker_; }
_ZNK11flatbuffers8Verifier12VerifyVectorIJEljEEbPKNS_6VectorIT0_T1_EE:
  121|   511k|  bool VerifyVector(const Vector<T, LenT> *const vec) const {
  122|   511k|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (122:12): [True: 498k, False: 12.4k]
  |  Branch (122:20): [True: 12.3k, False: 71]
  ------------------
  123|  12.4k|                       reinterpret_cast<const uint8_t *>(vec), sizeof(T));
  124|   511k|  }
_ZNK11flatbuffers8Verifier12VerifyVectorIJEdjEEbPKNS_6VectorIT0_T1_EE:
  121|   511k|  bool VerifyVector(const Vector<T, LenT> *const vec) const {
  122|   511k|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (122:12): [True: 498k, False: 12.2k]
  |  Branch (122:20): [True: 12.1k, False: 89]
  ------------------
  123|  12.2k|                       reinterpret_cast<const uint8_t *>(vec), sizeof(T));
  124|   511k|  }
_ZN11flatbuffers8Verifier11VerifyTableIN6MyGame17InParentNamespaceEEEbPKT_:
  115|   511k|  template<typename T> bool VerifyTable(const T *const table) {
  116|   511k|    return !table || table->Verify(*this);
  ------------------
  |  Branch (116:12): [True: 393k, False: 117k]
  |  Branch (116:22): [True: 117k, False: 6]
  ------------------
  117|   511k|  }
_ZNK11flatbuffers8Verifier12VerifyVectorIJENS_6OffsetIN6MyGame7Example10ReferrableEEEjEEbPKNS_6VectorIT0_T1_EE:
  121|  1.02M|  bool VerifyVector(const Vector<T, LenT> *const vec) const {
  122|  1.02M|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (122:12): [True: 782k, False: 239k]
  |  Branch (122:20): [True: 239k, False: 97]
  ------------------
  123|   239k|                       reinterpret_cast<const uint8_t *>(vec), sizeof(T));
  124|  1.02M|  }
_ZN11flatbuffers8Verifier20VerifyVectorOfTablesIN6MyGame7Example10ReferrableEEEbPKNS_6VectorINS_6OffsetIT_EEjEE:
  171|  1.02M|  bool VerifyVectorOfTables(const Vector<Offset<T>> *const vec) {
  172|  1.02M|    if (vec) {
  ------------------
  |  Branch (172:9): [True: 239k, False: 782k]
  ------------------
  173|  1.13M|      for (uoffset_t i = 0; i < vec->size(); i++) {
  ------------------
  |  Branch (173:29): [True: 899k, False: 239k]
  ------------------
  174|   899k|        if (!vec->Get(i)->Verify(*this)) return false;
  ------------------
  |  Branch (174:13): [True: 71, False: 898k]
  ------------------
  175|   899k|      }
  176|   239k|    }
  177|  1.02M|    return true;
  178|  1.02M|  }
_ZNK11flatbuffers8Verifier12VerifyVectorIJEmjEEbPKNS_6VectorIT0_T1_EE:
  121|  1.53M|  bool VerifyVector(const Vector<T, LenT> *const vec) const {
  122|  1.53M|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (122:12): [True: 1.51M, False: 18.3k]
  |  Branch (122:20): [True: 18.3k, False: 60]
  ------------------
  123|  18.3k|                       reinterpret_cast<const uint8_t *>(vec), sizeof(T));
  124|  1.53M|  }
_ZNK11flatbuffers8Verifier12VerifyVectorIJEN6MyGame7Example5ColorEjEEbPKNS_6VectorIT0_T1_EE:
  121|   510k|  bool VerifyVector(const Vector<T, LenT> *const vec) const {
  122|   510k|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (122:12): [True: 507k, False: 2.36k]
  |  Branch (122:20): [True: 2.25k, False: 112]
  ------------------
  123|  2.36k|                       reinterpret_cast<const uint8_t *>(vec), sizeof(T));
  124|   510k|  }
_ZNK11flatbuffers8Verifier11VerifyFieldIaEEbPKhtm:
  109|  2.70k|                   const size_t align) const {
  110|  2.70k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  111|  2.70k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (111:12): [True: 2.70k, False: 0]
  |  Branch (111:41): [True: 2.65k, False: 43]
  ------------------
  112|  2.70k|  }
_ZNK11flatbuffers8Verifier12VerifyVectorIJENS_6OffsetIN6MyGame7Example4StatEEEjEEbPKNS_6VectorIT0_T1_EE:
  121|   510k|  bool VerifyVector(const Vector<T, LenT> *const vec) const {
  122|   510k|    return !vec || VerifyVectorOrString<LenT>(
  ------------------
  |  Branch (122:12): [True: 508k, False: 1.86k]
  |  Branch (122:20): [True: 1.78k, False: 82]
  ------------------
  123|  1.86k|                       reinterpret_cast<const uint8_t *>(vec), sizeof(T));
  124|   510k|  }
_ZN11flatbuffers8Verifier20VerifyVectorOfTablesIN6MyGame7Example4StatEEEbPKNS_6VectorINS_6OffsetIT_EEjEE:
  171|   509k|  bool VerifyVectorOfTables(const Vector<Offset<T>> *const vec) {
  172|   509k|    if (vec) {
  ------------------
  |  Branch (172:9): [True: 1.78k, False: 508k]
  ------------------
  173|  32.1k|      for (uoffset_t i = 0; i < vec->size(); i++) {
  ------------------
  |  Branch (173:29): [True: 30.4k, False: 1.69k]
  ------------------
  174|  30.4k|        if (!vec->Get(i)->Verify(*this)) return false;
  ------------------
  |  Branch (174:13): [True: 87, False: 30.3k]
  ------------------
  175|  30.4k|      }
  176|  1.78k|    }
  177|   509k|    return true;
  178|   509k|  }
_ZNK11flatbuffers8Verifier11VerifyFieldIN6MyGame7Example4TestEEEbPKhtm:
  109|  1.14k|                   const size_t align) const {
  110|  1.14k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  111|  1.14k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (111:12): [True: 1.13k, False: 15]
  |  Branch (111:41): [True: 1.11k, False: 12]
  ------------------
  112|  1.14k|  }
_ZNK11flatbuffers8Verifier11VerifyFieldIdEEbPKhtm:
  109|  1.60k|                   const size_t align) const {
  110|  1.60k|    const auto f = static_cast<size_t>(base - buf_) + elem_off;
  111|  1.60k|    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
  ------------------
  |  Branch (111:12): [True: 1.58k, False: 16]
  |  Branch (111:41): [True: 1.58k, False: 4]
  ------------------
  112|  1.60k|  }
_ZN11flatbuffers8Verifier8EndTableEv:
  284|  1.93M|  bool EndTable() {
  285|  1.93M|    depth_--;
  286|  1.93M|    return true;
  287|  1.93M|  }

_ZN6MyGame7Example19VerifyMonsterBufferERN11flatbuffers8VerifierE:
 4239|  5.35k|    ::flatbuffers::Verifier &verifier) {
 4240|  5.35k|  return verifier.VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 4241|  5.35k|}
_ZNK6MyGame7Example7Monster6VerifyERN11flatbuffers8VerifierE:
 1883|   516k|  bool Verify(::flatbuffers::Verifier &verifier) const {
 1884|   516k|    return VerifyTableStart(verifier) &&
  ------------------
  |  Branch (1884:12): [True: 515k, False: 400]
  ------------------
 1885|   516k|           VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
  ------------------
  |  Branch (1885:12): [True: 515k, False: 49]
  ------------------
 1886|   516k|           VerifyField<int16_t>(verifier, VT_MANA, 2) &&
  ------------------
  |  Branch (1886:12): [True: 515k, False: 29]
  ------------------
 1887|   516k|           VerifyField<int16_t>(verifier, VT_HP, 2) &&
  ------------------
  |  Branch (1887:12): [True: 515k, False: 20]
  ------------------
 1888|   516k|           VerifyOffsetRequired(verifier, VT_NAME) &&
  ------------------
  |  Branch (1888:12): [True: 515k, False: 217]
  ------------------
 1889|   516k|           verifier.VerifyString(name()) &&
  ------------------
  |  Branch (1889:12): [True: 515k, False: 141]
  ------------------
 1890|   516k|           VerifyOffset(verifier, VT_INVENTORY) &&
  ------------------
  |  Branch (1890:12): [True: 515k, False: 77]
  ------------------
 1891|   516k|           verifier.VerifyVector(inventory()) &&
  ------------------
  |  Branch (1891:12): [True: 515k, False: 80]
  ------------------
 1892|   516k|           VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
  ------------------
  |  Branch (1892:12): [True: 515k, False: 20]
  ------------------
 1893|   516k|           VerifyField<uint8_t>(verifier, VT_TEST_TYPE, 1) &&
  ------------------
  |  Branch (1893:12): [True: 515k, False: 26]
  ------------------
 1894|   516k|           VerifyOffset(verifier, VT_TEST) &&
  ------------------
  |  Branch (1894:12): [True: 515k, False: 13]
  ------------------
 1895|   516k|           VerifyAny(verifier, test(), test_type()) &&
  ------------------
  |  Branch (1895:12): [True: 514k, False: 250]
  ------------------
 1896|   516k|           VerifyOffset(verifier, VT_TEST4) &&
  ------------------
  |  Branch (1896:12): [True: 514k, False: 31]
  ------------------
 1897|   516k|           verifier.VerifyVector(test4()) &&
  ------------------
  |  Branch (1897:12): [True: 514k, False: 74]
  ------------------
 1898|   516k|           VerifyOffset(verifier, VT_TESTARRAYOFSTRING) &&
  ------------------
  |  Branch (1898:12): [True: 514k, False: 13]
  ------------------
 1899|   516k|           verifier.VerifyVector(testarrayofstring()) &&
  ------------------
  |  Branch (1899:12): [True: 514k, False: 96]
  ------------------
 1900|   516k|           verifier.VerifyVectorOfStrings(testarrayofstring()) &&
  ------------------
  |  Branch (1900:12): [True: 514k, False: 177]
  ------------------
 1901|   516k|           VerifyOffset(verifier, VT_TESTARRAYOFTABLES) &&
  ------------------
  |  Branch (1901:12): [True: 514k, False: 12]
  ------------------
 1902|   516k|           verifier.VerifyVector(testarrayoftables()) &&
  ------------------
  |  Branch (1902:12): [True: 514k, False: 86]
  ------------------
 1903|   516k|           verifier.VerifyVectorOfTables(testarrayoftables()) &&
  ------------------
  |  Branch (1903:12): [True: 513k, False: 1.24k]
  ------------------
 1904|   516k|           VerifyOffset(verifier, VT_ENEMY) &&
  ------------------
  |  Branch (1904:12): [True: 513k, False: 60]
  ------------------
 1905|   516k|           verifier.VerifyTable(enemy()) &&
  ------------------
  |  Branch (1905:12): [True: 513k, False: 99]
  ------------------
 1906|   516k|           VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) &&
  ------------------
  |  Branch (1906:12): [True: 513k, False: 22]
  ------------------
 1907|   516k|           verifier.VerifyVector(testnestedflatbuffer()) &&
  ------------------
  |  Branch (1907:12): [True: 513k, False: 17]
  ------------------
 1908|   516k|           verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
  ------------------
  |  Branch (1908:12): [True: 512k, False: 133]
  ------------------
 1909|   516k|           VerifyOffset(verifier, VT_TESTEMPTY) &&
  ------------------
  |  Branch (1909:12): [True: 512k, False: 9]
  ------------------
 1910|   516k|           verifier.VerifyTable(testempty()) &&
  ------------------
  |  Branch (1910:12): [True: 512k, False: 276]
  ------------------
 1911|   516k|           VerifyField<uint8_t>(verifier, VT_TESTBOOL, 1) &&
  ------------------
  |  Branch (1911:12): [True: 512k, False: 33]
  ------------------
 1912|   516k|           VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1, 4) &&
  ------------------
  |  Branch (1912:12): [True: 512k, False: 34]
  ------------------
 1913|   516k|           VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1, 4) &&
  ------------------
  |  Branch (1913:12): [True: 512k, False: 50]
  ------------------
 1914|   516k|           VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1, 8) &&
  ------------------
  |  Branch (1914:12): [True: 512k, False: 32]
  ------------------
 1915|   516k|           VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1, 8) &&
  ------------------
  |  Branch (1915:12): [True: 512k, False: 41]
  ------------------
 1916|   516k|           VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1A, 4) &&
  ------------------
  |  Branch (1916:12): [True: 512k, False: 10]
  ------------------
 1917|   516k|           VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1A, 4) &&
  ------------------
  |  Branch (1917:12): [True: 512k, False: 10]
  ------------------
 1918|   516k|           VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1A, 8) &&
  ------------------
  |  Branch (1918:12): [True: 512k, False: 23]
  ------------------
 1919|   516k|           VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1A, 8) &&
  ------------------
  |  Branch (1919:12): [True: 512k, False: 5]
  ------------------
 1920|   516k|           VerifyOffset(verifier, VT_TESTARRAYOFBOOLS) &&
  ------------------
  |  Branch (1920:12): [True: 512k, False: 3]
  ------------------
 1921|   516k|           verifier.VerifyVector(testarrayofbools()) &&
  ------------------
  |  Branch (1921:12): [True: 512k, False: 15]
  ------------------
 1922|   516k|           VerifyField<float>(verifier, VT_TESTF, 4) &&
  ------------------
  |  Branch (1922:12): [True: 512k, False: 11]
  ------------------
 1923|   516k|           VerifyField<float>(verifier, VT_TESTF2, 4) &&
  ------------------
  |  Branch (1923:12): [True: 512k, False: 15]
  ------------------
 1924|   516k|           VerifyField<float>(verifier, VT_TESTF3, 4) &&
  ------------------
  |  Branch (1924:12): [True: 512k, False: 6]
  ------------------
 1925|   516k|           VerifyOffset(verifier, VT_TESTARRAYOFSTRING2) &&
  ------------------
  |  Branch (1925:12): [True: 512k, False: 11]
  ------------------
 1926|   516k|           verifier.VerifyVector(testarrayofstring2()) &&
  ------------------
  |  Branch (1926:12): [True: 512k, False: 18]
  ------------------
 1927|   516k|           verifier.VerifyVectorOfStrings(testarrayofstring2()) &&
  ------------------
  |  Branch (1927:12): [True: 512k, False: 30]
  ------------------
 1928|   516k|           VerifyOffset(verifier, VT_TESTARRAYOFSORTEDSTRUCT) &&
  ------------------
  |  Branch (1928:12): [True: 512k, False: 12]
  ------------------
 1929|   516k|           verifier.VerifyVector(testarrayofsortedstruct()) &&
  ------------------
  |  Branch (1929:12): [True: 512k, False: 50]
  ------------------
 1930|   516k|           VerifyOffset(verifier, VT_FLEX) &&
  ------------------
  |  Branch (1930:12): [True: 512k, False: 4]
  ------------------
 1931|   516k|           verifier.VerifyVector(flex()) &&
  ------------------
  |  Branch (1931:12): [True: 512k, False: 24]
  ------------------
 1932|   516k|           flexbuffers::VerifyNestedFlexBuffer(flex(), verifier) &&
  ------------------
  |  Branch (1932:12): [True: 511k, False: 852]
  ------------------
 1933|   516k|           VerifyOffset(verifier, VT_TEST5) &&
  ------------------
  |  Branch (1933:12): [True: 511k, False: 86]
  ------------------
 1934|   516k|           verifier.VerifyVector(test5()) &&
  ------------------
  |  Branch (1934:12): [True: 511k, False: 5]
  ------------------
 1935|   516k|           VerifyOffset(verifier, VT_VECTOR_OF_LONGS) &&
  ------------------
  |  Branch (1935:12): [True: 511k, False: 9]
  ------------------
 1936|   516k|           verifier.VerifyVector(vector_of_longs()) &&
  ------------------
  |  Branch (1936:12): [True: 511k, False: 71]
  ------------------
 1937|   516k|           VerifyOffset(verifier, VT_VECTOR_OF_DOUBLES) &&
  ------------------
  |  Branch (1937:12): [True: 511k, False: 11]
  ------------------
 1938|   516k|           verifier.VerifyVector(vector_of_doubles()) &&
  ------------------
  |  Branch (1938:12): [True: 511k, False: 89]
  ------------------
 1939|   516k|           VerifyOffset(verifier, VT_PARENT_NAMESPACE_TEST) &&
  ------------------
  |  Branch (1939:12): [True: 511k, False: 10]
  ------------------
 1940|   516k|           verifier.VerifyTable(parent_namespace_test()) &&
  ------------------
  |  Branch (1940:12): [True: 511k, False: 6]
  ------------------
 1941|   516k|           VerifyOffset(verifier, VT_VECTOR_OF_REFERRABLES) &&
  ------------------
  |  Branch (1941:12): [True: 511k, False: 9]
  ------------------
 1942|   516k|           verifier.VerifyVector(vector_of_referrables()) &&
  ------------------
  |  Branch (1942:12): [True: 510k, False: 89]
  ------------------
 1943|   516k|           verifier.VerifyVectorOfTables(vector_of_referrables()) &&
  ------------------
  |  Branch (1943:12): [True: 510k, False: 49]
  ------------------
 1944|   516k|           VerifyField<uint64_t>(verifier, VT_SINGLE_WEAK_REFERENCE, 8) &&
  ------------------
  |  Branch (1944:12): [True: 510k, False: 14]
  ------------------
 1945|   516k|           VerifyOffset(verifier, VT_VECTOR_OF_WEAK_REFERENCES) &&
  ------------------
  |  Branch (1945:12): [True: 510k, False: 8]
  ------------------
 1946|   516k|           verifier.VerifyVector(vector_of_weak_references()) &&
  ------------------
  |  Branch (1946:12): [True: 510k, False: 33]
  ------------------
 1947|   516k|           VerifyOffset(verifier, VT_VECTOR_OF_STRONG_REFERRABLES) &&
  ------------------
  |  Branch (1947:12): [True: 510k, False: 14]
  ------------------
 1948|   516k|           verifier.VerifyVector(vector_of_strong_referrables()) &&
  ------------------
  |  Branch (1948:12): [True: 510k, False: 8]
  ------------------
 1949|   516k|           verifier.VerifyVectorOfTables(vector_of_strong_referrables()) &&
  ------------------
  |  Branch (1949:12): [True: 510k, False: 22]
  ------------------
 1950|   516k|           VerifyField<uint64_t>(verifier, VT_CO_OWNING_REFERENCE, 8) &&
  ------------------
  |  Branch (1950:12): [True: 510k, False: 8]
  ------------------
 1951|   516k|           VerifyOffset(verifier, VT_VECTOR_OF_CO_OWNING_REFERENCES) &&
  ------------------
  |  Branch (1951:12): [True: 510k, False: 9]
  ------------------
 1952|   516k|           verifier.VerifyVector(vector_of_co_owning_references()) &&
  ------------------
  |  Branch (1952:12): [True: 510k, False: 22]
  ------------------
 1953|   516k|           VerifyField<uint64_t>(verifier, VT_NON_OWNING_REFERENCE, 8) &&
  ------------------
  |  Branch (1953:12): [True: 510k, False: 10]
  ------------------
 1954|   516k|           VerifyOffset(verifier, VT_VECTOR_OF_NON_OWNING_REFERENCES) &&
  ------------------
  |  Branch (1954:12): [True: 510k, False: 8]
  ------------------
 1955|   516k|           verifier.VerifyVector(vector_of_non_owning_references()) &&
  ------------------
  |  Branch (1955:12): [True: 510k, False: 5]
  ------------------
 1956|   516k|           VerifyField<uint8_t>(verifier, VT_ANY_UNIQUE_TYPE, 1) &&
  ------------------
  |  Branch (1956:12): [True: 510k, False: 26]
  ------------------
 1957|   516k|           VerifyOffset(verifier, VT_ANY_UNIQUE) &&
  ------------------
  |  Branch (1957:12): [True: 510k, False: 18]
  ------------------
 1958|   516k|           VerifyAnyUniqueAliases(verifier, any_unique(), any_unique_type()) &&
  ------------------
  |  Branch (1958:12): [True: 510k, False: 88]
  ------------------
 1959|   516k|           VerifyField<uint8_t>(verifier, VT_ANY_AMBIGUOUS_TYPE, 1) &&
  ------------------
  |  Branch (1959:12): [True: 510k, False: 41]
  ------------------
 1960|   516k|           VerifyOffset(verifier, VT_ANY_AMBIGUOUS) &&
  ------------------
  |  Branch (1960:12): [True: 510k, False: 11]
  ------------------
 1961|   516k|           VerifyAnyAmbiguousAliases(verifier, any_ambiguous(), any_ambiguous_type()) &&
  ------------------
  |  Branch (1961:12): [True: 510k, False: 162]
  ------------------
 1962|   516k|           VerifyOffset(verifier, VT_VECTOR_OF_ENUMS) &&
  ------------------
  |  Branch (1962:12): [True: 510k, False: 57]
  ------------------
 1963|   516k|           verifier.VerifyVector(vector_of_enums()) &&
  ------------------
  |  Branch (1963:12): [True: 510k, False: 112]
  ------------------
 1964|   516k|           VerifyField<int8_t>(verifier, VT_SIGNED_ENUM, 1) &&
  ------------------
  |  Branch (1964:12): [True: 510k, False: 43]
  ------------------
 1965|   516k|           VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
  ------------------
  |  Branch (1965:12): [True: 510k, False: 36]
  ------------------
 1966|   516k|           verifier.VerifyVector(testrequirednestedflatbuffer()) &&
  ------------------
  |  Branch (1966:12): [True: 510k, False: 19]
  ------------------
 1967|   516k|           verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
  ------------------
  |  Branch (1967:12): [True: 510k, False: 37]
  ------------------
 1968|   516k|           VerifyOffset(verifier, VT_SCALAR_KEY_SORTED_TABLES) &&
  ------------------
  |  Branch (1968:12): [True: 510k, False: 36]
  ------------------
 1969|   516k|           verifier.VerifyVector(scalar_key_sorted_tables()) &&
  ------------------
  |  Branch (1969:12): [True: 509k, False: 82]
  ------------------
 1970|   516k|           verifier.VerifyVectorOfTables(scalar_key_sorted_tables()) &&
  ------------------
  |  Branch (1970:12): [True: 509k, False: 87]
  ------------------
 1971|   516k|           VerifyField<MyGame::Example::Test>(verifier, VT_NATIVE_INLINE, 2) &&
  ------------------
  |  Branch (1971:12): [True: 509k, False: 27]
  ------------------
 1972|   516k|           VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NON_ENUM_DEFAULT, 8) &&
  ------------------
  |  Branch (1972:12): [True: 509k, False: 13]
  ------------------
 1973|   516k|           VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NORMAL_DEFAULT, 8) &&
  ------------------
  |  Branch (1973:12): [True: 509k, False: 21]
  ------------------
 1974|   516k|           VerifyField<float>(verifier, VT_NAN_DEFAULT, 4) &&
  ------------------
  |  Branch (1974:12): [True: 509k, False: 13]
  ------------------
 1975|   516k|           VerifyField<float>(verifier, VT_INF_DEFAULT, 4) &&
  ------------------
  |  Branch (1975:12): [True: 509k, False: 7]
  ------------------
 1976|   516k|           VerifyField<float>(verifier, VT_POSITIVE_INF_DEFAULT, 4) &&
  ------------------
  |  Branch (1976:12): [True: 509k, False: 4]
  ------------------
 1977|   516k|           VerifyField<float>(verifier, VT_INFINITY_DEFAULT, 4) &&
  ------------------
  |  Branch (1977:12): [True: 509k, False: 10]
  ------------------
 1978|   516k|           VerifyField<float>(verifier, VT_POSITIVE_INFINITY_DEFAULT, 4) &&
  ------------------
  |  Branch (1978:12): [True: 509k, False: 5]
  ------------------
 1979|   516k|           VerifyField<float>(verifier, VT_NEGATIVE_INF_DEFAULT, 4) &&
  ------------------
  |  Branch (1979:12): [True: 509k, False: 4]
  ------------------
 1980|   516k|           VerifyField<float>(verifier, VT_NEGATIVE_INFINITY_DEFAULT, 4) &&
  ------------------
  |  Branch (1980:12): [True: 509k, False: 9]
  ------------------
 1981|   516k|           VerifyField<double>(verifier, VT_DOUBLE_INF_DEFAULT, 8) &&
  ------------------
  |  Branch (1981:12): [True: 509k, False: 20]
  ------------------
 1982|   516k|           verifier.EndTable();
  ------------------
  |  Branch (1982:12): [True: 509k, False: 0]
  ------------------
 1983|   516k|  }
_ZNK6MyGame7Example7Monster4nameEv:
 1427|   515k|  const ::flatbuffers::String *name() const {
 1428|   515k|    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
 1429|   515k|  }
_ZNK6MyGame7Example7Monster9inventoryEv:
 1439|   515k|  const ::flatbuffers::Vector<uint8_t> *inventory() const {
 1440|   515k|    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_INVENTORY);
 1441|   515k|  }
_ZN6MyGame7Example9VerifyAnyERN11flatbuffers8VerifierEPKvNS0_3AnyE:
 3382|   515k|inline bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type) {
 3383|   515k|  switch (type) {
 3384|   140k|    case Any::NONE: {
  ------------------
  |  Branch (3384:5): [True: 140k, False: 374k]
  ------------------
 3385|   140k|      return true;
 3386|      0|    }
 3387|  1.26k|    case Any::Monster: {
  ------------------
  |  Branch (3387:5): [True: 1.26k, False: 513k]
  ------------------
 3388|  1.26k|      auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
 3389|  1.26k|      return verifier.VerifyTable(ptr);
 3390|      0|    }
 3391|  95.8k|    case Any::TestSimpleTableWithEnum: {
  ------------------
  |  Branch (3391:5): [True: 95.8k, False: 419k]
  ------------------
 3392|  95.8k|      auto ptr = reinterpret_cast<const MyGame::Example::TestSimpleTableWithEnum *>(obj);
 3393|  95.8k|      return verifier.VerifyTable(ptr);
 3394|      0|    }
 3395|   249k|    case Any::MyGame_Example2_Monster: {
  ------------------
  |  Branch (3395:5): [True: 249k, False: 266k]
  ------------------
 3396|   249k|      auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj);
 3397|   249k|      return verifier.VerifyTable(ptr);
 3398|      0|    }
 3399|  28.4k|    default: return true;
  ------------------
  |  Branch (3399:5): [True: 28.4k, False: 486k]
  ------------------
 3400|   515k|  }
 3401|   515k|}
_ZNK6MyGame7Example23TestSimpleTableWithEnum6VerifyERN11flatbuffers8VerifierE:
 1009|  2.31k|  bool Verify(::flatbuffers::Verifier &verifier) const {
 1010|  2.31k|    return VerifyTableStart(verifier) &&
  ------------------
  |  Branch (1010:12): [True: 2.31k, False: 2]
  ------------------
 1011|  2.31k|           VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
  ------------------
  |  Branch (1011:12): [True: 2.27k, False: 36]
  ------------------
 1012|  2.31k|           verifier.EndTable();
  ------------------
  |  Branch (1012:12): [True: 2.27k, False: 0]
  ------------------
 1013|  2.31k|  }
_ZNK6MyGame8Example27Monster6VerifyERN11flatbuffers8VerifierE:
  938|   248k|  bool Verify(::flatbuffers::Verifier &verifier) const {
  939|   248k|    return VerifyTableStart(verifier) &&
  ------------------
  |  Branch (939:12): [True: 248k, False: 3]
  ------------------
  940|   248k|           verifier.EndTable();
  ------------------
  |  Branch (940:12): [True: 248k, False: 0]
  ------------------
  941|   248k|  }
_ZNK6MyGame7Example7Monster4testEv:
 1454|   515k|  const void *test() const {
 1455|   515k|    return GetPointer<const void *>(VT_TEST);
 1456|   515k|  }
_ZNK6MyGame7Example7Monster9test_typeEv:
 1451|   515k|  MyGame::Example::Any test_type() const {
 1452|   515k|    return static_cast<MyGame::Example::Any>(GetField<uint8_t>(VT_TEST_TYPE, 0));
 1453|   515k|  }
_ZNK6MyGame7Example7Monster5test4Ev:
 1470|   514k|  const ::flatbuffers::Vector<const MyGame::Example::Test *> *test4() const {
 1471|   514k|    return GetPointer<const ::flatbuffers::Vector<const MyGame::Example::Test *> *>(VT_TEST4);
 1472|   514k|  }
_ZNK6MyGame7Example7Monster17testarrayofstringEv:
 1476|  1.02M|  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *testarrayofstring() const {
 1477|  1.02M|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TESTARRAYOFSTRING);
 1478|  1.02M|  }
_ZNK6MyGame7Example7Monster17testarrayoftablesEv:
 1484|  1.02M|  const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Monster>> *testarrayoftables() const {
 1485|  1.02M|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Monster>> *>(VT_TESTARRAYOFTABLES);
 1486|  1.02M|  }
_ZNK6MyGame7Example7Monster5enemyEv:
 1490|   513k|  const MyGame::Example::Monster *enemy() const {
 1491|   513k|    return GetPointer<const MyGame::Example::Monster *>(VT_ENEMY);
 1492|   513k|  }
_ZNK6MyGame7Example7Monster20testnestedflatbufferEv:
 1496|  1.02M|  const ::flatbuffers::Vector<uint8_t> *testnestedflatbuffer() const {
 1497|  1.02M|    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_TESTNESTEDFLATBUFFER);
 1498|  1.02M|  }
_ZNK6MyGame7Example4Stat6VerifyERN11flatbuffers8VerifierE:
 1110|   153k|  bool Verify(::flatbuffers::Verifier &verifier) const {
 1111|   153k|    return VerifyTableStart(verifier) &&
  ------------------
  |  Branch (1111:12): [True: 153k, False: 65]
  ------------------
 1112|   153k|           VerifyOffset(verifier, VT_ID) &&
  ------------------
  |  Branch (1112:12): [True: 153k, False: 120]
  ------------------
 1113|   153k|           verifier.VerifyString(id()) &&
  ------------------
  |  Branch (1113:12): [True: 153k, False: 132]
  ------------------
 1114|   153k|           VerifyField<int64_t>(verifier, VT_VAL, 8) &&
  ------------------
  |  Branch (1114:12): [True: 153k, False: 31]
  ------------------
 1115|   153k|           VerifyField<uint16_t>(verifier, VT_COUNT, 2) &&
  ------------------
  |  Branch (1115:12): [True: 153k, False: 15]
  ------------------
 1116|   153k|           verifier.EndTable();
  ------------------
  |  Branch (1116:12): [True: 153k, False: 0]
  ------------------
 1117|   153k|  }
_ZNK6MyGame7Example4Stat2idEv:
 1079|   153k|  const ::flatbuffers::String *id() const {
 1080|   153k|    return GetPointer<const ::flatbuffers::String *>(VT_ID);
 1081|   153k|  }
_ZNK6MyGame7Example7Monster9testemptyEv:
 1507|   512k|  const MyGame::Example::Stat *testempty() const {
 1508|   512k|    return GetPointer<const MyGame::Example::Stat *>(VT_TESTEMPTY);
 1509|   512k|  }
_ZNK6MyGame7Example7Monster16testarrayofboolsEv:
 1567|   512k|  const ::flatbuffers::Vector<uint8_t> *testarrayofbools() const {
 1568|   512k|    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_TESTARRAYOFBOOLS);
 1569|   512k|  }
_ZNK6MyGame7Example7Monster18testarrayofstring2Ev:
 1591|  1.02M|  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *testarrayofstring2() const {
 1592|  1.02M|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TESTARRAYOFSTRING2);
 1593|  1.02M|  }
_ZNK6MyGame7Example7Monster23testarrayofsortedstructEv:
 1597|   512k|  const ::flatbuffers::Vector<const MyGame::Example::Ability *> *testarrayofsortedstruct() const {
 1598|   512k|    return GetPointer<const ::flatbuffers::Vector<const MyGame::Example::Ability *> *>(VT_TESTARRAYOFSORTEDSTRUCT);
 1599|   512k|  }
_ZNK6MyGame7Example7Monster4flexEv:
 1603|  1.02M|  const ::flatbuffers::Vector<uint8_t> *flex() const {
 1604|  1.02M|    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_FLEX);
 1605|  1.02M|  }
_ZNK6MyGame7Example7Monster5test5Ev:
 1614|   511k|  const ::flatbuffers::Vector<const MyGame::Example::Test *> *test5() const {
 1615|   511k|    return GetPointer<const ::flatbuffers::Vector<const MyGame::Example::Test *> *>(VT_TEST5);
 1616|   511k|  }
_ZNK6MyGame7Example7Monster15vector_of_longsEv:
 1620|   511k|  const ::flatbuffers::Vector<int64_t> *vector_of_longs() const {
 1621|   511k|    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_VECTOR_OF_LONGS);
 1622|   511k|  }
_ZNK6MyGame7Example7Monster17vector_of_doublesEv:
 1626|   511k|  const ::flatbuffers::Vector<double> *vector_of_doubles() const {
 1627|   511k|    return GetPointer<const ::flatbuffers::Vector<double> *>(VT_VECTOR_OF_DOUBLES);
 1628|   511k|  }
_ZNK6MyGame17InParentNamespace6VerifyERN11flatbuffers8VerifierE:
  884|   117k|  bool Verify(::flatbuffers::Verifier &verifier) const {
  885|   117k|    return VerifyTableStart(verifier) &&
  ------------------
  |  Branch (885:12): [True: 117k, False: 6]
  ------------------
  886|   117k|           verifier.EndTable();
  ------------------
  |  Branch (886:12): [True: 117k, False: 0]
  ------------------
  887|   117k|  }
_ZNK6MyGame7Example7Monster21parent_namespace_testEv:
 1632|   511k|  const MyGame::InParentNamespace *parent_namespace_test() const {
 1633|   511k|    return GetPointer<const MyGame::InParentNamespace *>(VT_PARENT_NAMESPACE_TEST);
 1634|   511k|  }
_ZNK6MyGame7Example7Monster21vector_of_referrablesEv:
 1638|  1.02M|  const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *vector_of_referrables() const {
 1639|  1.02M|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *>(VT_VECTOR_OF_REFERRABLES);
 1640|  1.02M|  }
_ZNK6MyGame7Example10Referrable6VerifyERN11flatbuffers8VerifierE:
 1221|   899k|  bool Verify(::flatbuffers::Verifier &verifier) const {
 1222|   899k|    return VerifyTableStart(verifier) &&
  ------------------
  |  Branch (1222:12): [True: 898k, False: 49]
  ------------------
 1223|   899k|           VerifyField<uint64_t>(verifier, VT_ID, 8) &&
  ------------------
  |  Branch (1223:12): [True: 898k, False: 22]
  ------------------
 1224|   899k|           verifier.EndTable();
  ------------------
  |  Branch (1224:12): [True: 898k, False: 0]
  ------------------
 1225|   899k|  }
_ZNK6MyGame7Example7Monster25vector_of_weak_referencesEv:
 1650|   510k|  const ::flatbuffers::Vector<uint64_t> *vector_of_weak_references() const {
 1651|   510k|    return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_WEAK_REFERENCES);
 1652|   510k|  }
_ZNK6MyGame7Example7Monster28vector_of_strong_referrablesEv:
 1656|  1.02M|  const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *vector_of_strong_referrables() const {
 1657|  1.02M|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *>(VT_VECTOR_OF_STRONG_REFERRABLES);
 1658|  1.02M|  }
_ZNK6MyGame7Example7Monster30vector_of_co_owning_referencesEv:
 1668|   510k|  const ::flatbuffers::Vector<uint64_t> *vector_of_co_owning_references() const {
 1669|   510k|    return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_CO_OWNING_REFERENCES);
 1670|   510k|  }
_ZNK6MyGame7Example7Monster31vector_of_non_owning_referencesEv:
 1680|   510k|  const ::flatbuffers::Vector<uint64_t> *vector_of_non_owning_references() const {
 1681|   510k|    return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_NON_OWNING_REFERENCES);
 1682|   510k|  }
_ZN6MyGame7Example22VerifyAnyUniqueAliasesERN11flatbuffers8VerifierEPKvNS0_16AnyUniqueAliasesE:
 3495|   510k|inline bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type) {
 3496|   510k|  switch (type) {
 3497|   499k|    case AnyUniqueAliases::NONE: {
  ------------------
  |  Branch (3497:5): [True: 499k, False: 10.8k]
  ------------------
 3498|   499k|      return true;
 3499|      0|    }
 3500|    640|    case AnyUniqueAliases::M: {
  ------------------
  |  Branch (3500:5): [True: 640, False: 510k]
  ------------------
 3501|    640|      auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
 3502|    640|      return verifier.VerifyTable(ptr);
 3503|      0|    }
 3504|  1.54k|    case AnyUniqueAliases::TS: {
  ------------------
  |  Branch (3504:5): [True: 1.54k, False: 509k]
  ------------------
 3505|  1.54k|      auto ptr = reinterpret_cast<const MyGame::Example::TestSimpleTableWithEnum *>(obj);
 3506|  1.54k|      return verifier.VerifyTable(ptr);
 3507|      0|    }
 3508|    614|    case AnyUniqueAliases::M2: {
  ------------------
  |  Branch (3508:5): [True: 614, False: 510k]
  ------------------
 3509|    614|      auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj);
 3510|    614|      return verifier.VerifyTable(ptr);
 3511|      0|    }
 3512|  8.07k|    default: return true;
  ------------------
  |  Branch (3512:5): [True: 8.07k, False: 502k]
  ------------------
 3513|   510k|  }
 3514|   510k|}
_ZNK6MyGame7Example7Monster10any_uniqueEv:
 1689|   510k|  const void *any_unique() const {
 1690|   510k|    return GetPointer<const void *>(VT_ANY_UNIQUE);
 1691|   510k|  }
_ZNK6MyGame7Example7Monster15any_unique_typeEv:
 1686|   510k|  MyGame::Example::AnyUniqueAliases any_unique_type() const {
 1687|   510k|    return static_cast<MyGame::Example::AnyUniqueAliases>(GetField<uint8_t>(VT_ANY_UNIQUE_TYPE, 0));
 1688|   510k|  }
_ZN6MyGame7Example25VerifyAnyAmbiguousAliasesERN11flatbuffers8VerifierEPKvNS0_19AnyAmbiguousAliasesE:
 3608|   510k|inline bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type) {
 3609|   510k|  switch (type) {
 3610|   507k|    case AnyAmbiguousAliases::NONE: {
  ------------------
  |  Branch (3610:5): [True: 507k, False: 3.48k]
  ------------------
 3611|   507k|      return true;
 3612|      0|    }
 3613|    929|    case AnyAmbiguousAliases::M1: {
  ------------------
  |  Branch (3613:5): [True: 929, False: 509k]
  ------------------
 3614|    929|      auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
 3615|    929|      return verifier.VerifyTable(ptr);
 3616|      0|    }
 3617|    622|    case AnyAmbiguousAliases::M2: {
  ------------------
  |  Branch (3617:5): [True: 622, False: 509k]
  ------------------
 3618|    622|      auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
 3619|    622|      return verifier.VerifyTable(ptr);
 3620|      0|    }
 3621|    642|    case AnyAmbiguousAliases::M3: {
  ------------------
  |  Branch (3621:5): [True: 642, False: 509k]
  ------------------
 3622|    642|      auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
 3623|    642|      return verifier.VerifyTable(ptr);
 3624|      0|    }
 3625|  1.28k|    default: return true;
  ------------------
  |  Branch (3625:5): [True: 1.28k, False: 509k]
  ------------------
 3626|   510k|  }
 3627|   510k|}
_ZNK6MyGame7Example7Monster13any_ambiguousEv:
 1708|   510k|  const void *any_ambiguous() const {
 1709|   510k|    return GetPointer<const void *>(VT_ANY_AMBIGUOUS);
 1710|   510k|  }
_ZNK6MyGame7Example7Monster18any_ambiguous_typeEv:
 1705|   510k|  MyGame::Example::AnyAmbiguousAliases any_ambiguous_type() const {
 1706|   510k|    return static_cast<MyGame::Example::AnyAmbiguousAliases>(GetField<uint8_t>(VT_ANY_AMBIGUOUS_TYPE, 0));
 1707|   510k|  }
_ZNK6MyGame7Example7Monster15vector_of_enumsEv:
 1723|   510k|  const ::flatbuffers::Vector<MyGame::Example::Color> *vector_of_enums() const {
 1724|   510k|    return GetPointer<const ::flatbuffers::Vector<MyGame::Example::Color> *>(VT_VECTOR_OF_ENUMS);
 1725|   510k|  }
_ZNK6MyGame7Example7Monster28testrequirednestedflatbufferEv:
 1735|  1.02M|  const ::flatbuffers::Vector<uint8_t> *testrequirednestedflatbuffer() const {
 1736|  1.02M|    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_TESTREQUIREDNESTEDFLATBUFFER);
 1737|  1.02M|  }
_ZNK6MyGame7Example7Monster24scalar_key_sorted_tablesEv:
 1746|  1.02M|  const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables() const {
 1747|  1.02M|    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Stat>> *>(VT_SCALAR_KEY_SORTED_TABLES);
 1748|  1.02M|  }
_ZN6MyGame7Example17MonsterIdentifierEv:
 4224|  5.35k|inline const char *MonsterIdentifier() {
 4225|  5.35k|  return "MONS";
 4226|  5.35k|}

LLVMFuzzerTestOneInput:
   10|  5.35k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   11|  5.35k|  flatbuffers::Verifier verifier(data, size);
   12|  5.35k|  MyGame::Example::VerifyMonsterBuffer(verifier);
   13|  5.35k|  return 0;
   14|  5.35k|}