_ZN11flatbuffers10ReadScalarIhEET_PKv:
  426|   142k|T ReadScalar(const void *p) {
  427|   142k|  return EndianScalar(*reinterpret_cast<const T *>(p));
  428|   142k|}
_ZN11flatbuffers12EndianScalarIhEET_S1_:
  415|   142k|template<typename T> T EndianScalar(T t) {
  416|   142k|  #if FLATBUFFERS_LITTLEENDIAN
  417|   142k|    return t;
  418|       |  #else
  419|       |    return EndianSwap(t);
  420|       |  #endif
  421|   142k|}
_ZN11flatbuffers10ReadScalarItEET_PKv:
  426|   132k|T ReadScalar(const void *p) {
  427|   132k|  return EndianScalar(*reinterpret_cast<const T *>(p));
  428|   132k|}
_ZN11flatbuffers12EndianScalarItEET_S1_:
  415|   132k|template<typename T> T EndianScalar(T t) {
  416|   132k|  #if FLATBUFFERS_LITTLEENDIAN
  417|   132k|    return t;
  418|       |  #else
  419|       |    return EndianSwap(t);
  420|       |  #endif
  421|   132k|}
_ZN11flatbuffers10ReadScalarIjEET_PKv:
  426|  4.84k|T ReadScalar(const void *p) {
  427|  4.84k|  return EndianScalar(*reinterpret_cast<const T *>(p));
  428|  4.84k|}
_ZN11flatbuffers12EndianScalarIjEET_S1_:
  415|  4.84k|template<typename T> T EndianScalar(T t) {
  416|  4.84k|  #if FLATBUFFERS_LITTLEENDIAN
  417|  4.84k|    return t;
  418|       |  #else
  419|       |    return EndianSwap(t);
  420|       |  #endif
  421|  4.84k|}
_ZN11flatbuffers10ReadScalarImEET_PKv:
  426|  5.14k|T ReadScalar(const void *p) {
  427|  5.14k|  return EndianScalar(*reinterpret_cast<const T *>(p));
  428|  5.14k|}
_ZN11flatbuffers12EndianScalarImEET_S1_:
  415|  5.14k|template<typename T> T EndianScalar(T t) {
  416|  5.14k|  #if FLATBUFFERS_LITTLEENDIAN
  417|  5.14k|    return t;
  418|       |  #else
  419|       |    return EndianSwap(t);
  420|       |  #endif
  421|  5.14k|}

_ZN11flexbuffers12VerifyBufferEPKhmPNSt3__16vectorIhNS2_9allocatorIhEEEE:
 1927|  1.44k|                         std::vector<uint8_t> *reuse_tracker = nullptr) {
 1928|  1.44k|  Verifier verifier(buf, buf_len, reuse_tracker);
 1929|  1.44k|  return verifier.VerifyBuffer();
 1930|  1.44k|}
_ZN11flexbuffers8VerifierC2EPKhmPNSt3__16vectorIhNS3_9allocatorIhEEEEbm:
 1722|  1.44k|        reuse_tracker_(reuse_tracker) {
 1723|  1.44k|    FLATBUFFERS_ASSERT(size_ < FLATBUFFERS_MAX_BUFFER_SIZE);
 1724|  1.44k|    if (reuse_tracker_) {
  ------------------
  |  Branch (1724:9): [True: 1.44k, False: 0]
  ------------------
 1725|  1.44k|      reuse_tracker_->clear();
 1726|  1.44k|      reuse_tracker_->resize(size_, PackedType(BIT_WIDTH_8, FBT_NULL));
 1727|  1.44k|    }
 1728|  1.44k|  }
_ZN11flexbuffers10PackedTypeENS_8BitWidthENS_4TypeE:
  862|   108k|inline uint8_t PackedType(BitWidth bit_width, Type type) {
  863|   108k|  return static_cast<uint8_t>(bit_width | (type << 2));
  864|   108k|}
