_ZN7testing8internal16BoolFromGTestEnvEPKcb:
 1331|     18|bool BoolFromGTestEnv(const char* flag, bool default_value) {
 1332|       |#if defined(GTEST_GET_BOOL_FROM_ENV_)
 1333|       |  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
 1334|       |#else
 1335|     18|  const std::string env_var = FlagToEnvVar(flag);
 1336|     18|  const char* const string_value = posix::GetEnv(env_var.c_str());
 1337|     18|  return string_value == nullptr ? default_value
  ------------------
  |  Branch (1337:10): [True: 18, False: 0]
  ------------------
 1338|     18|                                 : strcmp(string_value, "0") != 0;
 1339|     18|#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
 1340|     18|}
_ZN7testing8internal17Int32FromGTestEnvEPKci:
 1345|      6|Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
 1346|       |#if defined(GTEST_GET_INT32_FROM_ENV_)
 1347|       |  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
 1348|       |#else
 1349|      6|  const std::string env_var = FlagToEnvVar(flag);
 1350|      6|  const char* const string_value = posix::GetEnv(env_var.c_str());
 1351|      6|  if (string_value == nullptr) {
  ------------------
  |  Branch (1351:7): [True: 6, False: 0]
  ------------------
 1352|       |    // The environment variable is not set.
 1353|      6|    return default_value;
 1354|      6|  }
 1355|       |
 1356|      0|  Int32 result = default_value;
 1357|      0|  if (!ParseInt32(Message() << "Environment variable " << env_var,
  ------------------
  |  Branch (1357:7): [True: 0, False: 0]
  ------------------
 1358|      0|                  string_value, &result)) {
 1359|      0|    printf("The default value %s is used.\n",
 1360|      0|           (Message() << default_value).GetString().c_str());
 1361|      0|    fflush(stdout);
 1362|      0|    return default_value;
 1363|      0|  }
 1364|       |
 1365|      0|  return result;
 1366|      0|#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
 1367|      0|}
_ZN7testing8internal25OutputFlagAlsoCheckEnvVarEv:
 1377|      2|std::string OutputFlagAlsoCheckEnvVar(){
 1378|      2|  std::string default_value_for_output_flag = "";
 1379|      2|  const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
 1380|      2|  if (nullptr != xml_output_file_env) {
  ------------------
  |  Branch (1380:7): [True: 0, False: 2]
  ------------------
 1381|      0|    default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
 1382|      0|  }
 1383|      2|  return default_value_for_output_flag;
 1384|      2|}
_ZN7testing8internal18StringFromGTestEnvEPKcS2_:
 1388|     12|const char* StringFromGTestEnv(const char* flag, const char* default_value) {
 1389|       |#if defined(GTEST_GET_STRING_FROM_ENV_)
 1390|       |  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
 1391|       |#else
 1392|     12|  const std::string env_var = FlagToEnvVar(flag);
 1393|     12|  const char* const value = posix::GetEnv(env_var.c_str());
 1394|     12|  return value == nullptr ? default_value : value;
  ------------------
  |  Branch (1394:10): [True: 12, False: 0]
  ------------------
 1395|     12|#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
 1396|     12|}
gtest-port.cc:_ZN7testing8internalL12FlagToEnvVarEPKc:
 1274|     36|static std::string FlagToEnvVar(const char* flag) {
 1275|     36|  const std::string full_flag =
 1276|     36|      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
 1277|       |
 1278|     36|  Message env_var;
 1279|    728|  for (size_t i = 0; i != full_flag.length(); i++) {
  ------------------
  |  Branch (1279:22): [True: 692, False: 36]
  ------------------
 1280|    692|    env_var << ToUpper(full_flag.c_str()[i]);
 1281|    692|  }
 1282|       |
 1283|     36|  return env_var.GetString();
 1284|     36|}

_ZN7testing8internal13GetTestTypeIdEv:
  641|      2|TypeId GetTestTypeId() {
  642|      2|  return GetTypeId<Test>();
  643|      2|}
_ZN7testing7MessageC2Ev:
  964|     72|Message::Message() : ss_(new ::std::stringstream) {
  965|       |  // By default, we want there to be enough precision when printing
  966|       |  // a double to a Message.
  967|     72|  *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
  968|     72|}
_ZNK7testing7Message9GetStringEv:
  990|     72|std::string Message::GetString() const {
  991|     72|  return internal::StringStreamToString(ss_.get());
  992|     72|}
_ZN7testing8internal20StringStreamToStringEPNSt3__118basic_stringstreamIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1993|     72|std::string StringStreamToString(::std::stringstream* ss) {
 1994|     72|  const ::std::string& str = ss->str();
 1995|     72|  const char* const start = str.c_str();
 1996|     72|  const char* const end = start + str.length();
 1997|       |
 1998|     72|  std::string result;
 1999|     72|  result.reserve(static_cast<size_t>(2 * (end - start)));
 2000|  1.45k|  for (const char* ch = start; ch != end; ++ch) {
  ------------------
  |  Branch (2000:32): [True: 1.38k, False: 72]
  ------------------
 2001|  1.38k|    if (*ch == '\0') {
  ------------------
  |  Branch (2001:9): [True: 0, False: 1.38k]
  ------------------
 2002|      0|      result += "\\0";  // Replaces NUL with "\\0";
 2003|  1.38k|    } else {
 2004|  1.38k|      result += *ch;
 2005|  1.38k|    }
 2006|  1.38k|  }
 2007|       |
 2008|     72|  return result;
 2009|     72|}
gtest.cc:_ZN7testingL16GetDefaultFilterEv:
  203|      2|static const char* GetDefaultFilter() {
  204|      2|  const char* const testbridge_test_only =
  205|      2|      internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");
  206|      2|  if (testbridge_test_only != nullptr) {
  ------------------
  |  Branch (206:7): [True: 0, False: 2]
  ------------------
  207|      0|    return testbridge_test_only;
  208|      0|  }
  209|      2|  return kUniversalFilter;
  210|      2|}

_ZN6google8protobuf8internal14ArenaStringPtr22DestroyNoArenaSlowPathEv:
   71|    846|void ArenaStringPtr::DestroyNoArenaSlowPath() { delete UnsafeMutablePointer(); }
_ZN6google8protobuf8internal14ArenaStringPtr7MutableENS2_12EmptyDefaultEPNS0_5ArenaE:
  120|    846|std::string* ArenaStringPtr::Mutable(EmptyDefault, ::google::protobuf::Arena* arena) {
  121|    846|  if (!IsDonatedString() && !IsDefault(&GetEmptyStringAlreadyInited())) {
  ------------------
  |  Branch (121:7): [True: 846, False: 0]
  |  Branch (121:29): [True: 0, False: 846]
  ------------------
  122|      0|    return UnsafeMutablePointer();
  123|    846|  } else {
  124|    846|    return MutableSlow(arena);
  125|    846|  }
  126|    846|}
_ZN6google8protobuf8internal14ArenaStringPtr11MutableSlowIJEEEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS0_5ArenaEDpRKT_:
  152|    846|                                         const Lazy&... lazy_default) {
  153|    846|  const std::string* const default_value =
  154|    846|      sizeof...(Lazy) == 0 ? &GetEmptyStringAlreadyInited() : nullptr;
  ------------------
  |  Branch (154:7): [Folded - Ignored]
  ------------------
  155|    846|  GOOGLE_DCHECK(IsDefault(default_value));
  156|    846|  std::string* new_string =
  157|    846|      Arena::Create<std::string>(arena, lazy_default.get()...);
  158|    846|  tagged_ptr_.Set(new_string);
  159|    846|  return new_string;
  160|    846|}

_ZN6google8protobuf14DescriptorPool24InternalAddGeneratedFileEPKvi:
 1348|     12|    const void* encoded_file_descriptor, int size) {
 1349|       |  // So, this function is called in the process of initializing the
 1350|       |  // descriptors for generated proto classes.  Each generated .pb.cc file
 1351|       |  // has an internal procedure called AddDescriptors() which is called at
 1352|       |  // process startup, and that function calls this one in order to register
 1353|       |  // the raw bytes of the FileDescriptorProto representing the file.
 1354|       |  //
 1355|       |  // We do not actually construct the descriptor objects right away.  We just
 1356|       |  // hang on to the bytes until they are actually needed.  We actually construct
 1357|       |  // the descriptor the first time one of the following things happens:
 1358|       |  // * Someone calls a method like descriptor(), GetDescriptor(), or
 1359|       |  //   GetReflection() on the generated types, which requires returning the
 1360|       |  //   descriptor or an object based on it.
 1361|       |  // * Someone looks up the descriptor in DescriptorPool::generated_pool().
 1362|       |  //
 1363|       |  // Once one of these happens, the DescriptorPool actually parses the
 1364|       |  // FileDescriptorProto and generates a FileDescriptor (and all its children)
 1365|       |  // based on it.
 1366|       |  //
 1367|       |  // Note that FileDescriptorProto is itself a generated protocol message.
 1368|       |  // Therefore, when we parse one, we have to be very careful to avoid using
 1369|       |  // any descriptor-based operations, since this might cause infinite recursion
 1370|       |  // or deadlock.
 1371|     12|  GOOGLE_CHECK(GeneratedDatabase()->Add(encoded_file_descriptor, size));
 1372|     12|}
_ZN6google8protobuf6SymbolC2Ev:
  102|      2|  inline Symbol() : type(NULL_SYMBOL) { descriptor = nullptr; }
descriptor.cc:_ZN6google8protobuf12_GLOBAL__N_117GeneratedDatabaseEv:
 1315|     12|EncodedDescriptorDatabase* GeneratedDatabase() {
 1316|     12|  static auto generated_database =
 1317|     12|      internal::OnShutdownDelete(new EncodedDescriptorDatabase());
 1318|     12|  return generated_database;
 1319|     12|}

_ZN6google8protobuf33FieldDescriptorProto_Type_IsValidEi:
 1070|    346|bool FieldDescriptorProto_Type_IsValid(int value) {
 1071|    346|  switch (value) {
 1072|      6|    case 1:
  ------------------
  |  Branch (1072:5): [True: 6, False: 340]
  ------------------
 1073|      8|    case 2:
  ------------------
  |  Branch (1073:5): [True: 2, False: 344]
  ------------------
 1074|     12|    case 3:
  ------------------
  |  Branch (1074:5): [True: 4, False: 342]
  ------------------
 1075|     16|    case 4:
  ------------------
  |  Branch (1075:5): [True: 4, False: 342]
  ------------------
 1076|     56|    case 5:
  ------------------
  |  Branch (1076:5): [True: 40, False: 306]
  ------------------
 1077|     56|    case 6:
  ------------------
  |  Branch (1077:5): [True: 0, False: 346]
  ------------------
 1078|     56|    case 7:
  ------------------
  |  Branch (1078:5): [True: 0, False: 346]
  ------------------
 1079|    114|    case 8:
  ------------------
  |  Branch (1079:5): [True: 58, False: 288]
  ------------------
 1080|    214|    case 9:
  ------------------
  |  Branch (1080:5): [True: 100, False: 246]
  ------------------
 1081|    214|    case 10:
  ------------------
  |  Branch (1081:5): [True: 0, False: 346]
  ------------------
 1082|    316|    case 11:
  ------------------
  |  Branch (1082:5): [True: 102, False: 244]
  ------------------
 1083|    322|    case 12:
  ------------------
  |  Branch (1083:5): [True: 6, False: 340]
  ------------------
 1084|    324|    case 13:
  ------------------
  |  Branch (1084:5): [True: 2, False: 344]
  ------------------
 1085|    346|    case 14:
  ------------------
  |  Branch (1085:5): [True: 22, False: 324]
  ------------------
 1086|    346|    case 15:
  ------------------
  |  Branch (1086:5): [True: 0, False: 346]
  ------------------
 1087|    346|    case 16:
  ------------------
  |  Branch (1087:5): [True: 0, False: 346]
  ------------------
 1088|    346|    case 17:
  ------------------
  |  Branch (1088:5): [True: 0, False: 346]
  ------------------
 1089|    346|    case 18:
  ------------------
  |  Branch (1089:5): [True: 0, False: 346]
  ------------------
 1090|    346|      return true;
 1091|      0|    default:
  ------------------
  |  Branch (1091:5): [True: 0, False: 346]
  ------------------
 1092|      0|      return false;
 1093|    346|  }
 1094|    346|}
_ZN6google8protobuf34FieldDescriptorProto_Label_IsValidEi:
 1123|    346|bool FieldDescriptorProto_Label_IsValid(int value) {
 1124|    346|  switch (value) {
 1125|    252|    case 1:
  ------------------
  |  Branch (1125:5): [True: 252, False: 94]
  ------------------
 1126|    256|    case 2:
  ------------------
  |  Branch (1126:5): [True: 4, False: 342]
  ------------------
 1127|    346|    case 3:
  ------------------
  |  Branch (1127:5): [True: 90, False: 256]
  ------------------
 1128|    346|      return true;
 1129|      0|    default:
  ------------------
  |  Branch (1129:5): [True: 0, False: 346]
  ------------------
 1130|      0|      return false;
 1131|    346|  }
 1132|    346|}
_ZN6google8protobuf32FileOptions_OptimizeMode_IsValidEi:
 1146|      2|bool FileOptions_OptimizeMode_IsValid(int value) {
 1147|      2|  switch (value) {
 1148|      2|    case 1:
  ------------------
  |  Branch (1148:5): [True: 2, False: 0]
  ------------------
 1149|      2|    case 2:
  ------------------
  |  Branch (1149:5): [True: 0, False: 2]
  ------------------
 1150|      2|    case 3:
  ------------------
  |  Branch (1150:5): [True: 0, False: 2]
  ------------------
 1151|      2|      return true;
 1152|      0|    default:
  ------------------
  |  Branch (1152:5): [True: 0, False: 2]
  ------------------
 1153|      0|      return false;
 1154|      2|  }
 1155|      2|}
_ZN6google8protobuf19FileDescriptorProtoC2EPNS0_5ArenaE:
 1471|     12|  weak_dependency_(arena) {
 1472|     12|  SharedCtor();
 1473|     12|  RegisterArenaDtor(arena);
 1474|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.FileDescriptorProto)
 1475|     12|}
_ZN6google8protobuf19FileDescriptorProtoD2Ev:
 1525|     12|FileDescriptorProto::~FileDescriptorProto() {
 1526|       |  // @@protoc_insertion_point(destructor:google.protobuf.FileDescriptorProto)
 1527|     12|  SharedDtor();
 1528|     12|  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 1529|     12|}
_ZN6google8protobuf19FileDescriptorProto5ClearEv:
 1550|     12|void FileDescriptorProto::Clear() {
 1551|       |// @@protoc_insertion_point(message_clear_start:google.protobuf.FileDescriptorProto)
 1552|     12|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 1553|       |  // Prevent compiler warnings about cached_has_bits being unused
 1554|     12|  (void) cached_has_bits;
 1555|       |
 1556|     12|  dependency_.Clear();
 1557|     12|  message_type_.Clear();
 1558|     12|  enum_type_.Clear();
 1559|     12|  service_.Clear();
 1560|     12|  extension_.Clear();
 1561|     12|  public_dependency_.Clear();
 1562|     12|  weak_dependency_.Clear();
 1563|     12|  cached_has_bits = _has_bits_[0];
 1564|     12|  if (cached_has_bits & 0x0000001fu) {
  ------------------
  |  Branch (1564:7): [True: 0, False: 12]
  ------------------
 1565|      0|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1565:9): [True: 0, False: 0]
  ------------------
 1566|      0|      name_.ClearNonDefaultToEmpty();
 1567|      0|    }
 1568|      0|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1568:9): [True: 0, False: 0]
  ------------------
 1569|      0|      package_.ClearNonDefaultToEmpty();
 1570|      0|    }
 1571|      0|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (1571:9): [True: 0, False: 0]
  ------------------
 1572|      0|      syntax_.ClearNonDefaultToEmpty();
 1573|      0|    }
 1574|      0|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (1574:9): [True: 0, False: 0]
  ------------------
 1575|      0|      GOOGLE_DCHECK(options_ != nullptr);
 1576|      0|      options_->Clear();
 1577|      0|    }
 1578|      0|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (1578:9): [True: 0, False: 0]
  ------------------
 1579|      0|      GOOGLE_DCHECK(source_code_info_ != nullptr);
 1580|      0|      source_code_info_->Clear();
 1581|      0|    }
 1582|      0|  }
 1583|     12|  _has_bits_.Clear();
 1584|     12|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 1585|     12|}
_ZN6google8protobuf19FileDescriptorProto14_InternalParseEPKcPNS0_8internal12ParseContextE:
 1587|     12|const char* FileDescriptorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 1588|     12|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 1589|     12|  _Internal::HasBits has_bits{};
 1590|     76|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (1590:10): [True: 64, False: 12]
  ------------------
 1591|     64|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 1592|     64|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 1593|     64|    switch (tag >> 3) {
 1594|       |      // optional string name = 1;
 1595|     12|      case 1:
  ------------------
  |  Branch (1595:7): [True: 12, False: 52]
  ------------------
 1596|     12|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
 1597|     12|          auto str = _internal_mutable_name();
 1598|     12|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 1599|       |          #ifndef NDEBUG
 1600|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FileDescriptorProto.name");
 1601|       |          #endif  // !NDEBUG
 1602|     12|          CHK_(ptr);
  ------------------
  |  | 1588|     12|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 1603|     12|        } else goto handle_unusual;
 1604|     12|        continue;
 1605|       |      // optional string package = 2;
 1606|     12|      case 2:
  ------------------
  |  Branch (1606:7): [True: 12, False: 52]
  ------------------
 1607|     12|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
 1608|     12|          auto str = _internal_mutable_package();
 1609|     12|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 1610|       |          #ifndef NDEBUG
 1611|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FileDescriptorProto.package");
 1612|       |          #endif  // !NDEBUG
 1613|     12|          CHK_(ptr);
  ------------------
  |  | 1588|     12|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 1614|     12|        } else goto handle_unusual;
 1615|     12|        continue;
 1616|       |      // repeated string dependency = 3;
 1617|     12|      case 3:
  ------------------
  |  Branch (1617:7): [True: 2, False: 62]
  ------------------
 1618|      2|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
 1619|      2|          ptr -= 1;
 1620|      4|          do {
 1621|      4|            ptr += 1;
 1622|      4|            auto str = _internal_add_dependency();
 1623|      4|            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 1624|       |            #ifndef NDEBUG
 1625|       |            ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FileDescriptorProto.dependency");
 1626|       |            #endif  // !NDEBUG
 1627|      4|            CHK_(ptr);
  ------------------
  |  | 1588|      4|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 1628|      4|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (1628:17): [True: 0, False: 4]
  ------------------
 1629|      4|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
  ------------------
  |  Branch (1629:20): [True: 2, False: 2]
  ------------------
 1630|      2|        } else goto handle_unusual;
 1631|      2|        continue;
 1632|       |      // repeated .google.protobuf.DescriptorProto message_type = 4;
 1633|     12|      case 4:
  ------------------
  |  Branch (1633:7): [True: 12, False: 52]
  ------------------
 1634|     12|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
 1635|     12|          ptr -= 1;
 1636|     80|          do {
 1637|     80|            ptr += 1;
 1638|     80|            ptr = ctx->ParseMessage(_internal_add_message_type(), ptr);
 1639|     80|            CHK_(ptr);
  ------------------
  |  | 1588|     80|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 1640|     80|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (1640:17): [True: 0, False: 80]
  ------------------
 1641|     80|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
  ------------------
  |  Branch (1641:20): [True: 68, False: 12]
  ------------------
 1642|     12|        } else goto handle_unusual;
 1643|     12|        continue;
 1644|       |      // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
 1645|     12|      case 5:
  ------------------
  |  Branch (1645:7): [True: 4, False: 60]
  ------------------
 1646|      4|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
 1647|      4|          ptr -= 1;
 1648|      4|          do {
 1649|      4|            ptr += 1;
 1650|      4|            ptr = ctx->ParseMessage(_internal_add_enum_type(), ptr);
 1651|      4|            CHK_(ptr);
  ------------------
  |  | 1588|      4|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 1652|      4|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (1652:17): [True: 0, False: 4]
  ------------------
 1653|      4|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
  ------------------
  |  Branch (1653:20): [True: 0, False: 4]
  ------------------
 1654|      4|        } else goto handle_unusual;
 1655|      4|        continue;
 1656|       |      // repeated .google.protobuf.ServiceDescriptorProto service = 6;
 1657|      4|      case 6:
  ------------------
  |  Branch (1657:7): [True: 0, False: 64]
  ------------------
 1658|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
 1659|      0|          ptr -= 1;
 1660|      0|          do {
 1661|      0|            ptr += 1;
 1662|      0|            ptr = ctx->ParseMessage(_internal_add_service(), ptr);
 1663|      0|            CHK_(ptr);
  ------------------
  |  | 1588|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 1664|      0|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (1664:17): [True: 0, False: 0]
  ------------------
 1665|      0|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
  ------------------
  |  Branch (1665:20): [True: 0, False: 0]
  ------------------
 1666|      0|        } else goto handle_unusual;
 1667|      0|        continue;
 1668|       |      // repeated .google.protobuf.FieldDescriptorProto extension = 7;
 1669|      0|      case 7:
  ------------------
  |  Branch (1669:7): [True: 0, False: 64]
  ------------------
 1670|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
 1671|      0|          ptr -= 1;
 1672|      0|          do {
 1673|      0|            ptr += 1;
 1674|      0|            ptr = ctx->ParseMessage(_internal_add_extension(), ptr);
 1675|      0|            CHK_(ptr);
  ------------------
  |  | 1588|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 1676|      0|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (1676:17): [True: 0, False: 0]
  ------------------
 1677|      0|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr));
  ------------------
  |  Branch (1677:20): [True: 0, False: 0]
  ------------------
 1678|      0|        } else goto handle_unusual;
 1679|      0|        continue;
 1680|       |      // optional .google.protobuf.FileOptions options = 8;
 1681|     12|      case 8:
  ------------------
  |  Branch (1681:7): [True: 12, False: 52]
  ------------------
 1682|     12|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
 1683|     12|          ptr = ctx->ParseMessage(_internal_mutable_options(), ptr);
 1684|     12|          CHK_(ptr);
  ------------------
  |  | 1588|     12|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 1685|     12|        } else goto handle_unusual;
 1686|     12|        continue;
 1687|       |      // optional .google.protobuf.SourceCodeInfo source_code_info = 9;
 1688|     12|      case 9:
  ------------------
  |  Branch (1688:7): [True: 0, False: 64]
  ------------------
 1689|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
 1690|      0|          ptr = ctx->ParseMessage(_internal_mutable_source_code_info(), ptr);
 1691|      0|          CHK_(ptr);
  ------------------
  |  | 1588|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 1692|      0|        } else goto handle_unusual;
 1693|      0|        continue;
 1694|       |      // repeated int32 public_dependency = 10;
 1695|      0|      case 10:
  ------------------
  |  Branch (1695:7): [True: 0, False: 64]
  ------------------
 1696|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
 1697|      0|          ptr -= 1;
 1698|      0|          do {
 1699|      0|            ptr += 1;
 1700|      0|            _internal_add_public_dependency(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
 1701|      0|            CHK_(ptr);
  ------------------
  |  | 1588|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 1702|      0|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (1702:17): [True: 0, False: 0]
  ------------------
 1703|      0|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<80>(ptr));
  ------------------
  |  Branch (1703:20): [True: 0, False: 0]
  ------------------
 1704|      0|        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82) {
  ------------------
  |  Branch (1704:20): [True: 0, False: 0]
  ------------------
 1705|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_public_dependency(), ptr, ctx);
 1706|      0|          CHK_(ptr);
  ------------------
  |  | 1588|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 1707|      0|        } else goto handle_unusual;
 1708|      0|        continue;
 1709|       |      // repeated int32 weak_dependency = 11;
 1710|      0|      case 11:
  ------------------
  |  Branch (1710:7): [True: 0, False: 64]
  ------------------
 1711|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) {
 1712|      0|          ptr -= 1;
 1713|      0|          do {
 1714|      0|            ptr += 1;
 1715|      0|            _internal_add_weak_dependency(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
 1716|      0|            CHK_(ptr);
  ------------------
  |  | 1588|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 1717|      0|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (1717:17): [True: 0, False: 0]
  ------------------
 1718|      0|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<88>(ptr));
  ------------------
  |  Branch (1718:20): [True: 0, False: 0]
  ------------------
 1719|      0|        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90) {
  ------------------
  |  Branch (1719:20): [True: 0, False: 0]
  ------------------
 1720|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_weak_dependency(), ptr, ctx);
 1721|      0|          CHK_(ptr);
  ------------------
  |  | 1588|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 1722|      0|        } else goto handle_unusual;
 1723|      0|        continue;
 1724|       |      // optional string syntax = 12;
 1725|     10|      case 12:
  ------------------
  |  Branch (1725:7): [True: 10, False: 54]
  ------------------
 1726|     10|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
 1727|     10|          auto str = _internal_mutable_syntax();
 1728|     10|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 1729|       |          #ifndef NDEBUG
 1730|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FileDescriptorProto.syntax");
 1731|       |          #endif  // !NDEBUG
 1732|     10|          CHK_(ptr);
  ------------------
  |  | 1588|     10|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 1733|     10|        } else goto handle_unusual;
 1734|     10|        continue;
 1735|     10|      default: {
  ------------------
  |  Branch (1735:7): [True: 0, False: 64]
  ------------------
 1736|      0|      handle_unusual:
 1737|      0|        if ((tag == 0) || ((tag & 7) == 4)) {
  ------------------
  |  Branch (1737:13): [True: 0, False: 0]
  |  Branch (1737:27): [True: 0, False: 0]
  ------------------
 1738|      0|          CHK_(ptr);
  ------------------
  |  | 1588|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 1739|      0|          ctx->SetLastTag(tag);
 1740|      0|          goto success;
 1741|      0|        }
 1742|      0|        ptr = UnknownFieldParse(tag,
 1743|      0|            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
 1744|      0|            ptr, ctx);
 1745|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 1588|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 1746|      0|        continue;
 1747|      0|      }
 1748|     64|    }  // switch
 1749|     64|  }  // while
 1750|     12|success:
 1751|     12|  _has_bits_.Or(has_bits);
 1752|     12|  return ptr;
 1753|      0|failure:
 1754|      0|  ptr = nullptr;
 1755|      0|  goto success;
 1756|     12|#undef CHK_
 1757|     12|}