_ZN11flexbuffers8Verifier12VerifyBufferEv:
 1904|  1.44k|  bool VerifyBuffer() {
 1905|  1.44k|    if (!Check(size_ >= 3)) return false;
  ------------------
  |  Branch (1905:9): [True: 2, False: 1.43k]
  ------------------
 1906|  1.43k|    auto end = buf_ + size_;
 1907|  1.43k|    auto byte_width = *--end;
 1908|  1.43k|    auto packed_type = *--end;
 1909|  1.43k|    return VerifyByteWidth(byte_width) && Check(end - buf_ >= byte_width) &&
  ------------------
  |  Branch (1909:12): [True: 1.41k, False: 25]
  |  Branch (1909:43): [True: 1.40k, False: 5]
  ------------------
 1910|  1.43k|           VerifyRef(Reference(end - byte_width, byte_width, packed_type));
  ------------------
  |  Branch (1910:12): [True: 282, False: 1.12k]
  ------------------
 1911|  1.44k|  }
_ZNK11flexbuffers8Verifier5CheckEb:
 1732|  1.08M|  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|  1.08M|    return ok;
 1739|  1.08M|  }
_ZN11flexbuffers8Verifier15VerifyByteWidthEm:
 1758|   296k|  bool VerifyByteWidth(size_t width) {
 1759|   296k|    return Check(width == 1 || width == 2 || width == 4 || width == 8);
  ------------------
  |  Branch (1759:18): [True: 282k, False: 14.7k]
  |  Branch (1759:32): [True: 6.32k, False: 8.42k]
  |  Branch (1759:46): [True: 4.04k, False: 4.37k]
  |  Branch (1759:60): [True: 4.28k, False: 98]
  ------------------
 1760|   296k|  }