_ZNK6google8protobuf19FileDescriptorProto13IsInitializedEv:
 2046|     12|bool FileDescriptorProto::IsInitialized() const {
 2047|     12|  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(message_type_)) return false;
  ------------------
  |  Branch (2047:7): [True: 0, False: 12]
  ------------------
 2048|     12|  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(enum_type_)) return false;
  ------------------
  |  Branch (2048:7): [True: 0, False: 12]
  ------------------
 2049|     12|  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(service_)) return false;
  ------------------
  |  Branch (2049:7): [True: 0, False: 12]
  ------------------
 2050|     12|  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(extension_)) return false;
  ------------------
  |  Branch (2050:7): [True: 0, False: 12]
  ------------------
 2051|     12|  if (_internal_has_options()) {
  ------------------
  |  Branch (2051:7): [True: 12, False: 0]
  ------------------
 2052|     12|    if (!options_->IsInitialized()) return false;
  ------------------
  |  Branch (2052:9): [True: 0, False: 12]
  ------------------
 2053|     12|  }
 2054|     12|  return true;
 2055|     12|}
_ZN6google8protobuf30DescriptorProto_ExtensionRangeC2EPNS0_5ArenaE:
 2107|     18|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 2108|     18|  SharedCtor();
 2109|     18|  RegisterArenaDtor(arena);
 2110|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.DescriptorProto.ExtensionRange)
 2111|     18|}
_ZN6google8protobuf30DescriptorProto_ExtensionRangeD2Ev:
 2134|     18|DescriptorProto_ExtensionRange::~DescriptorProto_ExtensionRange() {
 2135|       |  // @@protoc_insertion_point(destructor:google.protobuf.DescriptorProto.ExtensionRange)
 2136|     18|  SharedDtor();
 2137|     18|  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 2138|     18|}
_ZN6google8protobuf30DescriptorProto_ExtensionRange14_InternalParseEPKcPNS0_8internal12ParseContextE:
 2175|     18|const char* DescriptorProto_ExtensionRange::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 2176|     18|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 2177|     18|  _Internal::HasBits has_bits{};
 2178|     54|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (2178:10): [True: 36, False: 18]
  ------------------
 2179|     36|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 2180|     36|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 2181|     36|    switch (tag >> 3) {
 2182|       |      // optional int32 start = 1;
 2183|     18|      case 1:
  ------------------
  |  Branch (2183:7): [True: 18, False: 18]
  ------------------
 2184|     18|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
 2185|     18|          _Internal::set_has_start(&has_bits);
 2186|     18|          start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 2187|     18|          CHK_(ptr);
  ------------------
  |  | 2176|     18|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2188|     18|        } else goto handle_unusual;
 2189|     18|        continue;
 2190|       |      // optional int32 end = 2;
 2191|     18|      case 2:
  ------------------
  |  Branch (2191:7): [True: 18, False: 18]
  ------------------
 2192|     18|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
 2193|     18|          _Internal::set_has_end(&has_bits);
 2194|     18|          end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 2195|     18|          CHK_(ptr);
  ------------------
  |  | 2176|     18|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2196|     18|        } else goto handle_unusual;
 2197|     18|        continue;
 2198|       |      // optional .google.protobuf.ExtensionRangeOptions options = 3;
 2199|     18|      case 3:
  ------------------
  |  Branch (2199:7): [True: 0, False: 36]
  ------------------
 2200|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
 2201|      0|          ptr = ctx->ParseMessage(_internal_mutable_options(), ptr);
 2202|      0|          CHK_(ptr);
  ------------------
  |  | 2176|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2203|      0|        } else goto handle_unusual;
 2204|      0|        continue;
 2205|      0|      default: {
  ------------------
  |  Branch (2205:7): [True: 0, False: 36]
  ------------------
 2206|      0|      handle_unusual:
 2207|      0|        if ((tag == 0) || ((tag & 7) == 4)) {
  ------------------
  |  Branch (2207:13): [True: 0, False: 0]
  |  Branch (2207:27): [True: 0, False: 0]
  ------------------
 2208|      0|          CHK_(ptr);
  ------------------
  |  | 2176|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2209|      0|          ctx->SetLastTag(tag);
 2210|      0|          goto success;
 2211|      0|        }
 2212|      0|        ptr = UnknownFieldParse(tag,
 2213|      0|            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
 2214|      0|            ptr, ctx);
 2215|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 2176|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2216|      0|        continue;
 2217|      0|      }
 2218|     36|    }  // switch
 2219|     36|  }  // while
 2220|     18|success:
 2221|     18|  _has_bits_.Or(has_bits);
 2222|     18|  return ptr;
 2223|      0|failure:
 2224|      0|  ptr = nullptr;
 2225|      0|  goto success;
 2226|     18|#undef CHK_
 2227|     18|}
_ZNK6google8protobuf30DescriptorProto_ExtensionRange13IsInitializedEv:
 2356|     18|bool DescriptorProto_ExtensionRange::IsInitialized() const {
 2357|     18|  if (_internal_has_options()) {
  ------------------
  |  Branch (2357:7): [True: 0, False: 18]
  ------------------
 2358|      0|    if (!options_->IsInitialized()) return false;
  ------------------
  |  Branch (2358:9): [True: 0, False: 0]
  ------------------
 2359|      0|  }
 2360|     18|  return true;
 2361|     18|}
_ZN6google8protobuf29DescriptorProto_ReservedRangeC2EPNS0_5ArenaE:
 2395|     16|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 2396|     16|  SharedCtor();
 2397|     16|  RegisterArenaDtor(arena);
 2398|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.DescriptorProto.ReservedRange)
 2399|     16|}
_ZN6google8protobuf29DescriptorProto_ReservedRangeD2Ev:
 2417|     16|DescriptorProto_ReservedRange::~DescriptorProto_ReservedRange() {
 2418|       |  // @@protoc_insertion_point(destructor:google.protobuf.DescriptorProto.ReservedRange)
 2419|     16|  SharedDtor();
 2420|     16|  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 2421|     16|}
_ZN6google8protobuf29DescriptorProto_ReservedRange14_InternalParseEPKcPNS0_8internal12ParseContextE:
 2453|     16|const char* DescriptorProto_ReservedRange::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 2454|     16|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 2455|     16|  _Internal::HasBits has_bits{};
 2456|     48|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (2456:10): [True: 32, False: 16]
  ------------------
 2457|     32|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 2458|     32|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 2459|     32|    switch (tag >> 3) {
 2460|       |      // optional int32 start = 1;
 2461|     16|      case 1:
  ------------------
  |  Branch (2461:7): [True: 16, False: 16]
  ------------------
 2462|     16|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
 2463|     16|          _Internal::set_has_start(&has_bits);
 2464|     16|          start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 2465|     16|          CHK_(ptr);
  ------------------
  |  | 2454|     16|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2466|     16|        } else goto handle_unusual;
 2467|     16|        continue;
 2468|       |      // optional int32 end = 2;
 2469|     16|      case 2:
  ------------------
  |  Branch (2469:7): [True: 16, False: 16]
  ------------------
 2470|     16|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
 2471|     16|          _Internal::set_has_end(&has_bits);
 2472|     16|          end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 2473|     16|          CHK_(ptr);
  ------------------
  |  | 2454|     16|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2474|     16|        } else goto handle_unusual;
 2475|     16|        continue;
 2476|     16|      default: {
  ------------------
  |  Branch (2476:7): [True: 0, False: 32]
  ------------------
 2477|      0|      handle_unusual:
 2478|      0|        if ((tag == 0) || ((tag & 7) == 4)) {
  ------------------
  |  Branch (2478:13): [True: 0, False: 0]
  |  Branch (2478:27): [True: 0, False: 0]
  ------------------
 2479|      0|          CHK_(ptr);
  ------------------
  |  | 2454|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2480|      0|          ctx->SetLastTag(tag);
 2481|      0|          goto success;
 2482|      0|        }
 2483|      0|        ptr = UnknownFieldParse(tag,
 2484|      0|            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
 2485|      0|            ptr, ctx);
 2486|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 2454|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2487|      0|        continue;
 2488|      0|      }
 2489|     32|    }  // switch
 2490|     32|  }  // while
 2491|     16|success:
 2492|     16|  _has_bits_.Or(has_bits);
 2493|     16|  return ptr;
 2494|      0|failure:
 2495|      0|  ptr = nullptr;
 2496|      0|  goto success;
 2497|     16|#undef CHK_
 2498|     16|}
_ZN6google8protobuf15DescriptorProtoC2EPNS0_5ArenaE:
 2658|     94|  reserved_name_(arena) {
 2659|     94|  SharedCtor();
 2660|     94|  RegisterArenaDtor(arena);
 2661|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.DescriptorProto)
 2662|     94|}
_ZN6google8protobuf15DescriptorProtoD2Ev:
 2693|     94|DescriptorProto::~DescriptorProto() {
 2694|       |  // @@protoc_insertion_point(destructor:google.protobuf.DescriptorProto)
 2695|     94|  SharedDtor();
 2696|     94|  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 2697|     94|}
_ZN6google8protobuf15DescriptorProto14_InternalParseEPKcPNS0_8internal12ParseContextE:
 2743|     94|const char* DescriptorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 2744|     94|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 2745|     94|  _Internal::HasBits has_bits{};
 2746|    334|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (2746:10): [True: 240, False: 94]
  ------------------
 2747|    240|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 2748|    240|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 2749|    240|    switch (tag >> 3) {
 2750|       |      // optional string name = 1;
 2751|     94|      case 1:
  ------------------
  |  Branch (2751:7): [True: 94, False: 146]
  ------------------
 2752|     94|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
 2753|     94|          auto str = _internal_mutable_name();
 2754|     94|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 2755|       |          #ifndef NDEBUG
 2756|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.DescriptorProto.name");
 2757|       |          #endif  // !NDEBUG
 2758|     94|          CHK_(ptr);
  ------------------
  |  | 2744|     94|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2759|     94|        } else goto handle_unusual;
 2760|     94|        continue;
 2761|       |      // repeated .google.protobuf.FieldDescriptorProto field = 2;
 2762|     94|      case 2:
  ------------------
  |  Branch (2762:7): [True: 94, False: 146]
  ------------------
 2763|     94|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
 2764|     94|          ptr -= 1;
 2765|    346|          do {
 2766|    346|            ptr += 1;
 2767|    346|            ptr = ctx->ParseMessage(_internal_add_field(), ptr);
 2768|    346|            CHK_(ptr);
  ------------------
  |  | 2744|    346|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2769|    346|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (2769:17): [True: 56, False: 290]
  ------------------
 2770|    346|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
  ------------------
  |  Branch (2770:20): [True: 252, False: 38]
  ------------------
 2771|     94|        } else goto handle_unusual;
 2772|     94|        continue;
 2773|       |      // repeated .google.protobuf.DescriptorProto nested_type = 3;
 2774|     94|      case 3:
  ------------------
  |  Branch (2774:7): [True: 12, False: 228]
  ------------------
 2775|     12|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
 2776|     12|          ptr -= 1;
 2777|     14|          do {
 2778|     14|            ptr += 1;
 2779|     14|            ptr = ctx->ParseMessage(_internal_add_nested_type(), ptr);
 2780|     14|            CHK_(ptr);
  ------------------
  |  | 2744|     14|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2781|     14|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (2781:17): [True: 12, False: 2]
  ------------------
 2782|     14|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
  ------------------
  |  Branch (2782:20): [True: 2, False: 0]
  ------------------
 2783|     12|        } else goto handle_unusual;
 2784|     12|        continue;
 2785|       |      // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
 2786|     12|      case 4:
  ------------------
  |  Branch (2786:7): [True: 10, False: 230]
  ------------------
 2787|     10|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
 2788|     10|          ptr -= 1;
 2789|     16|          do {
 2790|     16|            ptr += 1;
 2791|     16|            ptr = ctx->ParseMessage(_internal_add_enum_type(), ptr);
 2792|     16|            CHK_(ptr);
  ------------------
  |  | 2744|     16|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2793|     16|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (2793:17): [True: 4, False: 12]
  ------------------
 2794|     16|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
  ------------------
  |  Branch (2794:20): [True: 6, False: 6]
  ------------------
 2795|     10|        } else goto handle_unusual;
 2796|     10|        continue;
 2797|       |      // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
 2798|     18|      case 5:
  ------------------
  |  Branch (2798:7): [True: 18, False: 222]
  ------------------
 2799|     18|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
 2800|     18|          ptr -= 1;
 2801|     18|          do {
 2802|     18|            ptr += 1;
 2803|     18|            ptr = ctx->ParseMessage(_internal_add_extension_range(), ptr);
 2804|     18|            CHK_(ptr);
  ------------------
  |  | 2744|     18|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2805|     18|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (2805:17): [True: 10, False: 8]
  ------------------
 2806|     18|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
  ------------------
  |  Branch (2806:20): [True: 0, False: 8]
  ------------------
 2807|     18|        } else goto handle_unusual;
 2808|     18|        continue;
 2809|       |      // repeated .google.protobuf.FieldDescriptorProto extension = 6;
 2810|     18|      case 6:
  ------------------
  |  Branch (2810:7): [True: 0, False: 240]
  ------------------
 2811|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
 2812|      0|          ptr -= 1;
 2813|      0|          do {
 2814|      0|            ptr += 1;
 2815|      0|            ptr = ctx->ParseMessage(_internal_add_extension(), ptr);
 2816|      0|            CHK_(ptr);
  ------------------
  |  | 2744|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2817|      0|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (2817:17): [True: 0, False: 0]
  ------------------
 2818|      0|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
  ------------------
  |  Branch (2818:20): [True: 0, False: 0]
  ------------------
 2819|      0|        } else goto handle_unusual;
 2820|      0|        continue;
 2821|       |      // optional .google.protobuf.MessageOptions options = 7;
 2822|      2|      case 7:
  ------------------
  |  Branch (2822:7): [True: 2, False: 238]
  ------------------
 2823|      2|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
 2824|      2|          ptr = ctx->ParseMessage(_internal_mutable_options(), ptr);
 2825|      2|          CHK_(ptr);
  ------------------
  |  | 2744|      2|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2826|      2|        } else goto handle_unusual;
 2827|      2|        continue;
 2828|       |      // repeated .google.protobuf.OneofDescriptorProto oneof_decl = 8;
 2829|      2|      case 8:
  ------------------
  |  Branch (2829:7): [True: 2, False: 238]
  ------------------
 2830|      2|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
 2831|      2|          ptr -= 1;
 2832|      2|          do {
 2833|      2|            ptr += 1;
 2834|      2|            ptr = ctx->ParseMessage(_internal_add_oneof_decl(), ptr);
 2835|      2|            CHK_(ptr);
  ------------------
  |  | 2744|      2|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2836|      2|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (2836:17): [True: 2, False: 0]
  ------------------
 2837|      2|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr));
  ------------------
  |  Branch (2837:20): [True: 0, False: 0]
  ------------------
 2838|      2|        } else goto handle_unusual;
 2839|      2|        continue;
 2840|       |      // repeated .google.protobuf.DescriptorProto.ReservedRange reserved_range = 9;
 2841|      8|      case 9:
  ------------------
  |  Branch (2841:7): [True: 8, False: 232]
  ------------------
 2842|      8|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
 2843|      8|          ptr -= 1;
 2844|     16|          do {
 2845|     16|            ptr += 1;
 2846|     16|            ptr = ctx->ParseMessage(_internal_add_reserved_range(), ptr);
 2847|     16|            CHK_(ptr);
  ------------------
  |  | 2744|     16|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2848|     16|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (2848:17): [True: 8, False: 8]
  ------------------
 2849|     16|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr));
  ------------------
  |  Branch (2849:20): [True: 8, False: 0]
  ------------------
 2850|      8|        } else goto handle_unusual;
 2851|      8|        continue;
 2852|       |      // repeated string reserved_name = 10;
 2853|      8|      case 10:
  ------------------
  |  Branch (2853:7): [True: 0, False: 240]
  ------------------
 2854|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
 2855|      0|          ptr -= 1;
 2856|      0|          do {
 2857|      0|            ptr += 1;
 2858|      0|            auto str = _internal_add_reserved_name();
 2859|      0|            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 2860|       |            #ifndef NDEBUG
 2861|       |            ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.DescriptorProto.reserved_name");
 2862|       |            #endif  // !NDEBUG
 2863|      0|            CHK_(ptr);
  ------------------
  |  | 2744|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2864|      0|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (2864:17): [True: 0, False: 0]
  ------------------
 2865|      0|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<82>(ptr));
  ------------------
  |  Branch (2865:20): [True: 0, False: 0]
  ------------------
 2866|      0|        } else goto handle_unusual;
 2867|      0|        continue;
 2868|      0|      default: {
  ------------------
  |  Branch (2868:7): [True: 0, False: 240]
  ------------------
 2869|      0|      handle_unusual:
 2870|      0|        if ((tag == 0) || ((tag & 7) == 4)) {
  ------------------
  |  Branch (2870:13): [True: 0, False: 0]
  |  Branch (2870:27): [True: 0, False: 0]
  ------------------
 2871|      0|          CHK_(ptr);
  ------------------
  |  | 2744|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2872|      0|          ctx->SetLastTag(tag);
 2873|      0|          goto success;
 2874|      0|        }
 2875|      0|        ptr = UnknownFieldParse(tag,
 2876|      0|            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
 2877|      0|            ptr, ctx);
 2878|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 2744|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 2879|      0|        continue;
 2880|      0|      }
 2881|    240|    }  // switch
 2882|    240|  }  // while
 2883|     94|success:
 2884|     94|  _has_bits_.Or(has_bits);
 2885|     94|  return ptr;
 2886|      0|failure:
 2887|      0|  ptr = nullptr;
 2888|      0|  goto success;
 2889|     94|#undef CHK_
 2890|     94|}
_ZNK6google8protobuf15DescriptorProto13IsInitializedEv:
 3137|     94|bool DescriptorProto::IsInitialized() const {
 3138|     94|  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(field_)) return false;
  ------------------
  |  Branch (3138:7): [True: 0, False: 94]
  ------------------
 3139|     94|  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(nested_type_)) return false;
  ------------------
  |  Branch (3139:7): [True: 0, False: 94]
  ------------------
 3140|     94|  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(enum_type_)) return false;
  ------------------
  |  Branch (3140:7): [True: 0, False: 94]
  ------------------
 3141|     94|  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(extension_range_)) return false;
  ------------------
  |  Branch (3141:7): [True: 0, False: 94]
  ------------------
 3142|     94|  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(extension_)) return false;
  ------------------
  |  Branch (3142:7): [True: 0, False: 94]
  ------------------
 3143|     94|  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(oneof_decl_)) return false;
  ------------------
  |  Branch (3143:7): [True: 0, False: 94]
  ------------------
 3144|     94|  if (_internal_has_options()) {
  ------------------
  |  Branch (3144:7): [True: 2, False: 92]
  ------------------
 3145|      2|    if (!options_->IsInitialized()) return false;
  ------------------
  |  Branch (3145:9): [True: 0, False: 2]
  ------------------
 3146|      2|  }
 3147|     94|  return true;
 3148|     94|}
_ZN6google8protobuf20FieldDescriptorProtoC2EPNS0_5ArenaE:
 3435|    346|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 3436|    346|  SharedCtor();
 3437|    346|  RegisterArenaDtor(arena);
 3438|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.FieldDescriptorProto)
 3439|    346|}
_ZN6google8protobuf20FieldDescriptorProtoD2Ev:
 3494|    346|FieldDescriptorProto::~FieldDescriptorProto() {
 3495|       |  // @@protoc_insertion_point(destructor:google.protobuf.FieldDescriptorProto)
 3496|    346|  SharedDtor();
 3497|    346|  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 3498|    346|}
_ZN6google8protobuf20FieldDescriptorProto14_InternalParseEPKcPNS0_8internal12ParseContextE:
 3562|    346|const char* FieldDescriptorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 3563|    346|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 3564|    346|  _Internal::HasBits has_bits{};
 3565|  1.92k|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (3565:10): [True: 1.57k, False: 346]
  ------------------
 3566|  1.57k|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 3567|  1.57k|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 3568|  1.57k|    switch (tag >> 3) {
 3569|       |      // optional string name = 1;
 3570|    346|      case 1:
  ------------------
  |  Branch (3570:7): [True: 346, False: 1.23k]
  ------------------
 3571|    346|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
 3572|    346|          auto str = _internal_mutable_name();
 3573|    346|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 3574|       |          #ifndef NDEBUG
 3575|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FieldDescriptorProto.name");
 3576|       |          #endif  // !NDEBUG
 3577|    346|          CHK_(ptr);
  ------------------
  |  | 3563|    346|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 3578|    346|        } else goto handle_unusual;
 3579|    346|        continue;
 3580|       |      // optional string extendee = 2;
 3581|    346|      case 2:
  ------------------
  |  Branch (3581:7): [True: 0, False: 1.57k]
  ------------------
 3582|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
 3583|      0|          auto str = _internal_mutable_extendee();
 3584|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 3585|       |          #ifndef NDEBUG
 3586|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FieldDescriptorProto.extendee");
 3587|       |          #endif  // !NDEBUG
 3588|      0|          CHK_(ptr);
  ------------------
  |  | 3563|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 3589|      0|        } else goto handle_unusual;
 3590|      0|        continue;
 3591|       |      // optional int32 number = 3;
 3592|    346|      case 3:
  ------------------
  |  Branch (3592:7): [True: 346, False: 1.23k]
  ------------------
 3593|    346|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
 3594|    346|          _Internal::set_has_number(&has_bits);
 3595|    346|          number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 3596|    346|          CHK_(ptr);
  ------------------
  |  | 3563|    346|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 3597|    346|        } else goto handle_unusual;
 3598|    346|        continue;
 3599|       |      // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
 3600|    346|      case 4:
  ------------------
  |  Branch (3600:7): [True: 346, False: 1.23k]
  ------------------
 3601|    346|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
 3602|    346|          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 3603|    346|          CHK_(ptr);
  ------------------
  |  | 3563|    346|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 3604|    346|          if (PROTOBUF_PREDICT_TRUE(PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label_IsValid(val))) {
 3605|    346|            _internal_set_label(static_cast<PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label>(val));
 3606|    346|          } else {
 3607|      0|            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
 3608|      0|          }
 3609|    346|        } else goto handle_unusual;
 3610|    346|        continue;
 3611|       |      // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
 3612|    346|      case 5:
  ------------------
  |  Branch (3612:7): [True: 346, False: 1.23k]
  ------------------
 3613|    346|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
 3614|    346|          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 3615|    346|          CHK_(ptr);
  ------------------
  |  | 3563|    346|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 3616|    346|          if (PROTOBUF_PREDICT_TRUE(PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type_IsValid(val))) {
 3617|    346|            _internal_set_type(static_cast<PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type>(val));
 3618|    346|          } else {
 3619|      0|            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
 3620|      0|          }
 3621|    346|        } else goto handle_unusual;
 3622|    346|        continue;
 3623|       |      // optional string type_name = 6;
 3624|    346|      case 6:
  ------------------
  |  Branch (3624:7): [True: 124, False: 1.45k]
  ------------------
 3625|    124|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
 3626|    124|          auto str = _internal_mutable_type_name();
 3627|    124|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 3628|       |          #ifndef NDEBUG
 3629|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FieldDescriptorProto.type_name");
 3630|       |          #endif  // !NDEBUG
 3631|    124|          CHK_(ptr);
  ------------------
  |  | 3563|    124|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 3632|    124|        } else goto handle_unusual;
 3633|    124|        continue;
 3634|       |      // optional string default_value = 7;
 3635|    124|      case 7:
  ------------------
  |  Branch (3635:7): [True: 48, False: 1.52k]
  ------------------
 3636|     48|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
 3637|     48|          auto str = _internal_mutable_default_value();
 3638|     48|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 3639|       |          #ifndef NDEBUG
 3640|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FieldDescriptorProto.default_value");
 3641|       |          #endif  // !NDEBUG
 3642|     48|          CHK_(ptr);
  ------------------
  |  | 3563|     48|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 3643|     48|        } else goto handle_unusual;
 3644|     48|        continue;
 3645|       |      // optional .google.protobuf.FieldOptions options = 8;
 3646|     48|      case 8:
  ------------------
  |  Branch (3646:7): [True: 8, False: 1.56k]
  ------------------
 3647|      8|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
 3648|      8|          ptr = ctx->ParseMessage(_internal_mutable_options(), ptr);
 3649|      8|          CHK_(ptr);
  ------------------
  |  | 3563|      8|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 3650|      8|        } else goto handle_unusual;
 3651|      8|        continue;
 3652|       |      // optional int32 oneof_index = 9;
 3653|     12|      case 9:
  ------------------
  |  Branch (3653:7): [True: 12, False: 1.56k]
  ------------------
 3654|     12|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
 3655|     12|          _Internal::set_has_oneof_index(&has_bits);
 3656|     12|          oneof_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 3657|     12|          CHK_(ptr);
  ------------------
  |  | 3563|     12|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 3658|     12|        } else goto handle_unusual;
 3659|     12|        continue;
 3660|       |      // optional string json_name = 10;
 3661|     12|      case 10:
  ------------------
  |  Branch (3661:7): [True: 0, False: 1.57k]
  ------------------
 3662|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
 3663|      0|          auto str = _internal_mutable_json_name();
 3664|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 3665|       |          #ifndef NDEBUG
 3666|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FieldDescriptorProto.json_name");
 3667|       |          #endif  // !NDEBUG
 3668|      0|          CHK_(ptr);
  ------------------
  |  | 3563|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 3669|      0|        } else goto handle_unusual;
 3670|      0|        continue;
 3671|       |      // optional bool proto3_optional = 17;
 3672|      0|      case 17:
  ------------------
  |  Branch (3672:7): [True: 0, False: 1.57k]
  ------------------
 3673|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 136)) {
 3674|      0|          _Internal::set_has_proto3_optional(&has_bits);
 3675|      0|          proto3_optional_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 3676|      0|          CHK_(ptr);
  ------------------
  |  | 3563|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 3677|      0|        } else goto handle_unusual;
 3678|      0|        continue;
 3679|      0|      default: {
  ------------------
  |  Branch (3679:7): [True: 0, False: 1.57k]
  ------------------
 3680|      0|      handle_unusual:
 3681|      0|        if ((tag == 0) || ((tag & 7) == 4)) {
  ------------------
  |  Branch (3681:13): [True: 0, False: 0]
  |  Branch (3681:27): [True: 0, False: 0]
  ------------------
 3682|      0|          CHK_(ptr);
  ------------------
  |  | 3563|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 3683|      0|          ctx->SetLastTag(tag);
 3684|      0|          goto success;
 3685|      0|        }
 3686|      0|        ptr = UnknownFieldParse(tag,
 3687|      0|            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
 3688|      0|            ptr, ctx);
 3689|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 3563|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 3690|      0|        continue;
 3691|      0|      }
 3692|  1.57k|    }  // switch
 3693|  1.57k|  }  // while
 3694|    346|success:
 3695|    346|  _has_bits_.Or(has_bits);
 3696|    346|  return ptr;
 3697|      0|failure:
 3698|      0|  ptr = nullptr;
 3699|      0|  goto success;
 3700|    346|#undef CHK_
 3701|    346|}
_ZNK6google8protobuf20FieldDescriptorProto13IsInitializedEv:
 3981|    346|bool FieldDescriptorProto::IsInitialized() const {
 3982|    346|  if (_internal_has_options()) {
  ------------------
  |  Branch (3982:7): [True: 8, False: 338]
  ------------------
 3983|      8|    if (!options_->IsInitialized()) return false;
  ------------------
  |  Branch (3983:9): [True: 0, False: 8]
  ------------------
 3984|      8|  }
 3985|    346|  return true;
 3986|    346|}
_ZN6google8protobuf20OneofDescriptorProtoC2EPNS0_5ArenaE:
 4032|      2|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 4033|      2|  SharedCtor();
 4034|      2|  RegisterArenaDtor(arena);
 4035|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.OneofDescriptorProto)
 4036|      2|}
_ZN6google8protobuf20OneofDescriptorProtoD2Ev:
 4059|      2|OneofDescriptorProto::~OneofDescriptorProto() {
 4060|       |  // @@protoc_insertion_point(destructor:google.protobuf.OneofDescriptorProto)
 4061|      2|  SharedDtor();
 4062|      2|  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 4063|      2|}
_ZN6google8protobuf20OneofDescriptorProto14_InternalParseEPKcPNS0_8internal12ParseContextE:
 4101|      2|const char* OneofDescriptorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 4102|      2|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 4103|      2|  _Internal::HasBits has_bits{};
 4104|      4|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (4104:10): [True: 2, False: 2]
  ------------------
 4105|      2|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 4106|      2|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 4107|      2|    switch (tag >> 3) {
 4108|       |      // optional string name = 1;
 4109|      2|      case 1:
  ------------------
  |  Branch (4109:7): [True: 2, False: 0]
  ------------------
 4110|      2|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
 4111|      2|          auto str = _internal_mutable_name();
 4112|      2|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 4113|       |          #ifndef NDEBUG
 4114|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.OneofDescriptorProto.name");
 4115|       |          #endif  // !NDEBUG
 4116|      2|          CHK_(ptr);
  ------------------
  |  | 4102|      2|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 4117|      2|        } else goto handle_unusual;
 4118|      2|        continue;
 4119|       |      // optional .google.protobuf.OneofOptions options = 2;
 4120|      2|      case 2:
  ------------------
  |  Branch (4120:7): [True: 0, False: 2]
  ------------------
 4121|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
 4122|      0|          ptr = ctx->ParseMessage(_internal_mutable_options(), ptr);
 4123|      0|          CHK_(ptr);
  ------------------
  |  | 4102|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 4124|      0|        } else goto handle_unusual;
 4125|      0|        continue;
 4126|      0|      default: {
  ------------------
  |  Branch (4126:7): [True: 0, False: 2]
  ------------------
 4127|      0|      handle_unusual:
 4128|      0|        if ((tag == 0) || ((tag & 7) == 4)) {
  ------------------
  |  Branch (4128:13): [True: 0, False: 0]
  |  Branch (4128:27): [True: 0, False: 0]
  ------------------
 4129|      0|          CHK_(ptr);
  ------------------
  |  | 4102|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 4130|      0|          ctx->SetLastTag(tag);
 4131|      0|          goto success;
 4132|      0|        }
 4133|      0|        ptr = UnknownFieldParse(tag,
 4134|      0|            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
 4135|      0|            ptr, ctx);
 4136|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 4102|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 4137|      0|        continue;
 4138|      0|      }
 4139|      2|    }  // switch
 4140|      2|  }  // while
 4141|      2|success:
 4142|      2|  _has_bits_.Or(has_bits);
 4143|      2|  return ptr;
 4144|      0|failure:
 4145|      0|  ptr = nullptr;
 4146|      0|  goto success;
 4147|      2|#undef CHK_
 4148|      2|}
_ZNK6google8protobuf20OneofDescriptorProto13IsInitializedEv:
 4264|      2|bool OneofDescriptorProto::IsInitialized() const {
 4265|      2|  if (_internal_has_options()) {
  ------------------
  |  Branch (4265:7): [True: 0, False: 2]
  ------------------
 4266|      0|    if (!options_->IsInitialized()) return false;
  ------------------
  |  Branch (4266:9): [True: 0, False: 0]
  ------------------
 4267|      0|  }
 4268|      2|  return true;
 4269|      2|}
_ZN6google8protobuf19EnumDescriptorProtoC2EPNS0_5ArenaE:
 4557|     20|  reserved_name_(arena) {
 4558|     20|  SharedCtor();
 4559|     20|  RegisterArenaDtor(arena);
 4560|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.EnumDescriptorProto)
 4561|     20|}
_ZN6google8protobuf19EnumDescriptorProtoD2Ev:
 4587|     20|EnumDescriptorProto::~EnumDescriptorProto() {
 4588|       |  // @@protoc_insertion_point(destructor:google.protobuf.EnumDescriptorProto)
 4589|     20|  SharedDtor();
 4590|     20|  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 4591|     20|}
_ZN6google8protobuf19EnumDescriptorProto14_InternalParseEPKcPNS0_8internal12ParseContextE:
 4632|     20|const char* EnumDescriptorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 4633|     20|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 4634|     20|  _Internal::HasBits has_bits{};
 4635|     60|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (4635:10): [True: 40, False: 20]
  ------------------
 4636|     40|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 4637|     40|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 4638|     40|    switch (tag >> 3) {
 4639|       |      // optional string name = 1;
 4640|     20|      case 1:
  ------------------
  |  Branch (4640:7): [True: 20, False: 20]
  ------------------
 4641|     20|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
 4642|     20|          auto str = _internal_mutable_name();
 4643|     20|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 4644|       |          #ifndef NDEBUG
 4645|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.EnumDescriptorProto.name");
 4646|       |          #endif  // !NDEBUG
 4647|     20|          CHK_(ptr);
  ------------------
  |  | 4633|     20|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 4648|     20|        } else goto handle_unusual;
 4649|     20|        continue;
 4650|       |      // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
 4651|     20|      case 2:
  ------------------
  |  Branch (4651:7): [True: 20, False: 20]
  ------------------
 4652|     20|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
 4653|     20|          ptr -= 1;
 4654|    118|          do {
 4655|    118|            ptr += 1;
 4656|    118|            ptr = ctx->ParseMessage(_internal_add_value(), ptr);
 4657|    118|            CHK_(ptr);
  ------------------
  |  | 4633|    118|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 4658|    118|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (4658:17): [True: 20, False: 98]
  ------------------
 4659|    118|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
  ------------------
  |  Branch (4659:20): [True: 98, False: 0]
  ------------------
 4660|     20|        } else goto handle_unusual;
 4661|     20|        continue;
 4662|       |      // optional .google.protobuf.EnumOptions options = 3;
 4663|     20|      case 3:
  ------------------
  |  Branch (4663:7): [True: 0, False: 40]
  ------------------
 4664|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
 4665|      0|          ptr = ctx->ParseMessage(_internal_mutable_options(), ptr);
 4666|      0|          CHK_(ptr);
  ------------------
  |  | 4633|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 4667|      0|        } else goto handle_unusual;
 4668|      0|        continue;
 4669|       |      // repeated .google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4;
 4670|      0|      case 4:
  ------------------
  |  Branch (4670:7): [True: 0, False: 40]
  ------------------
 4671|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
 4672|      0|          ptr -= 1;
 4673|      0|          do {
 4674|      0|            ptr += 1;
 4675|      0|            ptr = ctx->ParseMessage(_internal_add_reserved_range(), ptr);
 4676|      0|            CHK_(ptr);
  ------------------
  |  | 4633|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 4677|      0|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (4677:17): [True: 0, False: 0]
  ------------------
 4678|      0|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
  ------------------
  |  Branch (4678:20): [True: 0, False: 0]
  ------------------
 4679|      0|        } else goto handle_unusual;
 4680|      0|        continue;
 4681|       |      // repeated string reserved_name = 5;
 4682|      0|      case 5:
  ------------------
  |  Branch (4682:7): [True: 0, False: 40]
  ------------------
 4683|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
 4684|      0|          ptr -= 1;
 4685|      0|          do {
 4686|      0|            ptr += 1;
 4687|      0|            auto str = _internal_add_reserved_name();
 4688|      0|            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 4689|       |            #ifndef NDEBUG
 4690|       |            ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.EnumDescriptorProto.reserved_name");
 4691|       |            #endif  // !NDEBUG
 4692|      0|            CHK_(ptr);
  ------------------
  |  | 4633|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 4693|      0|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (4693:17): [True: 0, False: 0]
  ------------------
 4694|      0|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
  ------------------
  |  Branch (4694:20): [True: 0, False: 0]
  ------------------
 4695|      0|        } else goto handle_unusual;
 4696|      0|        continue;
 4697|      0|      default: {
  ------------------
  |  Branch (4697:7): [True: 0, False: 40]
  ------------------
 4698|      0|      handle_unusual:
 4699|      0|        if ((tag == 0) || ((tag & 7) == 4)) {
  ------------------
  |  Branch (4699:13): [True: 0, False: 0]
  |  Branch (4699:27): [True: 0, False: 0]
  ------------------
 4700|      0|          CHK_(ptr);
  ------------------
  |  | 4633|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 4701|      0|          ctx->SetLastTag(tag);
 4702|      0|          goto success;
 4703|      0|        }
 4704|      0|        ptr = UnknownFieldParse(tag,
 4705|      0|            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
 4706|      0|            ptr, ctx);
 4707|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 4633|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 4708|      0|        continue;
 4709|      0|      }
 4710|     40|    }  // switch
 4711|     40|  }  // while
 4712|     20|success:
 4713|     20|  _has_bits_.Or(has_bits);
 4714|     20|  return ptr;
 4715|      0|failure:
 4716|      0|  ptr = nullptr;
 4717|      0|  goto success;
 4718|     20|#undef CHK_
 4719|     20|}
_ZNK6google8protobuf19EnumDescriptorProto13IsInitializedEv:
 4886|     20|bool EnumDescriptorProto::IsInitialized() const {
 4887|     20|  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(value_)) return false;
  ------------------
  |  Branch (4887:7): [True: 0, False: 20]
  ------------------
 4888|     20|  if (_internal_has_options()) {
  ------------------
  |  Branch (4888:7): [True: 0, False: 20]
  ------------------
 4889|      0|    if (!options_->IsInitialized()) return false;
  ------------------
  |  Branch (4889:9): [True: 0, False: 0]
  ------------------
 4890|      0|  }
 4891|     20|  return true;
 4892|     20|}
_ZN6google8protobuf24EnumValueDescriptorProtoC2EPNS0_5ArenaE:
 4933|    118|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 4934|    118|  SharedCtor();
 4935|    118|  RegisterArenaDtor(arena);
 4936|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.EnumValueDescriptorProto)
 4937|    118|}