_ZN11flexbuffers8Verifier9VerifyRefENS_9ReferenceE:
 1851|   292k|  bool VerifyRef(Reference r) {
 1852|       |    // r.parent_width_ and r.data_ already verified.
 1853|   292k|    if (!VerifyByteWidth(r.byte_width_) || !VerifyType(r.type_)) {
  ------------------
  |  Branch (1853:9): [True: 0, False: 292k]
  |  Branch (1853:44): [True: 40, False: 292k]
  ------------------
 1854|     40|      return false;
 1855|     40|    }
 1856|   292k|    if (IsInline(r.type_)) {
  ------------------
  |  Branch (1856:9): [True: 175k, False: 117k]
  ------------------
 1857|       |      // Inline scalars, don't require further verification.
 1858|   175k|      return true;
 1859|   175k|    }
 1860|       |    // All remaining types are an offset.
 1861|   117k|    auto off = ReadUInt64(r.data_, r.parent_width_);
 1862|   117k|    if (!VerifyOffset(off, r.data_)) return false;
  ------------------
  |  Branch (1862:9): [True: 245, False: 116k]
  ------------------
 1863|   116k|    auto p = r.Indirect();
 1864|   116k|    if (!VerifyAlignment(p, r.byte_width_)) return false;
  ------------------
  |  Branch (1864:9): [True: 54, False: 116k]
  ------------------
 1865|   116k|    switch (r.type_) {
 1866|    775|      case FBT_INDIRECT_INT:
  ------------------
  |  Branch (1866:7): [True: 775, False: 116k]
  ------------------
 1867|  3.44k|      case FBT_INDIRECT_UINT:
  ------------------
  |  Branch (1867:7): [True: 2.67k, False: 114k]
  ------------------
 1868|  7.94k|      case FBT_INDIRECT_FLOAT: return VerifyFromPointer(p, r.byte_width_);
  ------------------
  |  Branch (1868:7): [True: 4.50k, False: 112k]
  ------------------
 1869|  72.0k|      case FBT_KEY: return VerifyKey(p);
  ------------------
  |  Branch (1869:7): [True: 72.0k, False: 44.8k]
  ------------------
 1870|  4.29k|      case FBT_MAP:
  ------------------
  |  Branch (1870:7): [True: 4.29k, False: 112k]
  ------------------
 1871|  4.29k|        return VerifyVector(r, p, FBT_NULL) && VerifyKeys(p, r.byte_width_);
  ------------------
  |  Branch (1871:16): [True: 2.76k, False: 1.53k]
  |  Branch (1871:48): [True: 2.32k, False: 439]
  ------------------
 1872|  7.38k|      case FBT_VECTOR: return VerifyVector(r, p, FBT_NULL);
  ------------------
  |  Branch (1872:7): [True: 7.38k, False: 109k]
  ------------------
 1873|    293|      case FBT_VECTOR_INT: return VerifyVector(r, p, FBT_INT);
  ------------------
  |  Branch (1873:7): [True: 293, False: 116k]
  ------------------
 1874|    291|      case FBT_VECTOR_BOOL:
  ------------------
  |  Branch (1874:7): [True: 291, False: 116k]
  ------------------
 1875|    706|      case FBT_VECTOR_UINT: return VerifyVector(r, p, FBT_UINT);
  ------------------
  |  Branch (1875:7): [True: 415, False: 116k]
  ------------------
 1876|  14.2k|      case FBT_VECTOR_FLOAT: return VerifyVector(r, p, FBT_FLOAT);
  ------------------
  |  Branch (1876:7): [True: 14.2k, False: 102k]
  ------------------
 1877|    555|      case FBT_VECTOR_KEY: return VerifyVector(r, p, FBT_KEY);
  ------------------
  |  Branch (1877:7): [True: 555, False: 116k]
  ------------------
 1878|  1.06k|      case FBT_VECTOR_STRING_DEPRECATED:
  ------------------
  |  Branch (1878:7): [True: 1.06k, False: 115k]
  ------------------
 1879|       |        // Use of FBT_KEY here intentional, see elsewhere.
 1880|  1.06k|        return VerifyVector(r, p, FBT_KEY);
 1881|    652|      case FBT_BLOB: return VerifyVector(r, p, FBT_UINT);
  ------------------
  |  Branch (1881:7): [True: 652, False: 116k]
  ------------------
 1882|  3.03k|      case FBT_STRING:
  ------------------
  |  Branch (1882:7): [True: 3.03k, False: 113k]
  ------------------
 1883|  3.03k|        return VerifyVector(r, p, FBT_UINT) &&
  ------------------
  |  Branch (1883:16): [True: 2.95k, False: 75]
  ------------------
 1884|  3.03k|               VerifyTerminator(String(p, r.byte_width_));
  ------------------
  |  Branch (1884:16): [True: 2.95k, False: 7]
  ------------------
 1885|    888|      case FBT_VECTOR_INT2:
  ------------------
  |  Branch (1885:7): [True: 888, False: 116k]
  ------------------
 1886|  1.41k|      case FBT_VECTOR_UINT2:
  ------------------
  |  Branch (1886:7): [True: 525, False: 116k]
  ------------------
 1887|  1.74k|      case FBT_VECTOR_FLOAT2:
  ------------------
  |  Branch (1887:7): [True: 331, False: 116k]
  ------------------
 1888|  2.07k|      case FBT_VECTOR_INT3:
  ------------------
  |  Branch (1888:7): [True: 332, False: 116k]
  ------------------
 1889|  2.70k|      case FBT_VECTOR_UINT3:
  ------------------
  |  Branch (1889:7): [True: 627, False: 116k]
  ------------------
 1890|  3.00k|      case FBT_VECTOR_FLOAT3:
  ------------------
  |  Branch (1890:7): [True: 306, False: 116k]
  ------------------
 1891|  3.57k|      case FBT_VECTOR_INT4:
  ------------------
  |  Branch (1891:7): [True: 570, False: 116k]
  ------------------
 1892|  4.03k|      case FBT_VECTOR_UINT4:
  ------------------
  |  Branch (1892:7): [True: 453, False: 116k]
  ------------------
 1893|  4.57k|      case FBT_VECTOR_FLOAT4: {
  ------------------
  |  Branch (1893:7): [True: 545, False: 116k]
  ------------------
 1894|  4.57k|        uint8_t len = 0;
 1895|  4.57k|        auto vtype = ToFixedTypedVectorElementType(r.type_, &len);
 1896|  4.57k|        if (!VerifyType(vtype)) return false;
  ------------------
  |  Branch (1896:13): [True: 0, False: 4.57k]
  ------------------
 1897|  4.57k|        return VerifyFromPointer(p, static_cast<size_t>(r.byte_width_) * len);
 1898|  4.57k|      }
 1899|      4|      default: return false;
  ------------------
  |  Branch (1899:7): [True: 4, False: 116k]
  ------------------
 1900|   116k|    }
 1901|   116k|  }