_ZN6google8protobuf24EnumValueDescriptorProtoD2Ev:
 4964|    118|EnumValueDescriptorProto::~EnumValueDescriptorProto() {
 4965|       |  // @@protoc_insertion_point(destructor:google.protobuf.EnumValueDescriptorProto)
 4966|    118|  SharedDtor();
 4967|    118|  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 4968|    118|}
_ZN6google8protobuf24EnumValueDescriptorProto14_InternalParseEPKcPNS0_8internal12ParseContextE:
 5007|    118|const char* EnumValueDescriptorProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 5008|    118|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 5009|    118|  _Internal::HasBits has_bits{};
 5010|    354|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (5010:10): [True: 236, False: 118]
  ------------------
 5011|    236|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 5012|    236|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 5013|    236|    switch (tag >> 3) {
 5014|       |      // optional string name = 1;
 5015|    118|      case 1:
  ------------------
  |  Branch (5015:7): [True: 118, False: 118]
  ------------------
 5016|    118|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
 5017|    118|          auto str = _internal_mutable_name();
 5018|    118|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 5019|       |          #ifndef NDEBUG
 5020|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.EnumValueDescriptorProto.name");
 5021|       |          #endif  // !NDEBUG
 5022|    118|          CHK_(ptr);
  ------------------
  |  | 5008|    118|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 5023|    118|        } else goto handle_unusual;
 5024|    118|        continue;
 5025|       |      // optional int32 number = 2;
 5026|    118|      case 2:
  ------------------
  |  Branch (5026:7): [True: 118, False: 118]
  ------------------
 5027|    118|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
 5028|    118|          _Internal::set_has_number(&has_bits);
 5029|    118|          number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 5030|    118|          CHK_(ptr);
  ------------------
  |  | 5008|    118|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 5031|    118|        } else goto handle_unusual;
 5032|    118|        continue;
 5033|       |      // optional .google.protobuf.EnumValueOptions options = 3;
 5034|    118|      case 3:
  ------------------
  |  Branch (5034:7): [True: 0, False: 236]
  ------------------
 5035|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
 5036|      0|          ptr = ctx->ParseMessage(_internal_mutable_options(), ptr);
 5037|      0|          CHK_(ptr);
  ------------------
  |  | 5008|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 5038|      0|        } else goto handle_unusual;
 5039|      0|        continue;
 5040|      0|      default: {
  ------------------
  |  Branch (5040:7): [True: 0, False: 236]
  ------------------
 5041|      0|      handle_unusual:
 5042|      0|        if ((tag == 0) || ((tag & 7) == 4)) {
  ------------------
  |  Branch (5042:13): [True: 0, False: 0]
  |  Branch (5042:27): [True: 0, False: 0]
  ------------------
 5043|      0|          CHK_(ptr);
  ------------------
  |  | 5008|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 5044|      0|          ctx->SetLastTag(tag);
 5045|      0|          goto success;
 5046|      0|        }
 5047|      0|        ptr = UnknownFieldParse(tag,
 5048|      0|            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
 5049|      0|            ptr, ctx);
 5050|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 5008|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 5051|      0|        continue;
 5052|      0|      }
 5053|    236|    }  // switch
 5054|    236|  }  // while
 5055|    118|success:
 5056|    118|  _has_bits_.Or(has_bits);
 5057|    118|  return ptr;
 5058|      0|failure:
 5059|      0|  ptr = nullptr;
 5060|      0|  goto success;
 5061|    118|#undef CHK_
 5062|    118|}
_ZNK6google8protobuf24EnumValueDescriptorProto13IsInitializedEv:
 5195|    118|bool EnumValueDescriptorProto::IsInitialized() const {
 5196|    118|  if (_internal_has_options()) {
  ------------------
  |  Branch (5196:7): [True: 0, False: 118]
  ------------------
 5197|      0|    if (!options_->IsInitialized()) return false;
  ------------------
  |  Branch (5197:9): [True: 0, False: 0]
  ------------------
 5198|      0|  }
 5199|    118|  return true;
 5200|    118|}
_ZN6google8protobuf11FileOptionsC2EPNS0_5ArenaE:
 6023|     12|  uninterpreted_option_(arena) {
 6024|     12|  SharedCtor();
 6025|     12|  RegisterArenaDtor(arena);
 6026|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.FileOptions)
 6027|     12|}
_ZN6google8protobuf11FileOptionsD2Ev:
 6109|     12|FileOptions::~FileOptions() {
 6110|       |  // @@protoc_insertion_point(destructor:google.protobuf.FileOptions)
 6111|     12|  SharedDtor();
 6112|     12|  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 6113|     12|}
_ZN6google8protobuf11FileOptions14_InternalParseEPKcPNS0_8internal12ParseContextE:
 6198|     12|const char* FileOptions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 6199|     12|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 6200|     12|  _Internal::HasBits has_bits{};
 6201|     92|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (6201:10): [True: 80, False: 12]
  ------------------
 6202|     80|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 6203|     80|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 6204|     80|    switch (tag >> 3) {
 6205|       |      // optional string java_package = 1;
 6206|     12|      case 1:
  ------------------
  |  Branch (6206:7): [True: 12, False: 68]
  ------------------
 6207|     12|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
 6208|     12|          auto str = _internal_mutable_java_package();
 6209|     12|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 6210|       |          #ifndef NDEBUG
 6211|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FileOptions.java_package");
 6212|       |          #endif  // !NDEBUG
 6213|     12|          CHK_(ptr);
  ------------------
  |  | 6199|     12|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6214|     12|        } else goto handle_unusual;
 6215|     12|        continue;
 6216|       |      // optional string java_outer_classname = 8;
 6217|     12|      case 8:
  ------------------
  |  Branch (6217:7): [True: 12, False: 68]
  ------------------
 6218|     12|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
 6219|     12|          auto str = _internal_mutable_java_outer_classname();
 6220|     12|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 6221|       |          #ifndef NDEBUG
 6222|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FileOptions.java_outer_classname");
 6223|       |          #endif  // !NDEBUG
 6224|     12|          CHK_(ptr);
  ------------------
  |  | 6199|     12|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6225|     12|        } else goto handle_unusual;
 6226|     12|        continue;
 6227|       |      // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
 6228|     12|      case 9:
  ------------------
  |  Branch (6228:7): [True: 2, False: 78]
  ------------------
 6229|      2|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
 6230|      2|          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 6231|      2|          CHK_(ptr);
  ------------------
  |  | 6199|      2|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6232|      2|          if (PROTOBUF_PREDICT_TRUE(PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode_IsValid(val))) {
 6233|      2|            _internal_set_optimize_for(static_cast<PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode>(val));
 6234|      2|          } else {
 6235|      0|            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(9, val, mutable_unknown_fields());
 6236|      0|          }
 6237|      2|        } else goto handle_unusual;
 6238|      2|        continue;
 6239|       |      // optional bool java_multiple_files = 10 [default = false];
 6240|     10|      case 10:
  ------------------
  |  Branch (6240:7): [True: 10, False: 70]
  ------------------
 6241|     10|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
 6242|     10|          _Internal::set_has_java_multiple_files(&has_bits);
 6243|     10|          java_multiple_files_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 6244|     10|          CHK_(ptr);
  ------------------
  |  | 6199|     10|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6245|     10|        } else goto handle_unusual;
 6246|     10|        continue;
 6247|       |      // optional string go_package = 11;
 6248|     12|      case 11:
  ------------------
  |  Branch (6248:7): [True: 12, False: 68]
  ------------------
 6249|     12|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
 6250|     12|          auto str = _internal_mutable_go_package();
 6251|     12|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 6252|       |          #ifndef NDEBUG
 6253|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FileOptions.go_package");
 6254|       |          #endif  // !NDEBUG
 6255|     12|          CHK_(ptr);
  ------------------
  |  | 6199|     12|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6256|     12|        } else goto handle_unusual;
 6257|     12|        continue;
 6258|       |      // optional bool cc_generic_services = 16 [default = false];
 6259|     12|      case 16:
  ------------------
  |  Branch (6259:7): [True: 0, False: 80]
  ------------------
 6260|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 128)) {
 6261|      0|          _Internal::set_has_cc_generic_services(&has_bits);
 6262|      0|          cc_generic_services_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 6263|      0|          CHK_(ptr);
  ------------------
  |  | 6199|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6264|      0|        } else goto handle_unusual;
 6265|      0|        continue;
 6266|       |      // optional bool java_generic_services = 17 [default = false];
 6267|      0|      case 17:
  ------------------
  |  Branch (6267:7): [True: 0, False: 80]
  ------------------
 6268|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 136)) {
 6269|      0|          _Internal::set_has_java_generic_services(&has_bits);
 6270|      0|          java_generic_services_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 6271|      0|          CHK_(ptr);
  ------------------
  |  | 6199|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6272|      0|        } else goto handle_unusual;
 6273|      0|        continue;
 6274|       |      // optional bool py_generic_services = 18 [default = false];
 6275|      0|      case 18:
  ------------------
  |  Branch (6275:7): [True: 0, False: 80]
  ------------------
 6276|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 144)) {
 6277|      0|          _Internal::set_has_py_generic_services(&has_bits);
 6278|      0|          py_generic_services_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 6279|      0|          CHK_(ptr);
  ------------------
  |  | 6199|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6280|      0|        } else goto handle_unusual;
 6281|      0|        continue;
 6282|       |      // optional bool java_generate_equals_and_hash = 20 [deprecated = true];
 6283|      0|      case 20:
  ------------------
  |  Branch (6283:7): [True: 0, False: 80]
  ------------------
 6284|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 160)) {
 6285|      0|          _Internal::set_has_java_generate_equals_and_hash(&has_bits);
 6286|      0|          java_generate_equals_and_hash_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 6287|      0|          CHK_(ptr);
  ------------------
  |  | 6199|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6288|      0|        } else goto handle_unusual;
 6289|      0|        continue;
 6290|       |      // optional bool deprecated = 23 [default = false];
 6291|      0|      case 23:
  ------------------
  |  Branch (6291:7): [True: 0, False: 80]
  ------------------
 6292|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 184)) {
 6293|      0|          _Internal::set_has_deprecated(&has_bits);
 6294|      0|          deprecated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 6295|      0|          CHK_(ptr);
  ------------------
  |  | 6199|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6296|      0|        } else goto handle_unusual;
 6297|      0|        continue;
 6298|       |      // optional bool java_string_check_utf8 = 27 [default = false];
 6299|      0|      case 27:
  ------------------
  |  Branch (6299:7): [True: 0, False: 80]
  ------------------
 6300|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 216)) {
 6301|      0|          _Internal::set_has_java_string_check_utf8(&has_bits);
 6302|      0|          java_string_check_utf8_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 6303|      0|          CHK_(ptr);
  ------------------
  |  | 6199|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6304|      0|        } else goto handle_unusual;
 6305|      0|        continue;
 6306|       |      // optional bool cc_enable_arenas = 31 [default = true];
 6307|      8|      case 31:
  ------------------
  |  Branch (6307:7): [True: 8, False: 72]
  ------------------
 6308|      8|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 248)) {
 6309|      8|          _Internal::set_has_cc_enable_arenas(&has_bits);
 6310|      8|          cc_enable_arenas_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 6311|      8|          CHK_(ptr);
  ------------------
  |  | 6199|      8|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6312|      8|        } else goto handle_unusual;
 6313|      8|        continue;
 6314|       |      // optional string objc_class_prefix = 36;
 6315|     12|      case 36:
  ------------------
  |  Branch (6315:7): [True: 12, False: 68]
  ------------------
 6316|     12|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
 6317|     12|          auto str = _internal_mutable_objc_class_prefix();
 6318|     12|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 6319|       |          #ifndef NDEBUG
 6320|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FileOptions.objc_class_prefix");
 6321|       |          #endif  // !NDEBUG
 6322|     12|          CHK_(ptr);
  ------------------
  |  | 6199|     12|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6323|     12|        } else goto handle_unusual;
 6324|     12|        continue;
 6325|       |      // optional string csharp_namespace = 37;
 6326|     12|      case 37:
  ------------------
  |  Branch (6326:7): [True: 12, False: 68]
  ------------------
 6327|     12|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
 6328|     12|          auto str = _internal_mutable_csharp_namespace();
 6329|     12|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 6330|       |          #ifndef NDEBUG
 6331|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FileOptions.csharp_namespace");
 6332|       |          #endif  // !NDEBUG
 6333|     12|          CHK_(ptr);
  ------------------
  |  | 6199|     12|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6334|     12|        } else goto handle_unusual;
 6335|     12|        continue;
 6336|       |      // optional string swift_prefix = 39;
 6337|     12|      case 39:
  ------------------
  |  Branch (6337:7): [True: 0, False: 80]
  ------------------
 6338|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
 6339|      0|          auto str = _internal_mutable_swift_prefix();
 6340|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 6341|       |          #ifndef NDEBUG
 6342|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FileOptions.swift_prefix");
 6343|       |          #endif  // !NDEBUG
 6344|      0|          CHK_(ptr);
  ------------------
  |  | 6199|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6345|      0|        } else goto handle_unusual;
 6346|      0|        continue;
 6347|       |      // optional string php_class_prefix = 40;
 6348|      0|      case 40:
  ------------------
  |  Branch (6348:7): [True: 0, False: 80]
  ------------------
 6349|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
 6350|      0|          auto str = _internal_mutable_php_class_prefix();
 6351|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 6352|       |          #ifndef NDEBUG
 6353|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FileOptions.php_class_prefix");
 6354|       |          #endif  // !NDEBUG
 6355|      0|          CHK_(ptr);
  ------------------
  |  | 6199|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6356|      0|        } else goto handle_unusual;
 6357|      0|        continue;
 6358|       |      // optional string php_namespace = 41;
 6359|      0|      case 41:
  ------------------
  |  Branch (6359:7): [True: 0, False: 80]
  ------------------
 6360|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
 6361|      0|          auto str = _internal_mutable_php_namespace();
 6362|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 6363|       |          #ifndef NDEBUG
 6364|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FileOptions.php_namespace");
 6365|       |          #endif  // !NDEBUG
 6366|      0|          CHK_(ptr);
  ------------------
  |  | 6199|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6367|      0|        } else goto handle_unusual;
 6368|      0|        continue;
 6369|       |      // optional bool php_generic_services = 42 [default = false];
 6370|      0|      case 42:
  ------------------
  |  Branch (6370:7): [True: 0, False: 80]
  ------------------
 6371|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
 6372|      0|          _Internal::set_has_php_generic_services(&has_bits);
 6373|      0|          php_generic_services_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 6374|      0|          CHK_(ptr);
  ------------------
  |  | 6199|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6375|      0|        } else goto handle_unusual;
 6376|      0|        continue;
 6377|       |      // optional string php_metadata_namespace = 44;
 6378|      0|      case 44:
  ------------------
  |  Branch (6378:7): [True: 0, False: 80]
  ------------------
 6379|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
 6380|      0|          auto str = _internal_mutable_php_metadata_namespace();
 6381|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 6382|       |          #ifndef NDEBUG
 6383|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FileOptions.php_metadata_namespace");
 6384|       |          #endif  // !NDEBUG
 6385|      0|          CHK_(ptr);
  ------------------
  |  | 6199|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6386|      0|        } else goto handle_unusual;
 6387|      0|        continue;
 6388|       |      // optional string ruby_package = 45;
 6389|      0|      case 45:
  ------------------
  |  Branch (6389:7): [True: 0, False: 80]
  ------------------
 6390|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
 6391|      0|          auto str = _internal_mutable_ruby_package();
 6392|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 6393|       |          #ifndef NDEBUG
 6394|       |          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.FileOptions.ruby_package");
 6395|       |          #endif  // !NDEBUG
 6396|      0|          CHK_(ptr);
  ------------------
  |  | 6199|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6397|      0|        } else goto handle_unusual;
 6398|      0|        continue;
 6399|       |      // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 6400|      0|      case 999:
  ------------------
  |  Branch (6400:7): [True: 0, False: 80]
  ------------------
 6401|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
 6402|      0|          ptr -= 2;
 6403|      0|          do {
 6404|      0|            ptr += 2;
 6405|      0|            ptr = ctx->ParseMessage(_internal_add_uninterpreted_option(), ptr);
 6406|      0|            CHK_(ptr);
  ------------------
  |  | 6199|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6407|      0|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (6407:17): [True: 0, False: 0]
  ------------------
 6408|      0|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<7994>(ptr));
  ------------------
  |  Branch (6408:20): [True: 0, False: 0]
  ------------------
 6409|      0|        } else goto handle_unusual;
 6410|      0|        continue;
 6411|      0|      default: {
  ------------------
  |  Branch (6411:7): [True: 0, False: 80]
  ------------------
 6412|      0|      handle_unusual:
 6413|      0|        if ((tag == 0) || ((tag & 7) == 4)) {
  ------------------
  |  Branch (6413:13): [True: 0, False: 0]
  |  Branch (6413:27): [True: 0, False: 0]
  ------------------
 6414|      0|          CHK_(ptr);
  ------------------
  |  | 6199|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6415|      0|          ctx->SetLastTag(tag);
 6416|      0|          goto success;
 6417|      0|        }
 6418|      0|      if ((8000u <= tag)) {
  ------------------
  |  Branch (6418:11): [True: 0, False: 0]
  ------------------
 6419|      0|        ptr = _extensions_.ParseField(tag, ptr,
 6420|      0|            internal_default_instance(), &_internal_metadata_, ctx);
 6421|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 6199|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6422|      0|        continue;
 6423|      0|      }
 6424|      0|        ptr = UnknownFieldParse(tag,
 6425|      0|            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
 6426|      0|            ptr, ctx);
 6427|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 6199|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 6428|      0|        continue;
 6429|      0|      }
 6430|     80|    }  // switch
 6431|     80|  }  // while
 6432|     12|success:
 6433|     12|  _has_bits_.Or(has_bits);
 6434|     12|  return ptr;
 6435|      0|failure:
 6436|      0|  ptr = nullptr;
 6437|      0|  goto success;
 6438|     12|#undef CHK_
 6439|     12|}
_ZNK6google8protobuf11FileOptions13IsInitializedEv:
 6892|     12|bool FileOptions::IsInitialized() const {
 6893|     12|  if (!_extensions_.IsInitialized()) {
  ------------------
  |  Branch (6893:7): [True: 0, False: 12]
  ------------------
 6894|      0|    return false;
 6895|      0|  }
 6896|       |
 6897|     12|  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(uninterpreted_option_)) return false;
  ------------------
  |  Branch (6897:7): [True: 0, False: 12]
  ------------------
 6898|     12|  return true;
 6899|     12|}
_ZN6google8protobuf14MessageOptionsC2EPNS0_5ArenaE:
 6955|      2|  uninterpreted_option_(arena) {
 6956|      2|  SharedCtor();
 6957|      2|  RegisterArenaDtor(arena);
 6958|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.MessageOptions)
 6959|      2|}
_ZN6google8protobuf14MessageOptionsD2Ev:
 6979|      2|MessageOptions::~MessageOptions() {
 6980|       |  // @@protoc_insertion_point(destructor:google.protobuf.MessageOptions)
 6981|      2|  SharedDtor();
 6982|      2|  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 6983|      2|}
_ZN6google8protobuf14MessageOptions14_InternalParseEPKcPNS0_8internal12ParseContextE:
 7014|      2|const char* MessageOptions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 7015|      2|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 7016|      2|  _Internal::HasBits has_bits{};
 7017|      4|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (7017:10): [True: 2, False: 2]
  ------------------
 7018|      2|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 7019|      2|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 7020|      2|    switch (tag >> 3) {
 7021|       |      // optional bool message_set_wire_format = 1 [default = false];
 7022|      0|      case 1:
  ------------------
  |  Branch (7022:7): [True: 0, False: 2]
  ------------------
 7023|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
 7024|      0|          _Internal::set_has_message_set_wire_format(&has_bits);
 7025|      0|          message_set_wire_format_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 7026|      0|          CHK_(ptr);
  ------------------
  |  | 7015|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7027|      0|        } else goto handle_unusual;
 7028|      0|        continue;
 7029|       |      // optional bool no_standard_descriptor_accessor = 2 [default = false];
 7030|      0|      case 2:
  ------------------
  |  Branch (7030:7): [True: 0, False: 2]
  ------------------
 7031|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
 7032|      0|          _Internal::set_has_no_standard_descriptor_accessor(&has_bits);
 7033|      0|          no_standard_descriptor_accessor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 7034|      0|          CHK_(ptr);
  ------------------
  |  | 7015|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7035|      0|        } else goto handle_unusual;
 7036|      0|        continue;
 7037|       |      // optional bool deprecated = 3 [default = false];
 7038|      0|      case 3:
  ------------------
  |  Branch (7038:7): [True: 0, False: 2]
  ------------------
 7039|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
 7040|      0|          _Internal::set_has_deprecated(&has_bits);
 7041|      0|          deprecated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 7042|      0|          CHK_(ptr);
  ------------------
  |  | 7015|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7043|      0|        } else goto handle_unusual;
 7044|      0|        continue;
 7045|       |      // optional bool map_entry = 7;
 7046|      2|      case 7:
  ------------------
  |  Branch (7046:7): [True: 2, False: 0]
  ------------------
 7047|      2|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
 7048|      2|          _Internal::set_has_map_entry(&has_bits);
 7049|      2|          map_entry_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 7050|      2|          CHK_(ptr);
  ------------------
  |  | 7015|      2|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7051|      2|        } else goto handle_unusual;
 7052|      2|        continue;
 7053|       |      // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 7054|      2|      case 999:
  ------------------
  |  Branch (7054:7): [True: 0, False: 2]
  ------------------
 7055|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
 7056|      0|          ptr -= 2;
 7057|      0|          do {
 7058|      0|            ptr += 2;
 7059|      0|            ptr = ctx->ParseMessage(_internal_add_uninterpreted_option(), ptr);
 7060|      0|            CHK_(ptr);
  ------------------
  |  | 7015|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7061|      0|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (7061:17): [True: 0, False: 0]
  ------------------
 7062|      0|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<7994>(ptr));
  ------------------
  |  Branch (7062:20): [True: 0, False: 0]
  ------------------
 7063|      0|        } else goto handle_unusual;
 7064|      0|        continue;
 7065|      0|      default: {
  ------------------
  |  Branch (7065:7): [True: 0, False: 2]
  ------------------
 7066|      0|      handle_unusual:
 7067|      0|        if ((tag == 0) || ((tag & 7) == 4)) {
  ------------------
  |  Branch (7067:13): [True: 0, False: 0]
  |  Branch (7067:27): [True: 0, False: 0]
  ------------------
 7068|      0|          CHK_(ptr);
  ------------------
  |  | 7015|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7069|      0|          ctx->SetLastTag(tag);
 7070|      0|          goto success;
 7071|      0|        }
 7072|      0|      if ((8000u <= tag)) {
  ------------------
  |  Branch (7072:11): [True: 0, False: 0]
  ------------------
 7073|      0|        ptr = _extensions_.ParseField(tag, ptr,
 7074|      0|            internal_default_instance(), &_internal_metadata_, ctx);
 7075|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 7015|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7076|      0|        continue;
 7077|      0|      }
 7078|      0|        ptr = UnknownFieldParse(tag,
 7079|      0|            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
 7080|      0|            ptr, ctx);
 7081|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 7015|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7082|      0|        continue;
 7083|      0|      }
 7084|      2|    }  // switch
 7085|      2|  }  // while
 7086|      2|success:
 7087|      2|  _has_bits_.Or(has_bits);
 7088|      2|  return ptr;
 7089|      0|failure:
 7090|      0|  ptr = nullptr;
 7091|      0|  goto success;
 7092|      2|#undef CHK_
 7093|      2|}
_ZNK6google8protobuf14MessageOptions13IsInitializedEv:
 7251|      2|bool MessageOptions::IsInitialized() const {
 7252|      2|  if (!_extensions_.IsInitialized()) {
  ------------------
  |  Branch (7252:7): [True: 0, False: 2]
  ------------------
 7253|      0|    return false;
 7254|      0|  }
 7255|       |
 7256|      2|  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(uninterpreted_option_)) return false;
  ------------------
  |  Branch (7256:7): [True: 0, False: 2]
  ------------------
 7257|      2|  return true;
 7258|      2|}
_ZN6google8protobuf12FieldOptionsC2EPNS0_5ArenaE:
 7308|      8|  uninterpreted_option_(arena) {
 7309|      8|  SharedCtor();
 7310|      8|  RegisterArenaDtor(arena);
 7311|       |  // @@protoc_insertion_point(arena_constructor:google.protobuf.FieldOptions)
 7312|      8|}
_ZN6google8protobuf12FieldOptionsD2Ev:
 7332|      8|FieldOptions::~FieldOptions() {
 7333|       |  // @@protoc_insertion_point(destructor:google.protobuf.FieldOptions)
 7334|      8|  SharedDtor();
 7335|      8|  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 7336|      8|}
_ZN6google8protobuf12FieldOptions14_InternalParseEPKcPNS0_8internal12ParseContextE:
 7370|      8|const char* FieldOptions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 7371|      8|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 7372|      8|  _Internal::HasBits has_bits{};
 7373|     16|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (7373:10): [True: 8, False: 8]
  ------------------
 7374|      8|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 7375|      8|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 7376|      8|    switch (tag >> 3) {
 7377|       |      // optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
 7378|      0|      case 1:
  ------------------
  |  Branch (7378:7): [True: 0, False: 8]
  ------------------
 7379|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
 7380|      0|          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 7381|      0|          CHK_(ptr);
  ------------------
  |  | 7371|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7382|      0|          if (PROTOBUF_PREDICT_TRUE(PROTOBUF_NAMESPACE_ID::FieldOptions_CType_IsValid(val))) {
 7383|      0|            _internal_set_ctype(static_cast<PROTOBUF_NAMESPACE_ID::FieldOptions_CType>(val));
 7384|      0|          } else {
 7385|      0|            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
 7386|      0|          }
 7387|      0|        } else goto handle_unusual;
 7388|      0|        continue;
 7389|       |      // optional bool packed = 2;
 7390|      6|      case 2:
  ------------------
  |  Branch (7390:7): [True: 6, False: 2]
  ------------------
 7391|      6|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
 7392|      6|          _Internal::set_has_packed(&has_bits);
 7393|      6|          packed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 7394|      6|          CHK_(ptr);
  ------------------
  |  | 7371|      6|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7395|      6|        } else goto handle_unusual;
 7396|      6|        continue;
 7397|       |      // optional bool deprecated = 3 [default = false];
 7398|      6|      case 3:
  ------------------
  |  Branch (7398:7): [True: 2, False: 6]
  ------------------
 7399|      2|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
 7400|      2|          _Internal::set_has_deprecated(&has_bits);
 7401|      2|          deprecated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 7402|      2|          CHK_(ptr);
  ------------------
  |  | 7371|      2|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7403|      2|        } else goto handle_unusual;
 7404|      2|        continue;
 7405|       |      // optional bool lazy = 5 [default = false];
 7406|      2|      case 5:
  ------------------
  |  Branch (7406:7): [True: 0, False: 8]
  ------------------
 7407|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
 7408|      0|          _Internal::set_has_lazy(&has_bits);
 7409|      0|          lazy_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 7410|      0|          CHK_(ptr);
  ------------------
  |  | 7371|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7411|      0|        } else goto handle_unusual;
 7412|      0|        continue;
 7413|       |      // optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];
 7414|      0|      case 6:
  ------------------
  |  Branch (7414:7): [True: 0, False: 8]
  ------------------
 7415|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
 7416|      0|          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 7417|      0|          CHK_(ptr);
  ------------------
  |  | 7371|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7418|      0|          if (PROTOBUF_PREDICT_TRUE(PROTOBUF_NAMESPACE_ID::FieldOptions_JSType_IsValid(val))) {
 7419|      0|            _internal_set_jstype(static_cast<PROTOBUF_NAMESPACE_ID::FieldOptions_JSType>(val));
 7420|      0|          } else {
 7421|      0|            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields());
 7422|      0|          }
 7423|      0|        } else goto handle_unusual;
 7424|      0|        continue;
 7425|       |      // optional bool weak = 10 [default = false];
 7426|      0|      case 10:
  ------------------
  |  Branch (7426:7): [True: 0, False: 8]
  ------------------
 7427|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
 7428|      0|          _Internal::set_has_weak(&has_bits);
 7429|      0|          weak_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 7430|      0|          CHK_(ptr);
  ------------------
  |  | 7371|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7431|      0|        } else goto handle_unusual;
 7432|      0|        continue;
 7433|       |      // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 7434|      0|      case 999:
  ------------------
  |  Branch (7434:7): [True: 0, False: 8]
  ------------------
 7435|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
 7436|      0|          ptr -= 2;
 7437|      0|          do {
 7438|      0|            ptr += 2;
 7439|      0|            ptr = ctx->ParseMessage(_internal_add_uninterpreted_option(), ptr);
 7440|      0|            CHK_(ptr);
  ------------------
  |  | 7371|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7441|      0|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (7441:17): [True: 0, False: 0]
  ------------------
 7442|      0|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<7994>(ptr));
  ------------------
  |  Branch (7442:20): [True: 0, False: 0]
  ------------------
 7443|      0|        } else goto handle_unusual;
 7444|      0|        continue;
 7445|      0|      default: {
  ------------------
  |  Branch (7445:7): [True: 0, False: 8]
  ------------------
 7446|      0|      handle_unusual:
 7447|      0|        if ((tag == 0) || ((tag & 7) == 4)) {
  ------------------
  |  Branch (7447:13): [True: 0, False: 0]
  |  Branch (7447:27): [True: 0, False: 0]
  ------------------
 7448|      0|          CHK_(ptr);
  ------------------
  |  | 7371|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7449|      0|          ctx->SetLastTag(tag);
 7450|      0|          goto success;
 7451|      0|        }
 7452|      0|      if ((8000u <= tag)) {
  ------------------
  |  Branch (7452:11): [True: 0, False: 0]
  ------------------
 7453|      0|        ptr = _extensions_.ParseField(tag, ptr,
 7454|      0|            internal_default_instance(), &_internal_metadata_, ctx);
 7455|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 7371|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7456|      0|        continue;
 7457|      0|      }
 7458|      0|        ptr = UnknownFieldParse(tag,
 7459|      0|            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
 7460|      0|            ptr, ctx);
 7461|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 7371|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ------------------
 7462|      0|        continue;
 7463|      0|      }
 7464|      8|    }  // switch
 7465|      8|  }  // while
 7466|      8|success:
 7467|      8|  _has_bits_.Or(has_bits);
 7468|      8|  return ptr;
 7469|      0|failure:
 7470|      0|  ptr = nullptr;
 7471|      0|  goto success;
 7472|      8|#undef CHK_
 7473|      8|}
_ZNK6google8protobuf12FieldOptions13IsInitializedEv:
 7663|      8|bool FieldOptions::IsInitialized() const {
 7664|      8|  if (!_extensions_.IsInitialized()) {
  ------------------
  |  Branch (7664:7): [True: 0, False: 8]
  ------------------
 7665|      0|    return false;
 7666|      0|  }
 7667|       |
 7668|      8|  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(uninterpreted_option_)) return false;
  ------------------
  |  Branch (7668:7): [True: 0, False: 8]
  ------------------
 7669|      8|  return true;
 7670|      8|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_30DescriptorProto_ExtensionRangeEJEEEPT_PS1_DpOT0_:
10848|     18|template<> PROTOBUF_NOINLINE PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* Arena::CreateMaybeMessage< PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange >(Arena* arena) {
10849|     18|  return Arena::CreateMessageInternal< PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange >(arena);
10850|     18|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_29DescriptorProto_ReservedRangeEJEEEPT_PS1_DpOT0_:
10851|     16|template<> PROTOBUF_NOINLINE PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* Arena::CreateMaybeMessage< PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange >(Arena* arena) {
10852|     16|  return Arena::CreateMessageInternal< PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange >(arena);
10853|     16|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_15DescriptorProtoEJEEEPT_PS1_DpOT0_:
10854|     94|template<> PROTOBUF_NOINLINE PROTOBUF_NAMESPACE_ID::DescriptorProto* Arena::CreateMaybeMessage< PROTOBUF_NAMESPACE_ID::DescriptorProto >(Arena* arena) {
10855|     94|  return Arena::CreateMessageInternal< PROTOBUF_NAMESPACE_ID::DescriptorProto >(arena);
10856|     94|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_20FieldDescriptorProtoEJEEEPT_PS1_DpOT0_:
10860|    346|template<> PROTOBUF_NOINLINE PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* Arena::CreateMaybeMessage< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >(Arena* arena) {
10861|    346|  return Arena::CreateMessageInternal< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >(arena);
10862|    346|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_20OneofDescriptorProtoEJEEEPT_PS1_DpOT0_:
10863|      2|template<> PROTOBUF_NOINLINE PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* Arena::CreateMaybeMessage< PROTOBUF_NAMESPACE_ID::OneofDescriptorProto >(Arena* arena) {
10864|      2|  return Arena::CreateMessageInternal< PROTOBUF_NAMESPACE_ID::OneofDescriptorProto >(arena);
10865|      2|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_19EnumDescriptorProtoEJEEEPT_PS1_DpOT0_:
10869|     20|template<> PROTOBUF_NOINLINE PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* Arena::CreateMaybeMessage< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >(Arena* arena) {
10870|     20|  return Arena::CreateMessageInternal< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >(arena);
10871|     20|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_24EnumValueDescriptorProtoEJEEEPT_PS1_DpOT0_:
10872|    118|template<> PROTOBUF_NOINLINE PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* Arena::CreateMaybeMessage< PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto >(Arena* arena) {
10873|    118|  return Arena::CreateMessageInternal< PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto >(arena);
10874|    118|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_11FileOptionsEJEEEPT_PS1_DpOT0_:
10881|     12|template<> PROTOBUF_NOINLINE PROTOBUF_NAMESPACE_ID::FileOptions* Arena::CreateMaybeMessage< PROTOBUF_NAMESPACE_ID::FileOptions >(Arena* arena) {
10882|     12|  return Arena::CreateMessageInternal< PROTOBUF_NAMESPACE_ID::FileOptions >(arena);
10883|     12|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_14MessageOptionsEJEEEPT_PS1_DpOT0_:
10884|      2|template<> PROTOBUF_NOINLINE PROTOBUF_NAMESPACE_ID::MessageOptions* Arena::CreateMaybeMessage< PROTOBUF_NAMESPACE_ID::MessageOptions >(Arena* arena) {
10885|      2|  return Arena::CreateMessageInternal< PROTOBUF_NAMESPACE_ID::MessageOptions >(arena);
10886|      2|}
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_12FieldOptionsEJEEEPT_PS1_DpOT0_:
10887|      8|template<> PROTOBUF_NOINLINE PROTOBUF_NAMESPACE_ID::FieldOptions* Arena::CreateMaybeMessage< PROTOBUF_NAMESPACE_ID::FieldOptions >(Arena* arena) {
10888|      8|  return Arena::CreateMessageInternal< PROTOBUF_NAMESPACE_ID::FieldOptions >(arena);
10889|      8|}
_ZN6google8protobuf19FileDescriptorProto10SharedCtorEv:
 1515|     12|void FileDescriptorProto::SharedCtor() {
 1516|     12|name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1517|     12|package_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1518|     12|syntax_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1519|     12|::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
 1520|     12|    reinterpret_cast<char*>(&options_) - reinterpret_cast<char*>(this)),
 1521|     12|    0, static_cast<size_t>(reinterpret_cast<char*>(&source_code_info_) -
 1522|     12|    reinterpret_cast<char*>(&options_)) + sizeof(source_code_info_));
 1523|     12|}
_ZN6google8protobuf19FileDescriptorProto10SharedDtorEv:
 1531|     12|void FileDescriptorProto::SharedDtor() {
 1532|     12|  GOOGLE_DCHECK(GetArena() == nullptr);
 1533|     12|  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1534|     12|  package_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1535|     12|  syntax_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1536|     12|  if (this != internal_default_instance()) delete options_;
  ------------------
  |  Branch (1536:7): [True: 12, False: 0]
  ------------------
 1537|     12|  if (this != internal_default_instance()) delete source_code_info_;
  ------------------
  |  Branch (1537:7): [True: 12, False: 0]
  ------------------
 1538|     12|}
_ZN6google8protobuf19FileDescriptorProto17RegisterArenaDtorEPNS0_5ArenaE:
 1544|     12|void FileDescriptorProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 1545|     12|}
_ZN6google8protobuf30DescriptorProto_ExtensionRange10SharedCtorEv:
 2127|     18|void DescriptorProto_ExtensionRange::SharedCtor() {
 2128|     18|::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
 2129|     18|    reinterpret_cast<char*>(&options_) - reinterpret_cast<char*>(this)),
 2130|     18|    0, static_cast<size_t>(reinterpret_cast<char*>(&end_) -
 2131|     18|    reinterpret_cast<char*>(&options_)) + sizeof(end_));
 2132|     18|}
_ZN6google8protobuf30DescriptorProto_ExtensionRange10SharedDtorEv:
 2140|     18|void DescriptorProto_ExtensionRange::SharedDtor() {
 2141|     18|  GOOGLE_DCHECK(GetArena() == nullptr);
 2142|     18|  if (this != internal_default_instance()) delete options_;
  ------------------
  |  Branch (2142:7): [True: 18, False: 0]
  ------------------
 2143|     18|}
_ZN6google8protobuf30DescriptorProto_ExtensionRange17RegisterArenaDtorEPNS0_5ArenaE:
 2149|     18|void DescriptorProto_ExtensionRange::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 2150|     18|}
_ZN6google8protobuf30DescriptorProto_ExtensionRange9_Internal13set_has_startEPNS0_8internal7HasBitsILm1EEE:
 2090|     18|  static void set_has_start(HasBits* has_bits) {
 2091|     18|    (*has_bits)[0] |= 2u;
 2092|     18|  }
_ZN6google8protobuf30DescriptorProto_ExtensionRange9_Internal11set_has_endEPNS0_8internal7HasBitsILm1EEE:
 2093|     18|  static void set_has_end(HasBits* has_bits) {
 2094|     18|    (*has_bits)[0] |= 4u;
 2095|     18|  }
_ZN6google8protobuf29DescriptorProto_ReservedRange10SharedCtorEv:
 2410|     16|void DescriptorProto_ReservedRange::SharedCtor() {
 2411|     16|::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
 2412|     16|    reinterpret_cast<char*>(&start_) - reinterpret_cast<char*>(this)),
 2413|     16|    0, static_cast<size_t>(reinterpret_cast<char*>(&end_) -
 2414|     16|    reinterpret_cast<char*>(&start_)) + sizeof(end_));
 2415|     16|}
_ZN6google8protobuf29DescriptorProto_ReservedRange10SharedDtorEv:
 2423|     16|void DescriptorProto_ReservedRange::SharedDtor() {
 2424|     16|  GOOGLE_DCHECK(GetArena() == nullptr);
 2425|     16|}
_ZN6google8protobuf29DescriptorProto_ReservedRange17RegisterArenaDtorEPNS0_5ArenaE:
 2431|     16|void DescriptorProto_ReservedRange::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 2432|     16|}
_ZN6google8protobuf29DescriptorProto_ReservedRange9_Internal13set_has_startEPNS0_8internal7HasBitsILm1EEE:
 2386|     16|  static void set_has_start(HasBits* has_bits) {
 2387|     16|    (*has_bits)[0] |= 1u;
 2388|     16|  }
_ZN6google8protobuf29DescriptorProto_ReservedRange9_Internal11set_has_endEPNS0_8internal7HasBitsILm1EEE:
 2389|     16|  static void set_has_end(HasBits* has_bits) {
 2390|     16|    (*has_bits)[0] |= 2u;
 2391|     16|  }
_ZN6google8protobuf15DescriptorProto10SharedCtorEv:
 2688|     94|void DescriptorProto::SharedCtor() {
 2689|     94|name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2690|     94|options_ = nullptr;
 2691|     94|}
_ZN6google8protobuf15DescriptorProto10SharedDtorEv:
 2699|     94|void DescriptorProto::SharedDtor() {
 2700|     94|  GOOGLE_DCHECK(GetArena() == nullptr);
 2701|     94|  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2702|     94|  if (this != internal_default_instance()) delete options_;
  ------------------
  |  Branch (2702:7): [True: 94, False: 0]
  ------------------
 2703|     94|}
_ZN6google8protobuf15DescriptorProto17RegisterArenaDtorEPNS0_5ArenaE:
 2709|     94|void DescriptorProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 2710|     94|}
_ZN6google8protobuf20FieldDescriptorProto10SharedCtorEv:
 3480|    346|void FieldDescriptorProto::SharedCtor() {
 3481|    346|name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 3482|    346|extendee_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 3483|    346|type_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 3484|    346|default_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 3485|    346|json_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 3486|    346|::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
 3487|    346|    reinterpret_cast<char*>(&options_) - reinterpret_cast<char*>(this)),
 3488|    346|    0, static_cast<size_t>(reinterpret_cast<char*>(&proto3_optional_) -
 3489|    346|    reinterpret_cast<char*>(&options_)) + sizeof(proto3_optional_));
 3490|    346|label_ = 1;
 3491|    346|type_ = 1;
 3492|    346|}
_ZN6google8protobuf20FieldDescriptorProto10SharedDtorEv:
 3500|    346|void FieldDescriptorProto::SharedDtor() {
 3501|    346|  GOOGLE_DCHECK(GetArena() == nullptr);
 3502|    346|  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 3503|    346|  extendee_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 3504|    346|  type_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 3505|    346|  default_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 3506|    346|  json_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 3507|    346|  if (this != internal_default_instance()) delete options_;
  ------------------
  |  Branch (3507:7): [True: 346, False: 0]
  ------------------
 3508|    346|}
_ZN6google8protobuf20FieldDescriptorProto17RegisterArenaDtorEPNS0_5ArenaE:
 3514|    346|void FieldDescriptorProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 3515|    346|}
_ZN6google8protobuf20FieldDescriptorProto9_Internal14set_has_numberEPNS0_8internal7HasBitsILm1EEE:
 3397|    346|  static void set_has_number(HasBits* has_bits) {
 3398|    346|    (*has_bits)[0] |= 64u;
 3399|    346|  }
_ZN6google8protobuf20FieldDescriptorProto9_Internal19set_has_oneof_indexEPNS0_8internal7HasBitsILm1EEE:
 3415|     12|  static void set_has_oneof_index(HasBits* has_bits) {
 3416|     12|    (*has_bits)[0] |= 128u;
 3417|     12|  }
_ZN6google8protobuf20OneofDescriptorProto10SharedCtorEv:
 4054|      2|void OneofDescriptorProto::SharedCtor() {
 4055|      2|name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 4056|      2|options_ = nullptr;
 4057|      2|}