_ZN11flexbuffers8Verifier10VerifyTypeEi:
 1762|   297k|  bool VerifyType(int type) { return Check(type >= 0 && type < FBT_MAX_TYPE); }
  ------------------
  |  Branch (1762:44): [True: 297k, False: 0]
  |  Branch (1762:57): [True: 297k, False: 40]
  ------------------
_ZN11flexbuffers8IsInlineENS_4TypeE:
   89|   310k|inline bool IsInline(Type t) { return t <= FBT_FLOAT || t == FBT_BOOL; }
  ------------------
  |  Branch (89:39): [True: 192k, False: 117k]
  |  Branch (89:57): [True: 63, False: 117k]
  ------------------
_ZN11flexbuffers10ReadUInt64EPKhh:
  154|   284k|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|   284k|    return ReadSizedScalar<uint64_t, uint8_t, uint16_t, uint32_t, uint64_t>(
  170|   284k|             data, byte_width);
  171|   284k|  #endif
  172|       |  // clang-format on
  173|   284k|}
_ZN11flexbuffers15ReadSizedScalarImhtjmEET_PKhh:
  139|   284k|R ReadSizedScalar(const uint8_t *data, uint8_t byte_width) {
  140|   284k|  return byte_width < 4
  ------------------
  |  Branch (140:10): [True: 274k, False: 9.99k]
  ------------------
  141|   284k|             ? (byte_width < 2
  ------------------
  |  Branch (141:17): [True: 142k, False: 132k]
  ------------------
  142|   274k|                    ? static_cast<R>(flatbuffers::ReadScalar<T1>(data))
  143|   274k|                    : static_cast<R>(flatbuffers::ReadScalar<T2>(data)))
  144|   284k|             : (byte_width < 8
  ------------------
  |  Branch (144:17): [True: 4.84k, False: 5.14k]
  ------------------
  145|  9.99k|                    ? static_cast<R>(flatbuffers::ReadScalar<T4>(data))
  146|  9.99k|                    : static_cast<R>(flatbuffers::ReadScalar<T8>(data)));
  147|   284k|}
_ZN11flexbuffers8Verifier12VerifyOffsetEmPKh:
 1764|   119k|  bool VerifyOffset(uint64_t off, const uint8_t *p) {
 1765|   119k|    return Check(off <= static_cast<uint64_t>(size_)) &&
  ------------------
  |  Branch (1765:12): [True: 119k, False: 282]
  ------------------
 1766|   119k|           off <= static_cast<uint64_t>(p - buf_);
  ------------------
  |  Branch (1766:12): [True: 119k, False: 115]
  ------------------
 1767|   119k|  }
_ZNK11flexbuffers9Reference8IndirectEv:
  790|   116k|  const uint8_t *Indirect() const {
  791|   116k|    return flexbuffers::Indirect(data_, parent_width_);
  792|   116k|  }
_ZN11flexbuffers8IndirectEPKhh:
  180|   116k|inline const uint8_t *Indirect(const uint8_t *offset, uint8_t byte_width) {
  181|   116k|  return offset - ReadUInt64(offset, byte_width);
  182|   116k|}
_ZNK11flexbuffers8Verifier15VerifyAlignmentEPKhm:
 1769|   116k|  bool VerifyAlignment(const uint8_t *p, size_t size) const {
 1770|   116k|    auto o = static_cast<size_t>(p - buf_);
 1771|   116k|    return Check((o & (size - 1)) == 0 || !check_alignment_);
  ------------------
  |  Branch (1771:18): [True: 116k, False: 54]
  |  Branch (1771:43): [True: 0, False: 54]
  ------------------
 1772|   116k|  }