_ZN6google8protobuf20OneofDescriptorProto10SharedDtorEv:
 4065|      2|void OneofDescriptorProto::SharedDtor() {
 4066|      2|  GOOGLE_DCHECK(GetArena() == nullptr);
 4067|      2|  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 4068|      2|  if (this != internal_default_instance()) delete options_;
  ------------------
  |  Branch (4068:7): [True: 2, False: 0]
  ------------------
 4069|      2|}
_ZN6google8protobuf20OneofDescriptorProto17RegisterArenaDtorEPNS0_5ArenaE:
 4075|      2|void OneofDescriptorProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 4076|      2|}
_ZN6google8protobuf19EnumDescriptorProto10SharedCtorEv:
 4582|     20|void EnumDescriptorProto::SharedCtor() {
 4583|     20|name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 4584|     20|options_ = nullptr;
 4585|     20|}
_ZN6google8protobuf19EnumDescriptorProto10SharedDtorEv:
 4593|     20|void EnumDescriptorProto::SharedDtor() {
 4594|     20|  GOOGLE_DCHECK(GetArena() == nullptr);
 4595|     20|  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 4596|     20|  if (this != internal_default_instance()) delete options_;
  ------------------
  |  Branch (4596:7): [True: 20, False: 0]
  ------------------
 4597|     20|}
_ZN6google8protobuf19EnumDescriptorProto17RegisterArenaDtorEPNS0_5ArenaE:
 4603|     20|void EnumDescriptorProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 4604|     20|}
_ZN6google8protobuf24EnumValueDescriptorProto10SharedCtorEv:
 4956|    118|void EnumValueDescriptorProto::SharedCtor() {
 4957|    118|name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 4958|    118|::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
 4959|    118|    reinterpret_cast<char*>(&options_) - reinterpret_cast<char*>(this)),
 4960|    118|    0, static_cast<size_t>(reinterpret_cast<char*>(&number_) -
 4961|    118|    reinterpret_cast<char*>(&options_)) + sizeof(number_));
 4962|    118|}
_ZN6google8protobuf24EnumValueDescriptorProto10SharedDtorEv:
 4970|    118|void EnumValueDescriptorProto::SharedDtor() {
 4971|    118|  GOOGLE_DCHECK(GetArena() == nullptr);
 4972|    118|  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 4973|    118|  if (this != internal_default_instance()) delete options_;
  ------------------
  |  Branch (4973:7): [True: 118, False: 0]
  ------------------
 4974|    118|}
_ZN6google8protobuf24EnumValueDescriptorProto17RegisterArenaDtorEPNS0_5ArenaE:
 4980|    118|void EnumValueDescriptorProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 4981|    118|}
_ZN6google8protobuf24EnumValueDescriptorProto9_Internal14set_has_numberEPNS0_8internal7HasBitsILm1EEE:
 4919|    118|  static void set_has_number(HasBits* has_bits) {
 4920|    118|    (*has_bits)[0] |= 4u;
 4921|    118|  }
_ZN6google8protobuf11FileOptions10SharedCtorEv:
 6090|     12|void FileOptions::SharedCtor() {
 6091|     12|java_package_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6092|     12|java_outer_classname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6093|     12|go_package_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6094|     12|objc_class_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6095|     12|csharp_namespace_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6096|     12|swift_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6097|     12|php_class_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6098|     12|php_namespace_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6099|     12|php_metadata_namespace_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6100|     12|ruby_package_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6101|     12|::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
 6102|     12|    reinterpret_cast<char*>(&java_multiple_files_) - reinterpret_cast<char*>(this)),
 6103|     12|    0, static_cast<size_t>(reinterpret_cast<char*>(&deprecated_) -
 6104|     12|    reinterpret_cast<char*>(&java_multiple_files_)) + sizeof(deprecated_));
 6105|     12|optimize_for_ = 1;
 6106|     12|cc_enable_arenas_ = true;
 6107|     12|}
_ZN6google8protobuf11FileOptions10SharedDtorEv:
 6115|     12|void FileOptions::SharedDtor() {
 6116|     12|  GOOGLE_DCHECK(GetArena() == nullptr);
 6117|     12|  java_package_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6118|     12|  java_outer_classname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6119|     12|  go_package_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6120|     12|  objc_class_prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6121|     12|  csharp_namespace_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6122|     12|  swift_prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6123|     12|  php_class_prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6124|     12|  php_namespace_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6125|     12|  php_metadata_namespace_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6126|     12|  ruby_package_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 6127|     12|}
_ZN6google8protobuf11FileOptions17RegisterArenaDtorEPNS0_5ArenaE:
 6133|     12|void FileOptions::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 6134|     12|}
_ZN6google8protobuf11FileOptions9_Internal27set_has_java_multiple_filesEPNS0_8internal7HasBitsILm1EEE:
 5964|     10|  static void set_has_java_multiple_files(HasBits* has_bits) {
 5965|     10|    (*has_bits)[0] |= 1024u;
 5966|     10|  }
_ZN6google8protobuf11FileOptions9_Internal24set_has_cc_enable_arenasEPNS0_8internal7HasBitsILm1EEE:
 5994|      8|  static void set_has_cc_enable_arenas(HasBits* has_bits) {
 5995|      8|    (*has_bits)[0] |= 524288u;
 5996|      8|  }
_ZN6google8protobuf14MessageOptions10SharedCtorEv:
 6972|      2|void MessageOptions::SharedCtor() {
 6973|      2|::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
 6974|      2|    reinterpret_cast<char*>(&message_set_wire_format_) - reinterpret_cast<char*>(this)),
 6975|      2|    0, static_cast<size_t>(reinterpret_cast<char*>(&map_entry_) -
 6976|      2|    reinterpret_cast<char*>(&message_set_wire_format_)) + sizeof(map_entry_));
 6977|      2|}
_ZN6google8protobuf14MessageOptions10SharedDtorEv:
 6985|      2|void MessageOptions::SharedDtor() {
 6986|      2|  GOOGLE_DCHECK(GetArena() == nullptr);
 6987|      2|}
_ZN6google8protobuf14MessageOptions17RegisterArenaDtorEPNS0_5ArenaE:
 6993|      2|void MessageOptions::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 6994|      2|}
_ZN6google8protobuf14MessageOptions9_Internal17set_has_map_entryEPNS0_8internal7HasBitsILm1EEE:
 6947|      2|  static void set_has_map_entry(HasBits* has_bits) {
 6948|      2|    (*has_bits)[0] |= 8u;
 6949|      2|  }
_ZN6google8protobuf12FieldOptions10SharedCtorEv:
 7325|      8|void FieldOptions::SharedCtor() {
 7326|      8|::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
 7327|      8|    reinterpret_cast<char*>(&ctype_) - reinterpret_cast<char*>(this)),
 7328|      8|    0, static_cast<size_t>(reinterpret_cast<char*>(&jstype_) -
 7329|      8|    reinterpret_cast<char*>(&ctype_)) + sizeof(jstype_));
 7330|      8|}
_ZN6google8protobuf12FieldOptions10SharedDtorEv:
 7338|      8|void FieldOptions::SharedDtor() {
 7339|      8|  GOOGLE_DCHECK(GetArena() == nullptr);
 7340|      8|}
_ZN6google8protobuf12FieldOptions17RegisterArenaDtorEPNS0_5ArenaE:
 7346|      8|void FieldOptions::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 7347|      8|}
_ZN6google8protobuf12FieldOptions9_Internal14set_has_packedEPNS0_8internal7HasBitsILm1EEE:
 7288|      6|  static void set_has_packed(HasBits* has_bits) {
 7289|      6|    (*has_bits)[0] |= 2u;
 7290|      6|  }
_ZN6google8protobuf12FieldOptions9_Internal18set_has_deprecatedEPNS0_8internal7HasBitsILm1EEE:
 7297|      2|  static void set_has_deprecated(HasBits* has_bits) {
 7298|      2|    (*has_bits)[0] |= 8u;
 7299|      2|  }

_ZN6google8protobuf25EncodedDescriptorDatabase3AddEPKvi:
  554|     12|                                    int size) {
  555|     12|  FileDescriptorProto file;
  556|     12|  if (file.ParseFromArray(encoded_file_descriptor, size)) {
  ------------------
  |  Branch (556:7): [True: 12, False: 0]
  ------------------
  557|     12|    return index_->AddFile(file, std::make_pair(encoded_file_descriptor, size));
  558|     12|  } else {
  559|      0|    GOOGLE_LOG(ERROR) << "Invalid file descriptor data passed to "
  560|      0|                  "EncodedDescriptorDatabase::Add().";
  561|      0|    return false;
  562|      0|  }
  563|     12|}
_ZN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9AddSymbolENS0_20stringpiece_internal11StringPieceE:
  692|     84|    StringPiece symbol) {
  693|     84|  SymbolEntry entry = {static_cast<int>(all_values_.size() - 1),
  694|     84|                       EncodeString(symbol)};
  695|     84|  std::string entry_as_string = entry.AsString(*this);
  696|       |
  697|       |  // We need to make sure not to violate our map invariant.
  698|       |
  699|       |  // If the symbol name is invalid it could break our lookup algorithm (which
  700|       |  // relies on the fact that '.' sorts before all other characters that are
  701|       |  // valid in symbol names).
  702|     84|  if (!ValidateSymbolName(symbol)) {
  ------------------
  |  Branch (702:7): [True: 0, False: 84]
  ------------------
  703|      0|    GOOGLE_LOG(ERROR) << "Invalid symbol name: " << entry_as_string;
  704|      0|    return false;
  705|      0|  }
  706|       |
  707|     84|  auto iter = FindLastLessOrEqual(&by_symbol_, entry);
  708|     84|  if (!CheckForMutualSubsymbols(entry_as_string, &iter, by_symbol_.end(),
  ------------------
  |  Branch (708:7): [True: 0, False: 84]
  ------------------
  709|     84|                                *this)) {
  710|      0|    return false;
  711|      0|  }
  712|       |
  713|       |  // Same, but on by_symbol_flat_
  714|     84|  auto flat_iter =
  715|     84|      FindLastLessOrEqual(&by_symbol_flat_, entry, by_symbol_.key_comp());
  716|     84|  if (!CheckForMutualSubsymbols(entry_as_string, &flat_iter,
  ------------------
  |  Branch (716:7): [True: 0, False: 84]
  ------------------
  717|     84|                                by_symbol_flat_.end(), *this)) {
  718|      0|    return false;
  719|      0|  }
  720|       |
  721|       |  // OK, no conflicts.
  722|       |
  723|       |  // Insert the new symbol using the iterator as a hint, the new entry will
  724|       |  // appear immediately before the one the iterator is pointing at.
  725|     84|  by_symbol_.insert(iter, entry);
  726|       |
  727|     84|  return true;
  728|     84|}
_ZN6google8protobuf25EncodedDescriptorDatabaseC2Ev:
  879|      2|    : index_(new DescriptorIndex()) {}
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex12EncodeStringENS0_20stringpiece_internal11StringPieceE:
  429|    108|  String EncodeString(StringPiece str) const { return String(str); }
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntry8AsStringERKS2_:
  479|    246|    std::string AsString(const DescriptorIndex& index) const {
  480|    246|      auto p = package(index);
  481|    246|      return StrCat(p, p.empty() ? "" : ".", symbol(index));
  ------------------
  |  Branch (481:24): [True: 0, False: 246]
  ------------------
  482|    246|    }
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntry7packageERKS2_:
  471|  1.27k|    StringPiece package(const DescriptorIndex& index) const {
  472|  1.27k|      return index.DecodeString(index.all_values_[data_offset].encoded_package,
  473|  1.27k|                                data_offset);
  474|  1.27k|    }
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex12DecodeStringERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEi:
  430|  2.61k|  StringPiece DecodeString(const String& str, int) const { return str; }
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntry6symbolERKS2_:
  475|  1.27k|    StringPiece symbol(const DescriptorIndex& index) const {
  476|  1.27k|      return index.DecodeString(encoded_symbol, data_offset);
  477|  1.27k|    }
descriptor_database.cc:_ZN6google8protobuf12_GLOBAL__N_118ValidateSymbolNameENS0_20stringpiece_internal11StringPieceE:
  153|     96|bool ValidateSymbolName(StringPiece name) {
  154|  1.22k|  for (char c : name) {
  ------------------
  |  Branch (154:15): [True: 1.22k, False: 96]
  ------------------
  155|       |    // I don't trust ctype.h due to locales.  :(
  156|  1.22k|    if (c != '.' && c != '_' && (c < '0' || c > '9') && (c < 'A' || c > 'Z') &&
  ------------------
  |  Branch (156:9): [True: 1.21k, False: 12]
  |  Branch (156:21): [True: 1.21k, False: 0]
  |  Branch (156:34): [True: 0, False: 1.21k]
  |  Branch (156:45): [True: 1.19k, False: 16]
  |  Branch (156:58): [True: 0, False: 1.19k]
  |  Branch (156:69): [True: 1.01k, False: 182]
  ------------------
  157|  1.22k|        (c < 'a' || c > 'z')) {
  ------------------
  |  Branch (157:10): [True: 0, False: 1.01k]
  |  Branch (157:21): [True: 0, False: 1.01k]
  ------------------
  158|      0|      return false;
  159|      0|    }
  160|  1.22k|  }
  161|     96|  return true;
  162|     96|}
descriptor_database.cc:_ZN6google8protobuf12_GLOBAL__N_111IsSubSymbolENS0_20stringpiece_internal11StringPieceES3_:
  187|    162|bool IsSubSymbol(StringPiece sub_symbol, StringPiece super_symbol) {
  188|    162|  return sub_symbol == super_symbol ||
  ------------------
  |  Branch (188:10): [True: 0, False: 162]
  ------------------
  189|    162|         (HasPrefixString(super_symbol, sub_symbol) &&
  ------------------
  |  Branch (189:11): [True: 8, False: 154]
  ------------------
  190|    162|          super_symbol[sub_symbol.size()] == '.');
  ------------------
  |  Branch (190:11): [True: 0, False: 8]
  ------------------
  191|    162|}
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex9FileEntry4nameERKS2_:
  447|     68|    StringPiece name(const DescriptorIndex& index) const {
  448|     68|      return index.DecodeString(encoded_name, data_offset);
  449|     68|    }
_ZN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex7AddFileINS0_19FileDescriptorProtoEEEbRKT_NSt3__14pairIPKviEE:
  625|     12|                                                         Value value) {
  626|       |  // We push `value` into the array first. This is important because the AddXXX
  627|       |  // functions below will expect it to be there.
  628|     12|  all_values_.push_back({value.first, value.second, {}});
  629|       |
  630|     12|  if (!ValidateSymbolName(file.package())) {
  ------------------
  |  Branch (630:7): [True: 0, False: 12]
  ------------------
  631|      0|    GOOGLE_LOG(ERROR) << "Invalid package name: " << file.package();
  632|      0|    return false;
  633|      0|  }
  634|     12|  all_values_.back().encoded_package = EncodeString(file.package());
  635|       |
  636|     12|  if (!InsertIfNotPresent(
  ------------------
  |  Branch (636:7): [True: 0, False: 12]
  |  Branch (636:7): [True: 0, False: 12]
  ------------------
  637|     12|          &by_name_, FileEntry{static_cast<int>(all_values_.size() - 1),
  638|     12|                               EncodeString(file.name())}) ||
  639|     12|      std::binary_search(by_name_flat_.begin(), by_name_flat_.end(),
  ------------------
  |  Branch (639:7): [True: 0, False: 12]
  ------------------
  640|     12|                         file.name(), by_name_.key_comp())) {
  641|      0|    GOOGLE_LOG(ERROR) << "File already exists in database: " << file.name();
  642|      0|    return false;
  643|      0|  }
  644|       |
  645|     80|  for (const auto& message_type : file.message_type()) {
  ------------------
  |  Branch (645:33): [True: 80, False: 12]
  ------------------
  646|     80|    if (!AddSymbol(message_type.name())) return false;
  ------------------
  |  Branch (646:9): [True: 0, False: 80]
  ------------------
  647|     80|    if (!AddNestedExtensions(file.name(), message_type)) return false;
  ------------------
  |  Branch (647:9): [True: 0, False: 80]
  ------------------
  648|     80|  }
  649|     12|  for (const auto& enum_type : file.enum_type()) {
  ------------------
  |  Branch (649:30): [True: 4, False: 12]
  ------------------
  650|      4|    if (!AddSymbol(enum_type.name())) return false;
  ------------------
  |  Branch (650:9): [True: 0, False: 4]
  ------------------
  651|      4|  }
  652|     12|  for (const auto& extension : file.extension()) {
  ------------------
  |  Branch (652:30): [True: 0, False: 12]
  ------------------
  653|      0|    if (!AddSymbol(extension.name())) return false;
  ------------------
  |  Branch (653:9): [True: 0, False: 0]
  ------------------
  654|      0|    if (!AddExtension(file.name(), extension)) return false;
  ------------------
  |  Branch (654:9): [True: 0, False: 0]
  ------------------
  655|      0|  }
  656|     12|  for (const auto& service : file.service()) {
  ------------------
  |  Branch (656:28): [True: 0, False: 12]
  ------------------
  657|      0|    if (!AddSymbol(service.name())) return false;
  ------------------
  |  Branch (657:9): [True: 0, False: 0]
  ------------------
  658|      0|  }
  659|       |
  660|     12|  return true;
  661|     12|}
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex11FileCompareclERKNS2_9FileEntryES6_:
  454|     34|    bool operator()(const FileEntry& a, const FileEntry& b) const {
  455|     34|      return a.name(index) < b.name(index);
  456|     34|    }
_ZN6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex19AddNestedExtensionsINS0_15DescriptorProtoEEEbNS0_20stringpiece_internal11StringPieceERKT_:
  732|     94|    StringPiece filename, const DescProto& message_type) {
  733|     94|  for (const auto& nested_type : message_type.nested_type()) {
  ------------------
  |  Branch (733:32): [True: 14, False: 94]
  ------------------
  734|     14|    if (!AddNestedExtensions(filename, nested_type)) return false;
  ------------------
  |  Branch (734:9): [True: 0, False: 14]
  ------------------
  735|     14|  }
  736|     94|  for (const auto& extension : message_type.extension()) {
  ------------------
  |  Branch (736:30): [True: 0, False: 94]
  ------------------
  737|      0|    if (!AddExtension(filename, extension)) return false;
  ------------------
  |  Branch (737:9): [True: 0, False: 0]
  ------------------
  738|      0|  }
  739|     94|  return true;
  740|     94|}
descriptor_database.cc:_ZN6google8protobuf12_GLOBAL__N_119FindLastLessOrEqualINSt3__13setINS0_25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS6_13SymbolCompareENS3_9allocatorIS7_EEEES7_EENT_14const_iteratorEPKSC_RKT0_:
  169|     84|    const Container* container, const Key& key) {
  170|     84|  auto iter = container->upper_bound(key);
  171|     84|  if (iter != container->begin()) --iter;
  ------------------
  |  Branch (171:7): [True: 78, False: 6]
  ------------------
  172|     84|  return iter;
  173|     84|}
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompareclINS2_11SymbolEntryES5_EEbRKT_RKT0_:
  505|    514|    bool operator()(const T& lhs, const U& rhs) const {
  506|    514|      auto lhs_parts = GetParts(lhs);
  507|    514|      auto rhs_parts = GetParts(rhs);
  508|       |
  509|       |      // Fast path to avoid making the whole string for common cases.
  510|    514|      if (int res =
  ------------------
  |  Branch (510:15): [True: 0, False: 514]
  ------------------
  511|    514|              lhs_parts.first.substr(0, rhs_parts.first.size())
  512|    514|                  .compare(rhs_parts.first.substr(0, lhs_parts.first.size()))) {
  513|       |        // If the packages already differ, exit early.
  514|      0|        return res < 0;
  515|    514|      } else if (lhs_parts.first.size() == rhs_parts.first.size()) {
  ------------------
  |  Branch (515:18): [True: 514, False: 0]
  ------------------
  516|    514|        return lhs_parts.second < rhs_parts.second;
  517|    514|      }
  518|      0|      return AsString(lhs) < AsString(rhs);
  519|    514|    }
_ZNK6google8protobuf25EncodedDescriptorDatabase15DescriptorIndex13SymbolCompare8GetPartsERKNS2_11SymbolEntryE:
  494|  1.02k|        const SymbolEntry& entry) const {
  495|  1.02k|      auto package = entry.package(index);
  496|  1.02k|      if (package.empty()) return {entry.symbol(index), StringPiece{}};
  ------------------
  |  Branch (496:11): [True: 0, False: 1.02k]
  ------------------
  497|  1.02k|      return {package, entry.symbol(index)};
  498|  1.02k|    }
descriptor_database.cc:_ZN6google8protobufL24CheckForMutualSubsymbolsINSt3__121__tree_const_iteratorINS0_25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEPNS2_11__tree_nodeIS6_PvEElEESB_S5_EEbNS0_20stringpiece_internal11StringPieceEPT_T0_RKT1_:
  665|     84|                                     Iter2 end, const Index& index) {
  666|     84|  if (*iter != end) {
  ------------------
  |  Branch (666:7): [True: 82, False: 2]
  ------------------
  667|     82|    if (IsSubSymbol((*iter)->AsString(index), symbol_name)) {
  ------------------
  |  Branch (667:9): [True: 0, False: 82]
  ------------------
  668|      0|      GOOGLE_LOG(ERROR) << "Symbol name \"" << symbol_name
  669|      0|                 << "\" conflicts with the existing symbol \""
  670|      0|                 << (*iter)->AsString(index) << "\".";
  671|      0|      return false;
  672|      0|    }
  673|       |
  674|       |    // OK, that worked.  Now we have to make sure that no symbol in the map is
  675|       |    // a sub-symbol of the one we are inserting.  The only symbol which could
  676|       |    // be so is the first symbol that is greater than the new symbol.  Since
  677|       |    // |iter| points at the last symbol that is less than or equal, we just have
  678|       |    // to increment it.
  679|     82|    ++*iter;
  680|       |
  681|     82|    if (*iter != end && IsSubSymbol(symbol_name, (*iter)->AsString(index))) {
  ------------------
  |  Branch (681:9): [True: 80, False: 2]
  |  Branch (681:9): [True: 0, False: 82]
  |  Branch (681:25): [True: 0, False: 80]
  ------------------
  682|      0|      GOOGLE_LOG(ERROR) << "Symbol name \"" << symbol_name
  683|      0|                 << "\" conflicts with the existing symbol \""
  684|      0|                 << (*iter)->AsString(index) << "\".";
  685|      0|      return false;
  686|      0|    }
  687|     82|  }
  688|     84|  return true;
  689|     84|}
descriptor_database.cc:_ZN6google8protobuf12_GLOBAL__N_119FindLastLessOrEqualINSt3__16vectorINS0_25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryENS3_9allocatorIS7_EEEES7_NS6_13SymbolCompareEEENT_14const_iteratorEPKSC_RKT0_RKT1_:
  178|     84|    const Container* container, const Key& key, const Cmp& cmp) {
  179|     84|  auto iter = std::upper_bound(container->begin(), container->end(), key, cmp);
  180|     84|  if (iter != container->begin()) --iter;
  ------------------
  |  Branch (180:7): [True: 0, False: 84]
  ------------------
  181|     84|  return iter;
  182|     84|}
descriptor_database.cc:_ZN6google8protobufL24CheckForMutualSubsymbolsINSt3__111__wrap_iterIPKNS0_25EncodedDescriptorDatabase15DescriptorIndex11SymbolEntryEEENS3_IPS6_EES5_EEbNS0_20stringpiece_internal11StringPieceEPT_T0_RKT1_:
  665|     84|                                     Iter2 end, const Index& index) {
  666|     84|  if (*iter != end) {
  ------------------
  |  Branch (666:7): [True: 0, False: 84]
  ------------------
  667|      0|    if (IsSubSymbol((*iter)->AsString(index), symbol_name)) {
  ------------------
  |  Branch (667:9): [True: 0, False: 0]
  ------------------
  668|      0|      GOOGLE_LOG(ERROR) << "Symbol name \"" << symbol_name
  669|      0|                 << "\" conflicts with the existing symbol \""
  670|      0|                 << (*iter)->AsString(index) << "\".";
  671|      0|      return false;
  672|      0|    }
  673|       |
  674|       |    // OK, that worked.  Now we have to make sure that no symbol in the map is
  675|       |    // a sub-symbol of the one we are inserting.  The only symbol which could
  676|       |    // be so is the first symbol that is greater than the new symbol.  Since
  677|       |    // |iter| points at the last symbol that is less than or equal, we just have
  678|       |    // to increment it.
  679|      0|    ++*iter;
  680|       |
  681|      0|    if (*iter != end && IsSubSymbol(symbol_name, (*iter)->AsString(index))) {
  ------------------
  |  Branch (681:9): [True: 0, False: 0]
  |  Branch (681:9): [True: 0, False: 0]
  |  Branch (681:25): [True: 0, False: 0]
  ------------------
  682|      0|      GOOGLE_LOG(ERROR) << "Symbol name \"" << symbol_name
  683|      0|                 << "\" conflicts with the existing symbol \""
  684|      0|                 << (*iter)->AsString(index) << "\".";
  685|      0|      return false;
  686|      0|    }
  687|      0|  }
  688|     84|  return true;
  689|     84|}

_ZN6google8protobuf8internal12ExtensionSetC2EPNS0_5ArenaE:
  192|     22|               : Arena::CreateArray<KeyValue>(arena_, flat_capacity_)} {}
_ZN6google8protobuf8internal12ExtensionSetD2Ev:
  194|     22|ExtensionSet::~ExtensionSet() {
  195|       |  // Deletes all allocated extensions.
  196|     22|  if (arena_ == NULL) {
  ------------------
  |  Branch (196:7): [True: 22, False: 0]
  ------------------
  197|     22|    ForEach([](int /* number */, Extension& ext) { ext.Free(); });
  198|     22|    if (PROTOBUF_PREDICT_FALSE(is_large())) {
  199|      0|      delete map_.large;
  200|     22|    } else {
  201|     22|      DeleteFlatMap(map_.flat, flat_capacity_);
  202|     22|    }
  203|     22|  }
  204|     22|}
_ZN6google8protobuf8internal12ExtensionSet13DeleteFlatMapEPKNS2_8KeyValueEt:
  207|     22|                                 uint16 flat_capacity) {
  208|       |#ifdef __cpp_sized_deallocation
  209|       |  // Arena::CreateArray already requires a trivially destructible type, but
  210|       |  // ensure this constraint is not violated in the future.
  211|       |  static_assert(std::is_trivially_destructible<KeyValue>::value,
  212|       |                "CreateArray requires a trivially destructible type");
  213|       |  // A const-cast is needed, but this is safe as we are about to deallocate the
  214|       |  // array.
  215|       |  ::operator delete[](const_cast<ExtensionSet::KeyValue*>(flat),
  216|       |                      sizeof(*flat) * flat_capacity);
  217|       |#else   // !__cpp_sized_deallocation
  218|     22|  delete[] flat;
  219|     22|#endif  // !__cpp_sized_deallocation
  220|     22|}
_ZNK6google8protobuf8internal12ExtensionSet13IsInitializedEv:
 1126|     22|bool ExtensionSet::IsInitialized() const {
 1127|       |  // Extensions are never required.  However, we need to check that all
 1128|       |  // embedded messages are initialized.
 1129|     22|  if (PROTOBUF_PREDICT_FALSE(is_large())) {
 1130|      0|    for (const auto& kv : *map_.large) {
  ------------------
  |  Branch (1130:25): [True: 0, False: 0]
  ------------------
 1131|      0|      if (!kv.second.IsInitialized()) return false;
  ------------------
  |  Branch (1131:11): [True: 0, False: 0]
  ------------------
 1132|      0|    }
 1133|      0|    return true;
 1134|      0|  }
 1135|     22|  for (const KeyValue* it = flat_begin(); it != flat_end(); ++it) {
  ------------------
  |  Branch (1135:43): [True: 0, False: 22]
  ------------------
 1136|      0|    if (!it->second.IsInitialized()) return false;
  ------------------
  |  Branch (1136:9): [True: 0, False: 0]
  ------------------
 1137|      0|  }
 1138|     22|  return true;
 1139|     22|}

_ZN6google8protobuf8internal20AddDescriptorsRunnerC2EPKNS1_15DescriptorTableE:
 2539|     12|AddDescriptorsRunner::AddDescriptorsRunner(const DescriptorTable* table) {
 2540|     12|  AddDescriptors(table);
 2541|     12|}
generated_message_reflection.cc:_ZN6google8protobuf12_GLOBAL__N_114AddDescriptorsEPKNS0_8internal15DescriptorTableE:
 2498|     16|void AddDescriptors(const DescriptorTable* table) {
 2499|       |  // AddDescriptors is not thread safe. Callers need to ensure calls are
 2500|       |  // properly serialized. This function is only called pre-main by global
 2501|       |  // descriptors and we can assume single threaded access or it's called
 2502|       |  // by AssignDescriptorImpl which uses a mutex to sequence calls.
 2503|     16|  if (table->is_initialized) return;
  ------------------
  |  Branch (2503:7): [True: 4, False: 12]
  ------------------
 2504|     12|  table->is_initialized = true;
 2505|     12|  AddDescriptorsImpl(table);
 2506|     12|}
generated_message_reflection.cc:_ZN6google8protobuf12_GLOBAL__N_118AddDescriptorsImplEPKNS0_8internal15DescriptorTableE:
 2481|     12|void AddDescriptorsImpl(const DescriptorTable* table) {
 2482|       |  // Reflection refers to the default fields so make sure they are initialized.
 2483|     12|  internal::InitProtobufDefaults();
 2484|       |
 2485|       |  // Ensure all dependent descriptors are registered to the generated descriptor
 2486|       |  // pool and message factory.
 2487|     12|  int num_deps = table->num_deps;
 2488|     16|  for (int i = 0; i < num_deps; i++) {
  ------------------
  |  Branch (2488:19): [True: 4, False: 12]
  ------------------
 2489|       |    // In case of weak fields deps[i] could be null.
 2490|      4|    if (table->deps[i]) AddDescriptors(table->deps[i]);
  ------------------
  |  Branch (2490:9): [True: 4, False: 0]
  ------------------
 2491|      4|  }
 2492|       |
 2493|       |  // Register the descriptor of this file.
 2494|     12|  DescriptorPool::InternalAddGeneratedFile(table->descriptor, table->size);
 2495|     12|  MessageFactory::InternalRegisterGeneratedFile(table);
 2496|     12|}

_ZN6google8protobuf8internal24InitProtobufDefaultsSlowEv:
   83|      4|void InitProtobufDefaultsSlow() {
   84|      4|  static bool is_inited = InitProtobufDefaultsImpl();
   85|      4|  (void)is_inited;
   86|      4|}
generated_message_util.cc:_ZN6google8protobuf8internalL24InitProtobufDefaultsImplEv:
   74|      2|static bool InitProtobufDefaultsImpl() {
   75|      2|  fixed_address_empty_string.DefaultConstruct();
   76|      2|  OnShutdownDestroyString(fixed_address_empty_string.get_mutable());
   77|       |
   78|       |
   79|      2|  init_protobuf_defaults_state.store(true, std::memory_order_release);
   80|      2|  return true;
   81|      2|}

_ZN6google8protobuf2io19LimitingInputStreamC2EPNS1_19ZeroCopyInputStreamEl:
  410|  43.1k|    : input_(input), limit_(limit) {
  411|  43.1k|  prior_bytes_read_ = input_->ByteCount();
  412|  43.1k|}
_ZN6google8protobuf2io19LimitingInputStreamD2Ev:
  414|  43.1k|LimitingInputStream::~LimitingInputStream() {
  415|       |  // If we overshot the limit, back up.
  416|  43.1k|  if (limit_ < 0) input_->BackUp(-limit_);
  ------------------
  |  Branch (416:7): [True: 0, False: 43.1k]
  ------------------
  417|  43.1k|}

_ZN6google8protobuf14MessageFactory29InternalRegisterGeneratedFileEPKNS0_8internal15DescriptorTableE:
  278|     12|    const google::protobuf::internal::DescriptorTable* table) {
  279|     12|  GeneratedMessageFactory::singleton()->RegisterFile(table);
  280|     12|}
message.cc:_ZN6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory9singletonEv:
  202|     12|GeneratedMessageFactory* GeneratedMessageFactory::singleton() {
  203|     12|  static auto instance =
  204|     12|      internal::OnShutdownDelete(new GeneratedMessageFactory);
  205|     12|  return instance;
  206|     12|}
message.cc:_ZN6google8protobuf12_GLOBAL__N_123GeneratedMessageFactory12RegisterFileEPKNS0_8internal15DescriptorTableE:
  209|     12|    const google::protobuf::internal::DescriptorTable* table) {
  210|     12|  if (!InsertIfNotPresent(&file_map_, table->filename, table)) {
  ------------------
  |  Branch (210:7): [True: 0, False: 12]
  ------------------
  211|      0|    GOOGLE_LOG(FATAL) << "File is already registered: " << table->filename;
  212|      0|  }
  213|     12|}

_ZN6google8protobuf8internal13MergeFromImplILb0EEEbNS0_20stringpiece_internal11StringPieceEPNS0_11MessageLiteENS5_10ParseFlagsE:
  140|     12|                   MessageLite::ParseFlags parse_flags) {
  141|     12|  const char* ptr;
  142|     12|  internal::ParseContext ctx(io::CodedInputStream::GetDefaultRecursionLimit(),
  143|     12|                             aliasing, &ptr, input);
  144|     12|  ptr = msg->_InternalParse(ptr, &ctx);
  145|       |  // ctx has an explicit limit set (length of string_view).
  146|     12|  if (PROTOBUF_PREDICT_TRUE(ptr && ctx.EndedAtLimit())) {
  147|     12|    return CheckFieldPresence(ctx, *msg, parse_flags);
  148|     12|  }
  149|      0|  return false;
  150|     12|}
_ZN6google8protobuf11MessageLite14ParseFromArrayEPKvi:
  324|     12|bool MessageLite::ParseFromArray(const void* data, int size) {
  325|     12|  return ParseFrom<kParse>(as_string_view(data, size));
  326|     12|}
_ZN6google8protobuf8internal13OnShutdownRunEPFvPKvES3_:
  581|      6|void OnShutdownRun(void (*f)(const void*), const void* arg) {
  582|      6|  auto shutdown_data = ShutdownData::get();
  583|      6|  MutexLock lock(&shutdown_data->mutex);
  584|      6|  shutdown_data->functions.push_back(std::make_pair(f, arg));
  585|      6|}
message_lite.cc:_ZN6google8protobuf12_GLOBAL__N_118CheckFieldPresenceERKNS0_8internal12ParseContextERKNS0_11MessageLiteENS6_10ParseFlagsE:
  123|     12|                               MessageLite::ParseFlags parse_flags) {
  124|     12|  if (PROTOBUF_PREDICT_FALSE((parse_flags & MessageLite::kMergePartial) != 0)) {
  125|      0|    return true;
  126|      0|  }
  127|     12|  return msg.IsInitializedWithErrors();
  128|     12|}
message_lite.cc:_ZN6google8protobuf12_GLOBAL__N_114as_string_viewEPKvi:
  116|     12|inline StringPiece as_string_view(const void* data, int size) {
  117|     12|  return StringPiece(static_cast<const char*>(data), size);
  118|     12|}
_ZN6google8protobuf8internal12ShutdownData3getEv:
  563|      6|  static ShutdownData* get() {
  564|      6|    static auto* data = new ShutdownData;
  565|      6|    return data;
  566|      6|  }

_ZN6google8protobuf8internal18EpsCopyInputStream12DoneFallbackEii:
  172|     10|                                                              int depth) {
  173|       |  // Did we exceeded the limit (parse error).
  174|     10|  if (PROTOBUF_PREDICT_FALSE(overrun > limit_)) return {nullptr, true};
  175|     10|  GOOGLE_DCHECK(overrun != limit_);  // Guaranteed by caller.
  176|     10|  GOOGLE_DCHECK(overrun < limit_);   // Follows from above
  177|       |  // TODO(gerbens) Instead of this dcheck we could just assign, and remove
  178|       |  // updating the limit_end from PopLimit, ie.
  179|       |  // limit_end_ = buffer_end_ + (std::min)(0, limit_);
  180|       |  // if (ptr < limit_end_) return {ptr, false};
  181|     10|  GOOGLE_DCHECK(limit_end_ == buffer_end_ + (std::min)(0, limit_));
  182|       |  // At this point we know the following assertion holds.
  183|     10|  GOOGLE_DCHECK(limit_ > 0);
  184|     10|  GOOGLE_DCHECK(limit_end_ == buffer_end_);  // because limit_ > 0
  185|     10|  const char* p;
  186|     10|  do {
  187|       |    // We are past the end of buffer_end_, in the slop region.
  188|     10|    GOOGLE_DCHECK(overrun >= 0);
  189|     10|    p = NextBuffer(overrun, depth);
  190|     10|    if (p == nullptr) {
  ------------------
  |  Branch (190:9): [True: 0, False: 10]
  ------------------
  191|       |      // We are at the end of the stream
  192|      0|      if (PROTOBUF_PREDICT_FALSE(overrun != 0)) return {nullptr, true};
  193|      0|      GOOGLE_DCHECK(limit_ > 0);
  194|      0|      limit_end_ = buffer_end_;
  195|       |      // Distinguish ending on a pushed limit or ending on end-of-stream.
  196|      0|      SetEndOfStream();
  197|      0|      return {buffer_end_, true};
  198|      0|    }
  199|     10|    limit_ -= buffer_end_ - p;  // Adjust limit_ relative to new anchor
  200|     10|    p += overrun;
  201|     10|    overrun = p - buffer_end_;
  202|     10|  } while (overrun >= 0);
  ------------------
  |  Branch (202:12): [True: 0, False: 10]
  ------------------
  203|     10|  limit_end_ = buffer_end_ + std::min(0, limit_);
  204|     10|  return {p, false};
  205|     10|}
_ZN6google8protobuf8internal12ParseContext28ReadSizeAndPushLimitAndDepthEPKcPi:
  330|    636|                                                       int* old_limit) {
  331|    636|  int size = ReadSize(&ptr);
  332|    636|  if (PROTOBUF_PREDICT_FALSE(!ptr)) {
  333|      0|    *old_limit = 0;  // Make sure this isn't uninitialized even on error return
  334|      0|    return nullptr;
  335|      0|  }
  336|    636|  *old_limit = PushLimit(ptr, size);
  337|    636|  if (--depth_ < 0) return nullptr;
  ------------------
  |  Branch (337:7): [True: 0, False: 636]
  ------------------
  338|    636|  return ptr;
  339|    636|}
_ZN6google8protobuf8internal17VarintParseSlow64EPKcj:
  387|     18|std::pair<const char*, uint64> VarintParseSlow64(const char* p, uint32 res32) {
  388|     18|  uint64 res = res32;
  389|     54|  for (std::uint32_t i = 2; i < 10; i++) {
  ------------------
  |  Branch (389:29): [True: 54, False: 0]
  ------------------
  390|     54|    uint64 byte = static_cast<uint8>(p[i]);
  391|     54|    res += (byte - 1) << (7 * i);
  392|     54|    if (PROTOBUF_PREDICT_TRUE(byte < 128)) {
  393|     18|      return {p + i + 1, res};
  394|     18|    }
  395|     54|  }
  396|      0|  return {nullptr, 0};
  397|     18|}
_ZN6google8protobuf8internal16ReadSizeFallbackEPKcj:
  410|     48|std::pair<const char*, int32> ReadSizeFallback(const char* p, uint32 res) {
  411|     48|  for (std::uint32_t i = 1; i < 4; i++) {
  ------------------
  |  Branch (411:29): [True: 48, False: 0]
  ------------------
  412|     48|    uint32 byte = static_cast<uint8>(p[i]);
  413|     48|    res += (byte - 1) << (7 * i);
  414|     48|    if (PROTOBUF_PREDICT_TRUE(byte < 128)) {
  415|     48|      return {p + i + 1, res};
  416|     48|    }
  417|     48|  }
  418|      0|  std::uint32_t byte = static_cast<uint8>(p[4]);
  419|      0|  if (PROTOBUF_PREDICT_FALSE(byte >= 8)) return {nullptr, 0};  // size >= 2gb
  420|      0|  res += (byte - 1) << 28;
  421|       |  // Protect against sign integer overflow in PushLimit. Limits are relative
  422|       |  // to buffer ends and ptr could potential be kSlopBytes beyond a buffer end.
  423|       |  // To protect against overflow we reject limits absurdly close to INT_MAX.
  424|      0|  if (PROTOBUF_PREDICT_FALSE(res > INT_MAX - ParseContext::kSlopBytes)) {
  425|      0|    return {nullptr, 0};
  426|      0|  }
  427|      0|  return {p + 5, res};
  428|      0|}
_ZN6google8protobuf8internal24InlineGreedyStringParserEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKcPNS1_12ParseContextE:
  450|    850|                                     ParseContext* ctx) {
  451|    850|  int size = ReadSize(&ptr);
  452|    850|  if (!ptr) return nullptr;
  ------------------
  |  Branch (452:7): [True: 0, False: 850]
  ------------------
  453|    850|  return ctx->ReadString(ptr, size, s);
  454|    850|}