_ZN11flexbuffers8Verifier17VerifyFromPointerEPKhm:
 1749|  54.4k|  bool VerifyFromPointer(const uint8_t *p, size_t len) {
 1750|  54.4k|    auto o = static_cast<size_t>(p - buf_);
 1751|  54.4k|    return VerifyFrom(o, len);
 1752|  54.4k|  }
_ZNK11flexbuffers8Verifier10VerifyFromEmm:
 1742|  54.4k|  bool VerifyFrom(size_t elem, size_t elem_len) const {
 1743|  54.4k|    return Check(elem_len < size_ && elem <= size_ - elem_len);
  ------------------
  |  Branch (1743:18): [True: 54.2k, False: 267]
  |  Branch (1743:38): [True: 54.1k, False: 47]
  ------------------
 1744|  54.4k|  }
_ZN11flexbuffers8Verifier9VerifyKeyEPKh:
 1837|  72.0k|  bool VerifyKey(const uint8_t *p) {
 1838|  72.0k|    FLEX_CHECK_VERIFIED(p, PackedType(BIT_WIDTH_8, FBT_KEY));
  ------------------
  |  | 1776|  72.0k|  if (reuse_tracker_) {                                         \
  |  |  ------------------
  |  |  |  Branch (1776:7): [True: 72.0k, False: 0]
  |  |  ------------------
  |  | 1777|  72.0k|    auto packed_type = PACKED_TYPE;                             \
  |  | 1778|  72.0k|    auto existing = (*reuse_tracker_)[P - buf_];                \
  |  | 1779|  72.0k|    if (existing == packed_type) return true;                   \
  |  |  ------------------
  |  |  |  Branch (1779:9): [True: 10.4k, False: 61.6k]
  |  |  ------------------
  |  | 1780|  72.0k|    /* Fail verification if already set with different type! */ \
  |  | 1781|  72.0k|    if (!Check(existing == 0)) return false;                    \
  |  |  ------------------
  |  |  |  Branch (1781:9): [True: 16, False: 61.5k]
  |  |  ------------------
  |  | 1782|  61.6k|    (*reuse_tracker_)[P - buf_] = packed_type;                  \
  |  | 1783|  61.5k|  }
  ------------------
 1839|   172M|    while (p < buf_ + size_)
  ------------------
  |  Branch (1839:12): [True: 172M, False: 0]
  ------------------
 1840|   172M|      if (*p++) return true;
  ------------------
  |  Branch (1840:11): [True: 61.5k, False: 172M]
  ------------------
 1841|      0|    return false;
 1842|  61.5k|  }
_ZN11flexbuffers8Verifier12VerifyVectorENS_9ReferenceEPKhNS_4TypeE:
 1785|  34.7k|  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|  34.7k|    depth_++;
 1789|  34.7k|    num_vectors_++;
 1790|  34.7k|    if (!Check(depth_ <= max_depth_ && num_vectors_ <= max_vectors_))
  ------------------
  |  Branch (1790:9): [True: 67, False: 34.6k]
  |  Branch (1790:16): [True: 34.7k, False: 27]
  |  Branch (1790:40): [True: 34.6k, False: 40]
  ------------------
 1791|     67|      return false;
 1792|  34.6k|    auto size_byte_width = r.byte_width_;
 1793|  34.6k|    if (!VerifyBeforePointer(p, size_byte_width)) return false;
  ------------------
  |  Branch (1793:9): [True: 37, False: 34.6k]
  ------------------
 1794|  34.6k|    FLEX_CHECK_VERIFIED(p - size_byte_width,
  ------------------
  |  | 1776|  34.6k|  if (reuse_tracker_) {                                         \
  |  |  ------------------
  |  |  |  Branch (1776:7): [True: 34.6k, False: 0]
  |  |  ------------------
  |  | 1777|  34.6k|    auto packed_type = PACKED_TYPE;                             \
  |  | 1778|  34.6k|    auto existing = (*reuse_tracker_)[P - buf_];                \
  |  | 1779|  34.6k|    if (existing == packed_type) return true;                   \
  |  |  ------------------
  |  |  |  Branch (1779:9): [True: 4.74k, False: 29.9k]
  |  |  ------------------
  |  | 1780|  34.6k|    /* Fail verification if already set with different type! */ \
  |  | 1781|  34.6k|    if (!Check(existing == 0)) return false;                    \
  |  |  ------------------
  |  |  |  Branch (1781:9): [True: 43, False: 29.8k]
  |  |  ------------------
  |  | 1782|  29.9k|    (*reuse_tracker_)[P - buf_] = packed_type;                  \
  |  | 1783|  29.8k|  }
  ------------------
 1795|  34.6k|                        PackedType(Builder::WidthB(size_byte_width), r.type_));
 1796|  29.8k|    auto sized = Sized(p, size_byte_width);
 1797|  29.8k|    auto num_elems = sized.size();
 1798|  29.8k|    auto elem_byte_width = r.type_ == FBT_STRING || r.type_ == FBT_BLOB
  ------------------
  |  Branch (1798:28): [True: 2.39k, False: 27.4k]
  |  Branch (1798:53): [True: 512, False: 26.9k]
  ------------------
 1799|  29.8k|                               ? uint8_t(1)
 1800|  29.8k|                               : r.byte_width_;
 1801|  29.8k|    auto max_elems = SIZE_MAX / elem_byte_width;
 1802|  29.8k|    if (!Check(num_elems < max_elems))
  ------------------
  |  Branch (1802:9): [True: 25, False: 29.8k]
  ------------------
 1803|     25|      return false;  // Protect against byte_size overflowing.
 1804|  29.8k|    auto byte_size = num_elems * elem_byte_width;
 1805|  29.8k|    if (!VerifyFromPointer(p, byte_size)) return false;
  ------------------
  |  Branch (1805:9): [True: 256, False: 29.5k]
  ------------------
 1806|  29.5k|    if (elem_type == FBT_NULL) {
  ------------------
  |  Branch (1806:9): [True: 9.17k, False: 20.4k]
  ------------------
 1807|       |      // Verify type bytes after the vector.
 1808|  9.17k|      if (!VerifyFromPointer(p + byte_size, num_elems)) return false;
  ------------------
  |  Branch (1808:11): [True: 35, False: 9.13k]
  ------------------
 1809|  9.13k|      auto v = Vector(p, size_byte_width);
 1810|   224k|      for (size_t i = 0; i < num_elems; i++)
  ------------------
  |  Branch (1810:26): [True: 219k, False: 5.44k]
  ------------------
 1811|   219k|        if (!VerifyRef(v[i])) return false;
  ------------------
  |  Branch (1811:13): [True: 3.69k, False: 215k]
  ------------------
 1812|  20.4k|    } else if (elem_type == FBT_KEY) {
  ------------------
  |  Branch (1812:16): [True: 3.06k, False: 17.3k]
  ------------------
 1813|  3.06k|      auto v = TypedVector(p, elem_byte_width, FBT_KEY);
 1814|  75.0k|      for (size_t i = 0; i < num_elems; i++)
  ------------------
  |  Branch (1814:26): [True: 72.0k, False: 2.98k]
  ------------------
 1815|  72.0k|        if (!VerifyRef(v[i])) return false;
  ------------------
  |  Branch (1815:13): [True: 77, False: 72.0k]
  ------------------
 1816|  17.3k|    } else {
 1817|  17.3k|      FLATBUFFERS_ASSERT(IsInline(elem_type));
 1818|  17.3k|    }
 1819|  25.7k|    depth_--;
 1820|  25.7k|    return true;
 1821|  29.5k|  }