_ZN6google8protobuf8internal18EpsCopyInputStream10NextBufferEii:
  102|     10|const char* EpsCopyInputStream::NextBuffer(int overrun, int depth) {
  103|     10|  if (next_chunk_ == nullptr) return nullptr;  // We've reached end of stream.
  ------------------
  |  Branch (103:7): [True: 0, False: 10]
  ------------------
  104|     10|  if (next_chunk_ != buffer_) {
  ------------------
  |  Branch (104:7): [True: 0, False: 10]
  ------------------
  105|      0|    GOOGLE_DCHECK(size_ > kSlopBytes);
  106|       |    // The chunk is large enough to be used directly
  107|      0|    buffer_end_ = next_chunk_ + size_ - kSlopBytes;
  108|      0|    auto res = next_chunk_;
  109|      0|    next_chunk_ = buffer_;
  110|      0|    if (aliasing_ == kOnPatch) aliasing_ = kNoDelta;
  ------------------
  |  Branch (110:9): [True: 0, False: 0]
  ------------------
  111|      0|    return res;
  112|      0|  }
  113|       |  // Move the slop bytes of previous buffer to start of the patch buffer.
  114|       |  // Note we must use memmove because the previous buffer could be part of
  115|       |  // buffer_.
  116|     10|  std::memmove(buffer_, buffer_end_, kSlopBytes);
  117|     10|  if (overall_limit_ > 0 &&
  ------------------
  |  Branch (117:7): [True: 0, False: 10]
  ------------------
  118|     10|      (depth < 0 || !ParseEndsInSlopRegion(buffer_, overrun, depth))) {
  ------------------
  |  Branch (118:8): [True: 0, False: 0]
  |  Branch (118:21): [True: 0, False: 0]
  ------------------
  119|      0|    const void* data;
  120|       |    // ZeroCopyInputStream indicates Next may return 0 size buffers. Hence
  121|       |    // we loop.
  122|      0|    while (StreamNext(&data)) {
  ------------------
  |  Branch (122:12): [True: 0, False: 0]
  ------------------
  123|      0|      if (size_ > kSlopBytes) {
  ------------------
  |  Branch (123:11): [True: 0, False: 0]
  ------------------
  124|       |        // We got a large chunk
  125|      0|        std::memcpy(buffer_ + kSlopBytes, data, kSlopBytes);
  126|      0|        next_chunk_ = static_cast<const char*>(data);
  127|      0|        buffer_end_ = buffer_ + kSlopBytes;
  128|      0|        if (aliasing_ >= kNoDelta) aliasing_ = kOnPatch;
  ------------------
  |  Branch (128:13): [True: 0, False: 0]
  ------------------
  129|      0|        return buffer_;
  130|      0|      } else if (size_ > 0) {
  ------------------
  |  Branch (130:18): [True: 0, False: 0]
  ------------------
  131|      0|        std::memcpy(buffer_ + kSlopBytes, data, size_);
  132|      0|        next_chunk_ = buffer_;
  133|      0|        buffer_end_ = buffer_ + size_;
  134|      0|        if (aliasing_ >= kNoDelta) aliasing_ = kOnPatch;
  ------------------
  |  Branch (134:13): [True: 0, False: 0]
  ------------------
  135|      0|        return buffer_;
  136|      0|      }
  137|      0|      GOOGLE_DCHECK(size_ == 0) << size_;
  138|      0|    }
  139|      0|    overall_limit_ = 0;  // Next failed, no more needs for next
  140|      0|  }
  141|       |  // End of stream or array
  142|     10|  if (aliasing_ == kNoDelta) {
  ------------------
  |  Branch (142:7): [True: 0, False: 10]
  ------------------
  143|       |    // If there is no more block and aliasing is true, the previous block
  144|       |    // is still valid and we can alias. We have users relying on string_view's
  145|       |    // obtained from protos to outlive the proto, when the parse was from an
  146|       |    // array. This guarantees string_view's are always aliased if parsed from
  147|       |    // an array.
  148|      0|    aliasing_ = reinterpret_cast<std::uintptr_t>(buffer_end_) -
  149|      0|                reinterpret_cast<std::uintptr_t>(buffer_);
  150|      0|  }
  151|     10|  next_chunk_ = nullptr;
  152|     10|  buffer_end_ = buffer_ + kSlopBytes;
  153|     10|  size_ = 0;
  154|     10|  return buffer_;
  155|     10|}

_ZN6google8protobuf8internal20RepeatedPtrFieldBase14InternalExtendEi:
   50|    248|void** RepeatedPtrFieldBase::InternalExtend(int extend_amount) {
   51|    248|  int new_size = current_size_ + extend_amount;
   52|    248|  if (total_size_ >= new_size) {
  ------------------
  |  Branch (52:7): [True: 0, False: 248]
  ------------------
   53|       |    // N.B.: rep_ is non-NULL because extend_amount is always > 0, hence
   54|       |    // total_size must be non-zero since it is lower-bounded by new_size.
   55|      0|    return &rep_->elements[current_size_];
   56|      0|  }
   57|    248|  Rep* old_rep = rep_;
   58|    248|  Arena* arena = GetArena();
   59|    248|  new_size = std::max(internal::kRepeatedFieldLowerClampLimit,
   60|    248|                      std::max(total_size_ * 2, new_size));
   61|    248|  GOOGLE_CHECK_LE(
   62|      0|      static_cast<int64>(new_size),
   63|      0|      static_cast<int64>((std::numeric_limits<size_t>::max() - kRepHeaderSize) /
   64|      0|                         sizeof(old_rep->elements[0])))
   65|      0|      << "Requested size is too large to fit into size_t.";
   66|    248|  size_t bytes = kRepHeaderSize + sizeof(old_rep->elements[0]) * new_size;
   67|    248|  if (arena == NULL) {
  ------------------
  |  Branch (67:7): [True: 248, False: 0]
  ------------------
   68|    248|    rep_ = reinterpret_cast<Rep*>(::operator new(bytes));
   69|    248|  } else {
   70|      0|    rep_ = reinterpret_cast<Rep*>(Arena::CreateArray<char>(arena, bytes));
   71|      0|  }
   72|       |#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
   73|       |  const int old_total_size = total_size_;
   74|       |#endif
   75|    248|  total_size_ = new_size;
   76|    248|  if (old_rep && old_rep->allocated_size > 0) {
  ------------------
  |  Branch (76:7): [True: 66, False: 182]
  |  Branch (76:18): [True: 66, False: 0]
  ------------------
   77|     66|    memcpy(rep_->elements, old_rep->elements,
   78|     66|           old_rep->allocated_size * sizeof(rep_->elements[0]));
   79|     66|    rep_->allocated_size = old_rep->allocated_size;
   80|    182|  } else {
   81|    182|    rep_->allocated_size = 0;
   82|    182|  }
   83|    248|  if (arena == NULL) {
  ------------------
  |  Branch (83:7): [True: 248, False: 0]
  ------------------
   84|       |#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
   85|       |    const size_t old_size =
   86|       |        old_total_size * sizeof(rep_->elements[0]) + kRepHeaderSize;
   87|       |    ::operator delete(static_cast<void*>(old_rep), old_size);
   88|       |#else
   89|    248|    ::operator delete(static_cast<void*>(old_rep));
   90|    248|#endif
   91|    248|  }
   92|    248|  return &rep_->elements[current_size_];
   93|    248|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase18AddOutOfLineHelperEPv:
  101|    618|void* RepeatedPtrFieldBase::AddOutOfLineHelper(void* obj) {
  102|    618|  if (!rep_ || rep_->allocated_size == total_size_) {
  ------------------
  |  Branch (102:7): [True: 182, False: 436]
  |  Branch (102:16): [True: 66, False: 370]
  ------------------
  103|    248|    InternalExtend(1);  // Equivalent to "Reserve(total_size_ + 1)"
  104|    248|  }
  105|    618|  ++rep_->allocated_size;
  106|    618|  rep_->elements[current_size_++] = obj;
  107|    618|  return obj;
  108|    618|}

_ZN6google8protobuf4util15status_internal6StatusC2Ev:
   88|    597|Status::Status() : error_code_(StatusCode::kOk) {}
_ZN6google8protobuf4util15status_internal6StatusC2ENS2_10StatusCodeENS0_20stringpiece_internal11StringPieceE:
   91|     86|    : error_code_(error_code) {
   92|     86|  if (error_code != StatusCode::kOk) {
  ------------------
  |  Branch (92:7): [True: 86, False: 0]
  ------------------
   93|     86|    error_message_ = error_message.ToString();
   94|     86|  }
   95|     86|}
_ZN6google8protobuf4util15status_internal6StatusaSERKS3_:
  101|     86|Status& Status::operator=(const Status& other) {
  102|     86|  error_code_ = other.error_code_;
  103|     86|  error_message_ = other.error_message_;
  104|     86|  return *this;
  105|     86|}

_ZNK6google8protobuf20stringpiece_internal11StringPiece6substrEmm:
  243|  1.02k|StringPiece StringPiece::substr(size_type pos, size_type n) const {
  244|  1.02k|  if (pos > length()) pos = length();
  ------------------
  |  Branch (244:7): [True: 0, False: 1.02k]
  ------------------
  245|  1.02k|  if (n > length_ - pos) n = length() - pos;
  ------------------
  |  Branch (245:7): [True: 0, False: 1.02k]
  ------------------
  246|  1.02k|  return StringPiece(ptr_ + pos, n);
  247|  1.02k|}

structurally_valid.cc:_ZN6google8protobuf8internal12_GLOBAL__N_112InitDetectorC2Ev:
  547|      2|  InitDetector() {
  548|      2|    module_initialized_ = true;
  549|      2|  }

_ZN6google8protobuf6StrCatERKNS0_7strings8AlphaNumES4_S4_:
 1481|    246|std::string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c) {
 1482|    246|  std::string result;
 1483|    246|  result.resize(a.size() + b.size() + c.size());
 1484|    246|  char *const begin = &*result.begin();
 1485|    246|  char *out = Append2(begin, a, b);
 1486|    246|  out = Append1(out, c);
 1487|    246|  GOOGLE_DCHECK_EQ(out, begin + result.size());
 1488|    246|  return result;
 1489|    246|}
strutil.cc:_ZN6google8protobufL7Append2EPcRKNS0_7strings8AlphaNumES5_:
 1439|    246|static char *Append2(char *out, const AlphaNum &x1, const AlphaNum &x2) {
 1440|    246|  if (x1.size() > 0) {
  ------------------
  |  Branch (1440:7): [True: 246, False: 0]
  ------------------
 1441|    246|    memcpy(out, x1.data(), x1.size());
 1442|    246|    out += x1.size();
 1443|    246|  }
 1444|    246|  if (x2.size() > 0) {
  ------------------
  |  Branch (1444:7): [True: 246, False: 0]
  ------------------
 1445|    246|    memcpy(out, x2.data(), x2.size());
 1446|    246|    out += x2.size();
 1447|    246|  }
 1448|    246|  return out;
 1449|    246|}
strutil.cc:_ZN6google8protobufL7Append1EPcRKNS0_7strings8AlphaNumE:
 1431|    246|static char *Append1(char *out, const AlphaNum &x) {
 1432|    246|  if (x.size() > 0) {
  ------------------
  |  Branch (1432:7): [True: 246, False: 0]
  ------------------
 1433|    246|    memcpy(out, x.data(), x.size());
 1434|    246|    out += x.size();
 1435|    246|  }
 1436|    246|  return out;
 1437|    246|}

_ZN6google4grpc11transcoding13MessageReaderC2EPNS1_21TranscoderInputStreamE:
   35|    597|      finished_(false) {}
_ZN6google4grpc11transcoding13MessageReader11NextMessageEv:
   80|  1.66M|std::unique_ptr<pbio::ZeroCopyInputStream> MessageReader::NextMessage() {
   81|  1.66M|  if (Finished()) {
  ------------------
  |  Branch (81:7): [True: 0, False: 1.66M]
  ------------------
   82|       |    // The stream has ended
   83|      0|    return nullptr;
   84|      0|  }
   85|       |
   86|       |  // Check if we have the current message size. If not try to read it.
   87|  1.66M|  if (!have_current_message_size_) {
  ------------------
  |  Branch (87:7): [True: 1.19M, False: 473k]
  ------------------
   88|  1.19M|    if (in_->BytesAvailable() <
  ------------------
  |  Branch (88:9): [True: 1.14M, False: 43.5k]
  ------------------
   89|  1.19M|        static_cast<pb::int64>(kGrpcDelimiterByteSize)) {
   90|       |      // We don't have 5 bytes available to read the length of the message.
   91|       |      // Find out whether the stream is finished and return false.
   92|  1.14M|      finished_ = in_->Finished();
   93|  1.14M|      if (finished_ && in_->BytesAvailable() != 0) {
  ------------------
  |  Branch (93:11): [True: 0, False: 1.14M]
  |  Branch (93:24): [True: 0, False: 0]
  ------------------
   94|      0|        status_ = google::protobuf::util::Status(
   95|      0|            google::protobuf::util::StatusCode::kInternal,
   96|      0|            "Incomplete gRPC frame header received");
   97|      0|      }
   98|  1.14M|      return nullptr;
   99|  1.14M|    }
  100|       |
  101|       |    // Try to read the delimiter.
  102|  43.5k|    memset(delimiter_, 0, kGrpcDelimiterByteSize);
  103|  43.5k|    if (!ReadStream(in_, delimiter_, kGrpcDelimiterByteSize)) {
  ------------------
  |  Branch (103:9): [True: 0, False: 43.5k]
  ------------------
  104|      0|      finished_ = true;
  105|      0|      return nullptr;
  106|      0|    }
  107|       |
  108|  43.5k|    if (delimiter_[0] != 0) {
  ------------------
  |  Branch (108:9): [True: 86, False: 43.4k]
  ------------------
  109|     86|      status_ = google::protobuf::util::Status(
  110|     86|          google::protobuf::util::StatusCode::kInternal,
  111|     86|          "Unsupported gRPC frame flag: " + std::to_string(delimiter_[0]));
  112|     86|      return nullptr;
  113|     86|    }
  114|       |
  115|  43.4k|    current_message_size_ = DelimiterToSize(delimiter_);
  116|  43.4k|    have_current_message_size_ = true;
  117|  43.4k|  }
  118|       |
  119|   517k|  if (in_->BytesAvailable() < static_cast<pb::int64>(current_message_size_)) {
  ------------------
  |  Branch (119:7): [True: 474k, False: 43.1k]
  ------------------
  120|   474k|    if (in_->Finished()) {
  ------------------
  |  Branch (120:9): [True: 0, False: 474k]
  ------------------
  121|      0|      status_ = google::protobuf::util::Status(
  122|      0|          google::protobuf::util::StatusCode::kInternal,
  123|      0|          "Incomplete gRPC frame expected size: " +
  124|      0|              std::to_string(current_message_size_) + " actual size: " +
  125|      0|              std::to_string(in_->BytesAvailable()));
  126|      0|    }
  127|       |    // We don't have a full message
  128|   474k|    return nullptr;
  129|   474k|  }
  130|       |
  131|       |  // Reset the have_current_message_size_ for the next message
  132|  43.1k|  have_current_message_size_ = false;
  133|       |
  134|       |  // We have a message! Use LimitingInputStream to wrap the input stream and
  135|       |  // limit it to current_message_size_ bytes to cover only the current message.
  136|  43.1k|  return std::unique_ptr<pbio::ZeroCopyInputStream>(
  137|  43.1k|      new pbio::LimitingInputStream(in_, current_message_size_));
  138|   517k|}
_ZN6google4grpc11transcoding13MessageReader23NextMessageAndGrpcFrameEv:
  140|  1.66M|MessageAndGrpcFrame MessageReader::NextMessageAndGrpcFrame() {
  141|  1.66M|  MessageAndGrpcFrame out;
  142|  1.66M|  out.message = NextMessage();
  143|  1.66M|  memcpy(out.grpc_frame, delimiter_, kGrpcDelimiterByteSize);
  144|  1.66M|  out.message_size = current_message_size_;
  145|  1.66M|  return out;
  146|  1.66M|}
message_reader.cc:_ZN6google4grpc11transcoding12_GLOBAL__N_110ReadStreamEPNS_8protobuf2io19ZeroCopyInputStreamEPhi:
   42|  43.5k|                int size) {
   43|  43.5k|  int size_in = 0;
   44|  43.5k|  const void* data_in = nullptr;
   45|       |  // While we have bytes to read
   46|   213k|  while (size > 0) {
  ------------------
  |  Branch (46:10): [True: 169k, False: 43.5k]
  ------------------
   47|   169k|    if (!stream->Next(&data_in, &size_in)) {
  ------------------
  |  Branch (47:9): [True: 0, False: 169k]
  ------------------
   48|      0|      return false;
   49|      0|    }
   50|   169k|    int to_copy = std::min(size, size_in);
   51|   169k|    memcpy(buffer, data_in, to_copy);
   52|       |    // Advance buffer and subtract the size to reflect the number of bytes left
   53|   169k|    buffer += to_copy;
   54|   169k|    size -= to_copy;
   55|       |    // Keep track of uncopied bytes
   56|   169k|    size_in -= to_copy;
   57|   169k|  }
   58|       |  // Return the uncopied bytes
   59|  43.5k|  stream->BackUp(size_in);
   60|  43.5k|  return true;
   61|  43.5k|}
message_reader.cc:_ZN6google4grpc11transcoding12_GLOBAL__N_115DelimiterToSizeEPKh:
   65|  43.4k|uint32_t DelimiterToSize(const unsigned char* delimiter) {
   66|  43.4k|  unsigned size = 0;
   67|       |  // Bytes 1-4 are big-endian 32-bit message size
   68|  43.4k|  size = size | static_cast<unsigned>(delimiter[1]);
   69|  43.4k|  size <<= 8;
   70|  43.4k|  size = size | static_cast<unsigned>(delimiter[2]);
   71|  43.4k|  size <<= 8;
   72|  43.4k|  size = size | static_cast<unsigned>(delimiter[3]);
   73|  43.4k|  size <<= 8;
   74|  43.4k|  size = size | static_cast<unsigned>(delimiter[4]);
   75|  43.4k|  return size;
   76|  43.4k|}

LLVMFuzzerTestOneInput:
   16|    597|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   17|    597|  FuzzedDataProvider provider(data, size);
   18|       |
   19|    597|  TestZeroCopyInputStream input_stream;
   20|    597|  MessageReader reader(&input_stream);
   21|       |
   22|  1.66M|  while (provider.remaining_bytes() > 0) {
  ------------------
  |  Branch (22:10): [True: 1.66M, False: 511]
  ------------------
   23|       |    // Add a few chucks of data to the input stream.
   24|  2.78M|    for (int i = 0; i < provider.ConsumeIntegralInRange(0, 5); i++) {
  ------------------
  |  Branch (24:21): [True: 1.11M, False: 1.66M]
  ------------------
   25|  1.11M|      input_stream.AddChunk(provider.ConsumeRandomLengthString(100));
   26|  1.11M|    }
   27|       |
   28|       |    // Run the message reader to get the next message.
   29|  1.66M|    (void)reader.NextMessageAndGrpcFrame();
   30|       |
   31|       |    // Handle end of input or error due to malformed bytes.
   32|  1.66M|    if (reader.Finished()) {
  ------------------
  |  Branch (32:9): [True: 86, False: 1.66M]
  ------------------
   33|     86|      return 0;
   34|     86|    }
   35|  1.66M|  }
   36|       |
   37|    511|  return 0;
   38|    597|}

_ZN6google4grpc11transcoding7testing23TestZeroCopyInputStreamC1Ev:
   43|    597|    : finished_(false), position_(0) {}
_ZN6google4grpc11transcoding7testing23TestZeroCopyInputStream8AddChunkENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE:
   45|  1.11M|void TestZeroCopyInputStream::AddChunk(std::string chunk) {
   46|       |  // Some of our tests generate 0-sized chunks. Let's not add them to the flow
   47|       |  // here because the tests explicitly handle 'out of input' and 'there is now
   48|       |  // new input' situations explicitly and empty chunks in the input would
   49|       |  // interfere with the test driver logic.
   50|  1.11M|  if (!chunk.empty()) {
  ------------------
  |  Branch (50:7): [True: 1.11M, False: 7.72k]
  ------------------
   51|  1.11M|    chunks_.emplace_back(std::move(chunk));
   52|  1.11M|  }
   53|  1.11M|}
_ZN6google4grpc11transcoding7testing23TestZeroCopyInputStream4NextEPPKvPi:
   55|   169k|bool TestZeroCopyInputStream::Next(const void** data, int* size) {
   56|   169k|  if (position_ < static_cast<int>(current_.size())) {
  ------------------
  |  Branch (56:7): [True: 11.8k, False: 158k]
  ------------------
   57|       |    // Still have some data in the current buffer
   58|  11.8k|    *data = current_.data() + position_;
   59|  11.8k|    *size = current_.size() - position_;
   60|  11.8k|    position_ = current_.size();
   61|  11.8k|    return true;
   62|   158k|  } else if (!chunks_.empty()) {
  ------------------
  |  Branch (62:14): [True: 158k, False: 0]
  ------------------
   63|       |    // Return the next buffer
   64|   158k|    current_ = std::move(chunks_.front());
   65|   158k|    chunks_.pop_front();
   66|   158k|    *data = current_.data();
   67|   158k|    *size = current_.size();
   68|   158k|    position_ = current_.size();
   69|   158k|    return true;
   70|   158k|  } else {
   71|      0|    *size = 0;
   72|      0|    return !finished_;
   73|      0|  }
   74|   169k|}
_ZN6google4grpc11transcoding7testing23TestZeroCopyInputStream6BackUpEi:
   76|  43.5k|void TestZeroCopyInputStream::BackUp(int count) {
   77|  87.0k|  EXPECT_TRUE(count <= position_) << "Out of bounds while trying to back up "
   78|  87.0k|                                     "the input stream. position: "
   79|  87.0k|                                  << position_ << " count: " << count
   80|  87.0k|                                  << std::endl;
   81|  43.5k|  position_ -= count;
   82|  43.5k|}
_ZNK6google4grpc11transcoding7testing23TestZeroCopyInputStream14BytesAvailableEv:
   84|  1.71M|int64_t TestZeroCopyInputStream::BytesAvailable() const {
   85|  1.71M|  auto total = current_.size() - position_;
   86|  4.57G|  for (auto chunk : chunks_) {
  ------------------
  |  Branch (86:19): [True: 4.57G, False: 1.71M]
  ------------------
   87|  4.57G|    total += chunk.size();
   88|  4.57G|  }
   89|  1.71M|  return total;
   90|  1.71M|}

_ZNK6google4grpc11transcoding7testing23TestZeroCopyInputStream8FinishedEv:
   48|  1.62M|  bool Finished() const { return finished_; }
_ZNK6google4grpc11transcoding7testing23TestZeroCopyInputStream9ByteCountEv:
   54|  43.1k|  int64_t ByteCount() const { return 0; }  // Not implemented