_ZN11flexbuffers8Verifier19VerifyBeforePointerEPKhm:
 1753|  37.4k|  bool VerifyBeforePointer(const uint8_t *p, size_t len) {
 1754|  37.4k|    auto o = static_cast<size_t>(p - buf_);
 1755|  37.4k|    return VerifyBefore(o, len);
 1756|  37.4k|  }
_ZNK11flexbuffers8Verifier12VerifyBeforeEmm:
 1745|  37.4k|  bool VerifyBefore(size_t elem, size_t elem_len) const {
 1746|  37.4k|    return Check(elem_len <= elem);
 1747|  37.4k|  }
_ZN11flexbuffers7Builder6WidthBEm:
 1466|  34.6k|  static BitWidth WidthB(size_t byte_width) {
 1467|  34.6k|    switch (byte_width) {
 1468|  28.5k|      case 1: return BIT_WIDTH_8;
  ------------------
  |  Branch (1468:7): [True: 28.5k, False: 6.13k]
  ------------------
 1469|  2.53k|      case 2: return BIT_WIDTH_16;
  ------------------
  |  Branch (1469:7): [True: 2.53k, False: 32.1k]
  ------------------
 1470|  1.85k|      case 4: return BIT_WIDTH_32;
  ------------------
  |  Branch (1470:7): [True: 1.85k, False: 32.8k]
  ------------------
 1471|  1.74k|      case 8: return BIT_WIDTH_64;
  ------------------
  |  Branch (1471:7): [True: 1.74k, False: 32.9k]
  ------------------
 1472|      0|      default: FLATBUFFERS_ASSERT(false); return BIT_WIDTH_64;
  ------------------
  |  Branch (1472:7): [True: 0, False: 34.6k]
  ------------------
 1473|  34.6k|    }
 1474|  34.6k|  }
_ZN11flexbuffers5SizedC2EPKhh:
  227|  45.0k|      : Object(data, byte_width), size_(read_size()) {}
_ZN11flexbuffers6ObjectC2EPKhh:
  215|  45.0k|      : data_(data), byte_width_(byte_width) {}
_ZNK11flexbuffers5Sized9read_sizeEv:
  233|  45.0k|  size_t read_size() const {
  234|  45.0k|    return static_cast<size_t>(ReadUInt64(data_ - byte_width_, byte_width_));
  235|  45.0k|  }
_ZNK11flexbuffers5Sized4sizeEv:
  231|   324k|  size_t size() const { return size_; }
_ZN11flexbuffers6VectorC2EPKhh:
  275|  9.13k|  Vector(const uint8_t *data, uint8_t byte_width) : Sized(data, byte_width) {}
_ZNK11flexbuffers6VectorixEm:
  875|   219k|inline Reference Vector::operator[](size_t i) const {
  876|   219k|  auto len = size();
  877|   219k|  if (i >= len) return Reference(nullptr, 1, NullPackedType());
  ------------------
  |  Branch (877:7): [True: 0, False: 219k]
  ------------------
  878|   219k|  auto packed_type = (data_ + len * byte_width_)[i];
  879|   219k|  auto elem = data_ + i * byte_width_;
  880|   219k|  return Reference(elem, byte_width_, packed_type);
  881|   219k|}
_ZN11flexbuffers11TypedVectorC2EPKhhNS_4TypeE:
  289|  3.06k|      : Sized(data, byte_width), type_(element_type) {}
_ZNK11flexbuffers11TypedVectorixEm:
  883|  72.0k|inline Reference TypedVector::operator[](size_t i) const {
  884|  72.0k|  auto len = size();
  885|  72.0k|  if (i >= len) return Reference(nullptr, 1, NullPackedType());
  ------------------
  |  Branch (885:7): [True: 0, False: 72.0k]
  ------------------
  886|  72.0k|  auto elem = data_ + i * byte_width_;
  887|  72.0k|  return Reference(elem, byte_width_, 1, type_);
  888|  72.0k|}
_ZN11flexbuffers9ReferenceC2EPKhhhNS_4TypeE:
  407|  74.5k|        type_(type) {}
_ZN11flexbuffers8Verifier10VerifyKeysEPKhh:
 1823|  2.76k|  bool VerifyKeys(const uint8_t *p, uint8_t byte_width) {
 1824|       |    // The vector part of the map has already been verified.
 1825|  2.76k|    const size_t num_prefixed_fields = 3;
 1826|  2.76k|    if (!VerifyBeforePointer(p, byte_width * num_prefixed_fields)) return false;
  ------------------
  |  Branch (1826:9): [True: 57, False: 2.71k]
  ------------------
 1827|  2.71k|    p -= byte_width * num_prefixed_fields;
 1828|  2.71k|    auto off = ReadUInt64(p, byte_width);
 1829|  2.71k|    if (!VerifyOffset(off, p)) return false;
  ------------------
  |  Branch (1829:9): [True: 152, False: 2.55k]
  ------------------
 1830|  2.55k|    auto key_byte_with =
 1831|  2.55k|        static_cast<uint8_t>(ReadUInt64(p + byte_width, byte_width));
 1832|  2.55k|    if (!VerifyByteWidth(key_byte_with)) return false;
  ------------------
  |  Branch (1832:9): [True: 73, False: 2.48k]
  ------------------
 1833|  2.48k|    return VerifyVector(Reference(p, byte_width, key_byte_with, FBT_VECTOR_KEY),
 1834|  2.48k|                        p - off, FBT_KEY);
 1835|  2.55k|  }
_ZN11flexbuffers8Verifier16VerifyTerminatorERKNS_6StringE:
 1846|  2.95k|  bool VerifyTerminator(const String &s) {
 1847|  2.95k|    return VerifyFromPointer(reinterpret_cast<const uint8_t *>(s.c_str()),
 1848|  2.95k|                             s.size() + 1);
 1849|  2.95k|  }
_ZNK11flexbuffers6String5c_strEv:
  250|  2.95k|  const char *c_str() const { return reinterpret_cast<const char *>(data_); }
_ZN11flexbuffers6StringC2EPKhh:
  244|  2.95k|  String(const uint8_t *data, uint8_t byte_width) : Sized(data, byte_width) {}
_ZN11flexbuffers29ToFixedTypedVectorElementTypeENS_4TypeEPh:
  120|  4.57k|inline Type ToFixedTypedVectorElementType(Type t, uint8_t *len) {
  121|  4.57k|  FLATBUFFERS_ASSERT(IsFixedTypedVector(t));
  122|      0|  auto fixed_type = t - FBT_VECTOR_INT2;
  123|  4.57k|  *len = static_cast<uint8_t>(fixed_type / 3 +
  124|  4.57k|                              2);  // 3 types each, starting from length 2.
  125|  4.57k|  return static_cast<Type>(fixed_type % 3 + FBT_INT);
  126|  4.57k|}
_ZN11flexbuffers18IsFixedTypedVectorENS_4TypeE:
  100|  4.57k|inline bool IsFixedTypedVector(Type t) {
  101|  4.57k|  return t >= FBT_VECTOR_INT2 && t <= FBT_VECTOR_FLOAT4;
  ------------------
  |  Branch (101:10): [True: 4.57k, False: 0]
  |  Branch (101:34): [True: 4.57k, False: 0]
  ------------------
  102|  4.57k|}
_ZN11flexbuffers9ReferenceC2EPKhhh:
  413|   220k|        type_(static_cast<Type>(packed_type >> 2)) {}

LLVMFuzzerTestOneInput:
   10|  1.44k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   11|  1.44k|  std::vector<uint8_t> reuse_tracker;
   12|       |  // Check both with and without reuse tracker paths.
   13|  1.44k|  flexbuffers::VerifyBuffer(data, size, &reuse_tracker);
   14|       |  // FIXME: we can't really verify this path, because the fuzzer will
   15|       |  // construct buffers that time out.
   16|       |  // Add a simple #define to bound the number of steps just for the fuzzer?
   17|       |  //flexbuffers::VerifyBuffer(data, size, nullptr);
   18|  1.44k|  return 0;
   19|  1.44k|}