system_profile.pb.h - OpenGrok cross reference for /aosp_15_r20/out/soong/.intermediates/external/cronet/third_party/metrics_proto/cronet_aml_third_party_metrics_proto_metrics_proto_gen_headers/android_arm64_armv8-2a_cortex-a55_apex30/gen/third_party/metrics_proto/system_profile.pb.h

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: system_profile.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_system_5fprofile_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_system_5fprofile_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
#include "extension_install.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_system_5fprofile_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_system_5fprofile_2eproto {
  static const uint32_t offsets[];
};
namespace metrics {
class SystemProfileProto;
struct SystemProfileProtoDefaultTypeInternal;
extern SystemProfileProtoDefaultTypeInternal _SystemProfileProto_default_instance_;
class SystemProfileProto_AntiVirusProduct;
struct SystemProfileProto_AntiVirusProductDefaultTypeInternal;
extern SystemProfileProto_AntiVirusProductDefaultTypeInternal _SystemProfileProto_AntiVirusProduct_default_instance_;
class SystemProfileProto_ChromeComponent;
struct SystemProfileProto_ChromeComponentDefaultTypeInternal;
extern SystemProfileProto_ChromeComponentDefaultTypeInternal _SystemProfileProto_ChromeComponent_default_instance_;
class SystemProfileProto_ClonedInstallInfo;
struct SystemProfileProto_ClonedInstallInfoDefaultTypeInternal;
extern SystemProfileProto_ClonedInstallInfoDefaultTypeInternal _SystemProfileProto_ClonedInstallInfo_default_instance_;
class SystemProfileProto_DemoModeDimensions;
struct SystemProfileProto_DemoModeDimensionsDefaultTypeInternal;
extern SystemProfileProto_DemoModeDimensionsDefaultTypeInternal _SystemProfileProto_DemoModeDimensions_default_instance_;
class SystemProfileProto_DemoModeDimensions_Retailer;
struct SystemProfileProto_DemoModeDimensions_RetailerDefaultTypeInternal;
extern SystemProfileProto_DemoModeDimensions_RetailerDefaultTypeInternal _SystemProfileProto_DemoModeDimensions_Retailer_default_instance_;
class SystemProfileProto_ExternalAccessPoint;
struct SystemProfileProto_ExternalAccessPointDefaultTypeInternal;
extern SystemProfileProto_ExternalAccessPointDefaultTypeInternal _SystemProfileProto_ExternalAccessPoint_default_instance_;
class SystemProfileProto_ExternalAudioVideoDevice;
struct SystemProfileProto_ExternalAudioVideoDeviceDefaultTypeInternal;
extern SystemProfileProto_ExternalAudioVideoDeviceDefaultTypeInternal _SystemProfileProto_ExternalAudioVideoDevice_default_instance_;
class SystemProfileProto_ExternalAudioVideoDevice_AudioDescription;
struct SystemProfileProto_ExternalAudioVideoDevice_AudioDescriptionDefaultTypeInternal;
extern SystemProfileProto_ExternalAudioVideoDevice_AudioDescriptionDefaultTypeInternal _SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_default_instance_;
class SystemProfileProto_ExternalAudioVideoDevice_CECCommand;
struct SystemProfileProto_ExternalAudioVideoDevice_CECCommandDefaultTypeInternal;
extern SystemProfileProto_ExternalAudioVideoDevice_CECCommandDefaultTypeInternal _SystemProfileProto_ExternalAudioVideoDevice_CECCommand_default_instance_;
class SystemProfileProto_FieldTrial;
struct SystemProfileProto_FieldTrialDefaultTypeInternal;
extern SystemProfileProto_FieldTrialDefaultTypeInternal _SystemProfileProto_FieldTrial_default_instance_;
class SystemProfileProto_GoogleUpdate;
struct SystemProfileProto_GoogleUpdateDefaultTypeInternal;
extern SystemProfileProto_GoogleUpdateDefaultTypeInternal _SystemProfileProto_GoogleUpdate_default_instance_;
class SystemProfileProto_GoogleUpdate_ProductInfo;
struct SystemProfileProto_GoogleUpdate_ProductInfoDefaultTypeInternal;
extern SystemProfileProto_GoogleUpdate_ProductInfoDefaultTypeInternal _SystemProfileProto_GoogleUpdate_ProductInfo_default_instance_;
class SystemProfileProto_Hardware;
struct SystemProfileProto_HardwareDefaultTypeInternal;
extern SystemProfileProto_HardwareDefaultTypeInternal _SystemProfileProto_Hardware_default_instance_;
class SystemProfileProto_Hardware_CPU;
struct SystemProfileProto_Hardware_CPUDefaultTypeInternal;
extern SystemProfileProto_Hardware_CPUDefaultTypeInternal _SystemProfileProto_Hardware_CPU_default_instance_;
class SystemProfileProto_Hardware_Drive;
struct SystemProfileProto_Hardware_DriveDefaultTypeInternal;
extern SystemProfileProto_Hardware_DriveDefaultTypeInternal _SystemProfileProto_Hardware_Drive_default_instance_;
class SystemProfileProto_Hardware_Graphics;
struct SystemProfileProto_Hardware_GraphicsDefaultTypeInternal;
extern SystemProfileProto_Hardware_GraphicsDefaultTypeInternal _SystemProfileProto_Hardware_Graphics_default_instance_;
class SystemProfileProto_Hardware_InternalStorageDevice;
struct SystemProfileProto_Hardware_InternalStorageDeviceDefaultTypeInternal;
extern SystemProfileProto_Hardware_InternalStorageDeviceDefaultTypeInternal _SystemProfileProto_Hardware_InternalStorageDevice_default_instance_;
class SystemProfileProto_Hardware_Motherboard;
struct SystemProfileProto_Hardware_MotherboardDefaultTypeInternal;
extern SystemProfileProto_Hardware_MotherboardDefaultTypeInternal _SystemProfileProto_Hardware_Motherboard_default_instance_;
class SystemProfileProto_LinkedAndroidPhoneData;
struct SystemProfileProto_LinkedAndroidPhoneDataDefaultTypeInternal;
extern SystemProfileProto_LinkedAndroidPhoneDataDefaultTypeInternal _SystemProfileProto_LinkedAndroidPhoneData_default_instance_;
class SystemProfileProto_Network;
struct SystemProfileProto_NetworkDefaultTypeInternal;
extern SystemProfileProto_NetworkDefaultTypeInternal _SystemProfileProto_Network_default_instance_;
class SystemProfileProto_OS;
struct SystemProfileProto_OSDefaultTypeInternal;
extern SystemProfileProto_OSDefaultTypeInternal _SystemProfileProto_OS_default_instance_;
class SystemProfileProto_OS_Arc;
struct SystemProfileProto_OS_ArcDefaultTypeInternal;
extern SystemProfileProto_OS_ArcDefaultTypeInternal _SystemProfileProto_OS_Arc_default_instance_;
class SystemProfileProto_Stability;
struct SystemProfileProto_StabilityDefaultTypeInternal;
extern SystemProfileProto_StabilityDefaultTypeInternal _SystemProfileProto_Stability_default_instance_;
}  // namespace metrics
PROTOBUF_NAMESPACE_OPEN
template<> ::metrics::SystemProfileProto* Arena::CreateMaybeMessage<::metrics::SystemProfileProto>(Arena*);
template<> ::metrics::SystemProfileProto_AntiVirusProduct* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_AntiVirusProduct>(Arena*);
template<> ::metrics::SystemProfileProto_ChromeComponent* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_ChromeComponent>(Arena*);
template<> ::metrics::SystemProfileProto_ClonedInstallInfo* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_ClonedInstallInfo>(Arena*);
template<> ::metrics::SystemProfileProto_DemoModeDimensions* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_DemoModeDimensions>(Arena*);
template<> ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_DemoModeDimensions_Retailer>(Arena*);
template<> ::metrics::SystemProfileProto_ExternalAccessPoint* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_ExternalAccessPoint>(Arena*);
template<> ::metrics::SystemProfileProto_ExternalAudioVideoDevice* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_ExternalAudioVideoDevice>(Arena*);
template<> ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription>(Arena*);
template<> ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand>(Arena*);
template<> ::metrics::SystemProfileProto_FieldTrial* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_FieldTrial>(Arena*);
template<> ::metrics::SystemProfileProto_GoogleUpdate* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_GoogleUpdate>(Arena*);
template<> ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_GoogleUpdate_ProductInfo>(Arena*);
template<> ::metrics::SystemProfileProto_Hardware* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_Hardware>(Arena*);
template<> ::metrics::SystemProfileProto_Hardware_CPU* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_Hardware_CPU>(Arena*);
template<> ::metrics::SystemProfileProto_Hardware_Drive* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_Hardware_Drive>(Arena*);
template<> ::metrics::SystemProfileProto_Hardware_Graphics* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_Hardware_Graphics>(Arena*);
template<> ::metrics::SystemProfileProto_Hardware_InternalStorageDevice* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_Hardware_InternalStorageDevice>(Arena*);
template<> ::metrics::SystemProfileProto_Hardware_Motherboard* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_Hardware_Motherboard>(Arena*);
template<> ::metrics::SystemProfileProto_LinkedAndroidPhoneData* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_LinkedAndroidPhoneData>(Arena*);
template<> ::metrics::SystemProfileProto_Network* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_Network>(Arena*);
template<> ::metrics::SystemProfileProto_OS* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_OS>(Arena*);
template<> ::metrics::SystemProfileProto_OS_Arc* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_OS_Arc>(Arena*);
template<> ::metrics::SystemProfileProto_Stability* Arena::CreateMaybeMessage<::metrics::SystemProfileProto_Stability>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace metrics {

enum SystemProfileProto_OS_DarkModeState : int {
  SystemProfileProto_OS_DarkModeState_UNKNOWN = 0,
  SystemProfileProto_OS_DarkModeState_DARK_MODE_SYSTEM = 1,
  SystemProfileProto_OS_DarkModeState_DARK_MODE_APP = 2,
  SystemProfileProto_OS_DarkModeState_LIGHT_MODE_SYSTEM = 3,
  SystemProfileProto_OS_DarkModeState_LIGHT_MODE_APP = 4
};
bool SystemProfileProto_OS_DarkModeState_IsValid(int value);
constexpr SystemProfileProto_OS_DarkModeState SystemProfileProto_OS_DarkModeState_DarkModeState_MIN = SystemProfileProto_OS_DarkModeState_UNKNOWN;
constexpr SystemProfileProto_OS_DarkModeState SystemProfileProto_OS_DarkModeState_DarkModeState_MAX = SystemProfileProto_OS_DarkModeState_LIGHT_MODE_APP;
constexpr int SystemProfileProto_OS_DarkModeState_DarkModeState_ARRAYSIZE = SystemProfileProto_OS_DarkModeState_DarkModeState_MAX + 1;

const std::string& SystemProfileProto_OS_DarkModeState_Name(SystemProfileProto_OS_DarkModeState value);
template<typename T>
inline const std::string& SystemProfileProto_OS_DarkModeState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_OS_DarkModeState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_OS_DarkModeState_Name.");
  return SystemProfileProto_OS_DarkModeState_Name(static_cast<SystemProfileProto_OS_DarkModeState>(enum_t_value));
}
bool SystemProfileProto_OS_DarkModeState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_OS_DarkModeState* value);
enum SystemProfileProto_OS_XdgSessionType : int {
  SystemProfileProto_OS_XdgSessionType_UNSET = 0,
  SystemProfileProto_OS_XdgSessionType_OTHER_SESSION_TYPE = 1,
  SystemProfileProto_OS_XdgSessionType_UNSPECIFIED = 2,
  SystemProfileProto_OS_XdgSessionType_TTY = 3,
  SystemProfileProto_OS_XdgSessionType_X11 = 4,
  SystemProfileProto_OS_XdgSessionType_WAYLAND = 5,
  SystemProfileProto_OS_XdgSessionType_MIR = 6
};
bool SystemProfileProto_OS_XdgSessionType_IsValid(int value);
constexpr SystemProfileProto_OS_XdgSessionType SystemProfileProto_OS_XdgSessionType_XdgSessionType_MIN = SystemProfileProto_OS_XdgSessionType_UNSET;
constexpr SystemProfileProto_OS_XdgSessionType SystemProfileProto_OS_XdgSessionType_XdgSessionType_MAX = SystemProfileProto_OS_XdgSessionType_MIR;
constexpr int SystemProfileProto_OS_XdgSessionType_XdgSessionType_ARRAYSIZE = SystemProfileProto_OS_XdgSessionType_XdgSessionType_MAX + 1;

const std::string& SystemProfileProto_OS_XdgSessionType_Name(SystemProfileProto_OS_XdgSessionType value);
template<typename T>
inline const std::string& SystemProfileProto_OS_XdgSessionType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_OS_XdgSessionType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_OS_XdgSessionType_Name.");
  return SystemProfileProto_OS_XdgSessionType_Name(static_cast<SystemProfileProto_OS_XdgSessionType>(enum_t_value));
}
bool SystemProfileProto_OS_XdgSessionType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_OS_XdgSessionType* value);
enum SystemProfileProto_OS_XdgCurrentDesktop : int {
  SystemProfileProto_OS_XdgCurrentDesktop_OTHER = 0,
  SystemProfileProto_OS_XdgCurrentDesktop_CINNAMON = 1,
  SystemProfileProto_OS_XdgCurrentDesktop_DEEPIN = 2,
  SystemProfileProto_OS_XdgCurrentDesktop_GNOME = 3,
  SystemProfileProto_OS_XdgCurrentDesktop_KDE = 4,
  SystemProfileProto_OS_XdgCurrentDesktop_PANTHEON = 5,
  SystemProfileProto_OS_XdgCurrentDesktop_UKUI = 6,
  SystemProfileProto_OS_XdgCurrentDesktop_UNITY = 7,
  SystemProfileProto_OS_XdgCurrentDesktop_XFCE = 8,
  SystemProfileProto_OS_XdgCurrentDesktop_LXQT = 9
};
bool SystemProfileProto_OS_XdgCurrentDesktop_IsValid(int value);
constexpr SystemProfileProto_OS_XdgCurrentDesktop SystemProfileProto_OS_XdgCurrentDesktop_XdgCurrentDesktop_MIN = SystemProfileProto_OS_XdgCurrentDesktop_OTHER;
constexpr SystemProfileProto_OS_XdgCurrentDesktop SystemProfileProto_OS_XdgCurrentDesktop_XdgCurrentDesktop_MAX = SystemProfileProto_OS_XdgCurrentDesktop_LXQT;
constexpr int SystemProfileProto_OS_XdgCurrentDesktop_XdgCurrentDesktop_ARRAYSIZE = SystemProfileProto_OS_XdgCurrentDesktop_XdgCurrentDesktop_MAX + 1;

const std::string& SystemProfileProto_OS_XdgCurrentDesktop_Name(SystemProfileProto_OS_XdgCurrentDesktop value);
template<typename T>
inline const std::string& SystemProfileProto_OS_XdgCurrentDesktop_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_OS_XdgCurrentDesktop>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_OS_XdgCurrentDesktop_Name.");
  return SystemProfileProto_OS_XdgCurrentDesktop_Name(static_cast<SystemProfileProto_OS_XdgCurrentDesktop>(enum_t_value));
}
bool SystemProfileProto_OS_XdgCurrentDesktop_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_OS_XdgCurrentDesktop* value);
enum SystemProfileProto_Hardware_InternalStorageDevice_Type : int {
  SystemProfileProto_Hardware_InternalStorageDevice_Type_TYPE_UNKNOWN = 0,
  SystemProfileProto_Hardware_InternalStorageDevice_Type_TYPE_EMMC = 1,
  SystemProfileProto_Hardware_InternalStorageDevice_Type_TYPE_NVME = 2,
  SystemProfileProto_Hardware_InternalStorageDevice_Type_TYPE_UFS = 3,
  SystemProfileProto_Hardware_InternalStorageDevice_Type_TYPE_SD_EXPRESS_INTERNAL = 4
};
bool SystemProfileProto_Hardware_InternalStorageDevice_Type_IsValid(int value);
constexpr SystemProfileProto_Hardware_InternalStorageDevice_Type SystemProfileProto_Hardware_InternalStorageDevice_Type_Type_MIN = SystemProfileProto_Hardware_InternalStorageDevice_Type_TYPE_UNKNOWN;
constexpr SystemProfileProto_Hardware_InternalStorageDevice_Type SystemProfileProto_Hardware_InternalStorageDevice_Type_Type_MAX = SystemProfileProto_Hardware_InternalStorageDevice_Type_TYPE_SD_EXPRESS_INTERNAL;
constexpr int SystemProfileProto_Hardware_InternalStorageDevice_Type_Type_ARRAYSIZE = SystemProfileProto_Hardware_InternalStorageDevice_Type_Type_MAX + 1;

const std::string& SystemProfileProto_Hardware_InternalStorageDevice_Type_Name(SystemProfileProto_Hardware_InternalStorageDevice_Type value);
template<typename T>
inline const std::string& SystemProfileProto_Hardware_InternalStorageDevice_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_Hardware_InternalStorageDevice_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_Hardware_InternalStorageDevice_Type_Name.");
  return SystemProfileProto_Hardware_InternalStorageDevice_Type_Name(static_cast<SystemProfileProto_Hardware_InternalStorageDevice_Type>(enum_t_value));
}
bool SystemProfileProto_Hardware_InternalStorageDevice_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Hardware_InternalStorageDevice_Type* value);
enum SystemProfileProto_Hardware_InternalStorageDevice_Purpose : int {
  SystemProfileProto_Hardware_InternalStorageDevice_Purpose_PURPOSE_UNKNOWN = 0,
  SystemProfileProto_Hardware_InternalStorageDevice_Purpose_PURPOSE_BOOT = 1,
  SystemProfileProto_Hardware_InternalStorageDevice_Purpose_PURPOSE_SWAP = 2,
  SystemProfileProto_Hardware_InternalStorageDevice_Purpose_PURPOSE_BOOT_SWAP = 3
};
bool SystemProfileProto_Hardware_InternalStorageDevice_Purpose_IsValid(int value);
constexpr SystemProfileProto_Hardware_InternalStorageDevice_Purpose SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Purpose_MIN = SystemProfileProto_Hardware_InternalStorageDevice_Purpose_PURPOSE_UNKNOWN;
constexpr SystemProfileProto_Hardware_InternalStorageDevice_Purpose SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Purpose_MAX = SystemProfileProto_Hardware_InternalStorageDevice_Purpose_PURPOSE_BOOT_SWAP;
constexpr int SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Purpose_ARRAYSIZE = SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Purpose_MAX + 1;

const std::string& SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Name(SystemProfileProto_Hardware_InternalStorageDevice_Purpose value);
template<typename T>
inline const std::string& SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_Hardware_InternalStorageDevice_Purpose>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Name.");
  return SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Name(static_cast<SystemProfileProto_Hardware_InternalStorageDevice_Purpose>(enum_t_value));
}
bool SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Hardware_InternalStorageDevice_Purpose* value);
enum SystemProfileProto_Hardware_FormFactor : int {
  SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_UNKNOWN = 0,
  SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_DESKTOP = 1,
  SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_PHONE = 2,
  SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_TABLET = 3,
  SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_TV = 4,
  SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_MEET_DEVICE = 5,
  SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_AUTOMOTIVE = 6,
  SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_FOLDABLE = 7
};
bool SystemProfileProto_Hardware_FormFactor_IsValid(int value);
constexpr SystemProfileProto_Hardware_FormFactor SystemProfileProto_Hardware_FormFactor_FormFactor_MIN = SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_UNKNOWN;
constexpr SystemProfileProto_Hardware_FormFactor SystemProfileProto_Hardware_FormFactor_FormFactor_MAX = SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_FOLDABLE;
constexpr int SystemProfileProto_Hardware_FormFactor_FormFactor_ARRAYSIZE = SystemProfileProto_Hardware_FormFactor_FormFactor_MAX + 1;

const std::string& SystemProfileProto_Hardware_FormFactor_Name(SystemProfileProto_Hardware_FormFactor value);
template<typename T>
inline const std::string& SystemProfileProto_Hardware_FormFactor_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_Hardware_FormFactor>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_Hardware_FormFactor_Name.");
  return SystemProfileProto_Hardware_FormFactor_Name(static_cast<SystemProfileProto_Hardware_FormFactor>(enum_t_value));
}
bool SystemProfileProto_Hardware_FormFactor_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Hardware_FormFactor* value);
enum SystemProfileProto_Hardware_BiosType : int {
  SystemProfileProto_Hardware_BiosType_BIOS_TYPE_UNKNOWN = 0,
  SystemProfileProto_Hardware_BiosType_BIOS_TYPE_LEGACY = 1,
  SystemProfileProto_Hardware_BiosType_BIOS_TYPE_UEFI = 2
};
bool SystemProfileProto_Hardware_BiosType_IsValid(int value);
constexpr SystemProfileProto_Hardware_BiosType SystemProfileProto_Hardware_BiosType_BiosType_MIN = SystemProfileProto_Hardware_BiosType_BIOS_TYPE_UNKNOWN;
constexpr SystemProfileProto_Hardware_BiosType SystemProfileProto_Hardware_BiosType_BiosType_MAX = SystemProfileProto_Hardware_BiosType_BIOS_TYPE_UEFI;
constexpr int SystemProfileProto_Hardware_BiosType_BiosType_ARRAYSIZE = SystemProfileProto_Hardware_BiosType_BiosType_MAX + 1;

const std::string& SystemProfileProto_Hardware_BiosType_Name(SystemProfileProto_Hardware_BiosType value);
template<typename T>
inline const std::string& SystemProfileProto_Hardware_BiosType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_Hardware_BiosType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_Hardware_BiosType_Name.");
  return SystemProfileProto_Hardware_BiosType_Name(static_cast<SystemProfileProto_Hardware_BiosType>(enum_t_value));
}
bool SystemProfileProto_Hardware_BiosType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Hardware_BiosType* value);
enum SystemProfileProto_Hardware_TpmType : int {
  SystemProfileProto_Hardware_TpmType_TPM_TYPE_UNKNOWN = 0,
  SystemProfileProto_Hardware_TpmType_TPM_TYPE_1 = 1,
  SystemProfileProto_Hardware_TpmType_TPM_TYPE_CR50 = 2,
  SystemProfileProto_Hardware_TpmType_TPM_TYPE_TI50 = 3,
  SystemProfileProto_Hardware_TpmType_TPM_TYPE_RUNTIME_SELECTION = 4,
  SystemProfileProto_Hardware_TpmType_TPM_TYPE_GENERIC_2 = 5
};
bool SystemProfileProto_Hardware_TpmType_IsValid(int value);
constexpr SystemProfileProto_Hardware_TpmType SystemProfileProto_Hardware_TpmType_TpmType_MIN = SystemProfileProto_Hardware_TpmType_TPM_TYPE_UNKNOWN;
constexpr SystemProfileProto_Hardware_TpmType SystemProfileProto_Hardware_TpmType_TpmType_MAX = SystemProfileProto_Hardware_TpmType_TPM_TYPE_GENERIC_2;
constexpr int SystemProfileProto_Hardware_TpmType_TpmType_ARRAYSIZE = SystemProfileProto_Hardware_TpmType_TpmType_MAX + 1;

const std::string& SystemProfileProto_Hardware_TpmType_Name(SystemProfileProto_Hardware_TpmType value);
template<typename T>
inline const std::string& SystemProfileProto_Hardware_TpmType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_Hardware_TpmType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_Hardware_TpmType_Name.");
  return SystemProfileProto_Hardware_TpmType_Name(static_cast<SystemProfileProto_Hardware_TpmType>(enum_t_value));
}
bool SystemProfileProto_Hardware_TpmType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Hardware_TpmType* value);
enum SystemProfileProto_Network_ConnectionType : int {
  SystemProfileProto_Network_ConnectionType_CONNECTION_UNKNOWN = 0,
  SystemProfileProto_Network_ConnectionType_CONNECTION_ETHERNET = 1,
  SystemProfileProto_Network_ConnectionType_CONNECTION_WIFI = 2,
  SystemProfileProto_Network_ConnectionType_CONNECTION_2G = 3,
  SystemProfileProto_Network_ConnectionType_CONNECTION_3G = 4,
  SystemProfileProto_Network_ConnectionType_CONNECTION_4G = 5,
  SystemProfileProto_Network_ConnectionType_CONNECTION_BLUETOOTH = 6,
  SystemProfileProto_Network_ConnectionType_CONNECTION_NONE = 7,
  SystemProfileProto_Network_ConnectionType_CONNECTION_AMBIGUOUS = 8,
  SystemProfileProto_Network_ConnectionType_CONNECTION_5G = 9
};
bool SystemProfileProto_Network_ConnectionType_IsValid(int value);
constexpr SystemProfileProto_Network_ConnectionType SystemProfileProto_Network_ConnectionType_ConnectionType_MIN = SystemProfileProto_Network_ConnectionType_CONNECTION_UNKNOWN;
constexpr SystemProfileProto_Network_ConnectionType SystemProfileProto_Network_ConnectionType_ConnectionType_MAX = SystemProfileProto_Network_ConnectionType_CONNECTION_5G;
constexpr int SystemProfileProto_Network_ConnectionType_ConnectionType_ARRAYSIZE = SystemProfileProto_Network_ConnectionType_ConnectionType_MAX + 1;

const std::string& SystemProfileProto_Network_ConnectionType_Name(SystemProfileProto_Network_ConnectionType value);
template<typename T>
inline const std::string& SystemProfileProto_Network_ConnectionType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_Network_ConnectionType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_Network_ConnectionType_Name.");
  return SystemProfileProto_Network_ConnectionType_Name(static_cast<SystemProfileProto_Network_ConnectionType>(enum_t_value));
}
bool SystemProfileProto_Network_ConnectionType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Network_ConnectionType* value);
enum SystemProfileProto_Network_WifiPHYLayerProtocol : int {
  SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_NONE = 0,
  SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_ANCIENT = 1,
  SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_A = 2,
  SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_B = 3,
  SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_G = 4,
  SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_N = 5,
  SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_UNKNOWN = 6,
  SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_AC = 7,
  SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_AD = 8,
  SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_AX = 9
};
bool SystemProfileProto_Network_WifiPHYLayerProtocol_IsValid(int value);
constexpr SystemProfileProto_Network_WifiPHYLayerProtocol SystemProfileProto_Network_WifiPHYLayerProtocol_WifiPHYLayerProtocol_MIN = SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_NONE;
constexpr SystemProfileProto_Network_WifiPHYLayerProtocol SystemProfileProto_Network_WifiPHYLayerProtocol_WifiPHYLayerProtocol_MAX = SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_AX;
constexpr int SystemProfileProto_Network_WifiPHYLayerProtocol_WifiPHYLayerProtocol_ARRAYSIZE = SystemProfileProto_Network_WifiPHYLayerProtocol_WifiPHYLayerProtocol_MAX + 1;

const std::string& SystemProfileProto_Network_WifiPHYLayerProtocol_Name(SystemProfileProto_Network_WifiPHYLayerProtocol value);
template<typename T>
inline const std::string& SystemProfileProto_Network_WifiPHYLayerProtocol_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_Network_WifiPHYLayerProtocol>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_Network_WifiPHYLayerProtocol_Name.");
  return SystemProfileProto_Network_WifiPHYLayerProtocol_Name(static_cast<SystemProfileProto_Network_WifiPHYLayerProtocol>(enum_t_value));
}
bool SystemProfileProto_Network_WifiPHYLayerProtocol_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Network_WifiPHYLayerProtocol* value);
enum SystemProfileProto_Network_EffectiveConnectionType : int {
  SystemProfileProto_Network_EffectiveConnectionType_EFFECTIVE_CONNECTION_TYPE_UNKNOWN = 0,
  SystemProfileProto_Network_EffectiveConnectionType_DEPRECATED_EFFECTIVE_CONNECTION_TYPE_AMBIGUOUS PROTOBUF_DEPRECATED_ENUM = 1,
  SystemProfileProto_Network_EffectiveConnectionType_EFFECTIVE_CONNECTION_TYPE_OFFLINE = 2,
  SystemProfileProto_Network_EffectiveConnectionType_EFFECTIVE_CONNECTION_TYPE_SLOW_2G = 3,
  SystemProfileProto_Network_EffectiveConnectionType_EFFECTIVE_CONNECTION_TYPE_2G = 4,
  SystemProfileProto_Network_EffectiveConnectionType_EFFECTIVE_CONNECTION_TYPE_3G = 5,
  SystemProfileProto_Network_EffectiveConnectionType_EFFECTIVE_CONNECTION_TYPE_4G = 6
};
bool SystemProfileProto_Network_EffectiveConnectionType_IsValid(int value);
constexpr SystemProfileProto_Network_EffectiveConnectionType SystemProfileProto_Network_EffectiveConnectionType_EffectiveConnectionType_MIN = SystemProfileProto_Network_EffectiveConnectionType_EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
constexpr SystemProfileProto_Network_EffectiveConnectionType SystemProfileProto_Network_EffectiveConnectionType_EffectiveConnectionType_MAX = SystemProfileProto_Network_EffectiveConnectionType_EFFECTIVE_CONNECTION_TYPE_4G;
constexpr int SystemProfileProto_Network_EffectiveConnectionType_EffectiveConnectionType_ARRAYSIZE = SystemProfileProto_Network_EffectiveConnectionType_EffectiveConnectionType_MAX + 1;

const std::string& SystemProfileProto_Network_EffectiveConnectionType_Name(SystemProfileProto_Network_EffectiveConnectionType value);
template<typename T>
inline const std::string& SystemProfileProto_Network_EffectiveConnectionType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_Network_EffectiveConnectionType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_Network_EffectiveConnectionType_Name.");
  return SystemProfileProto_Network_EffectiveConnectionType_Name(static_cast<SystemProfileProto_Network_EffectiveConnectionType>(enum_t_value));
}
bool SystemProfileProto_Network_EffectiveConnectionType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Network_EffectiveConnectionType* value);
enum SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult : int {
  SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_INSTALL_RESULT_SUCCESS = 0,
  SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_INSTALL_RESULT_FAILED_CUSTOM_ERROR = 1,
  SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_INSTALL_RESULT_FAILED_MSI_ERROR = 2,
  SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_INSTALL_RESULT_FAILED_SYSTEM_ERROR = 3,
  SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_INSTALL_RESULT_EXIT_CODE = 4
};
bool SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_IsValid(int value);
constexpr SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_InstallResult_MIN = SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_INSTALL_RESULT_SUCCESS;
constexpr SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_InstallResult_MAX = SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_INSTALL_RESULT_EXIT_CODE;
constexpr int SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_InstallResult_ARRAYSIZE = SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_InstallResult_MAX + 1;

const std::string& SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_Name(SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult value);
template<typename T>
inline const std::string& SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_Name.");
  return SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_Name(static_cast<SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult>(enum_t_value));
}
bool SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult* value);
enum SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat : int {
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_UNKNOWN = 0,
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_LPCM = 1,
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_AC_3 = 2,
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_MPEG1 = 3,
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_MP3 = 4,
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_MPEG2 = 5,
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_AAC = 6,
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_DTS = 7,
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_ATRAC = 8,
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_ONE_BIT = 9,
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_DD_PLUS = 10,
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_DTS_HD = 11,
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_MLP_DOLBY_TRUEHD = 12,
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_DST_AUDIO = 13,
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_MICROSOFT_WMA_PRO = 14
};
bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_IsValid(int value);
constexpr SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AudioFormat_MIN = SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_UNKNOWN;
constexpr SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AudioFormat_MAX = SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_MICROSOFT_WMA_PRO;
constexpr int SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AudioFormat_ARRAYSIZE = SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AudioFormat_MAX + 1;

const std::string& SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_Name(SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat value);
template<typename T>
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_Name.");
  return SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_Name(static_cast<SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat>(enum_t_value));
}
bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat* value);
enum SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode : int {
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_ANALOG = 0,
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_DIGITAL = 1
};
bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_IsValid(int value);
constexpr SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_OutputMode_MIN = SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_ANALOG;
constexpr SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_OutputMode_MAX = SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_DIGITAL;
constexpr int SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_OutputMode_ARRAYSIZE = SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_OutputMode_MAX + 1;

const std::string& SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_Name(SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode value);
template<typename T>
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_Name.");
  return SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_Name(static_cast<SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode>(enum_t_value));
}
bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode* value);
enum SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType : int {
  SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AV_DEVICE_TYPE_UNKNOWN = 0,
  SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AV_DEVICE_TYPE_TV = 1,
  SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AV_DEVICE_TYPE_RECORDER = 2,
  SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AV_DEVICE_TYPE_TUNER = 3,
  SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AV_DEVICE_TYPE_PLAYER = 4,
  SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AV_DEVICE_TYPE_AUDIO_SYSTEM = 5
};
bool SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_IsValid(int value);
constexpr SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AVDeviceType_MIN = SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AV_DEVICE_TYPE_UNKNOWN;
constexpr SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AVDeviceType_MAX = SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AV_DEVICE_TYPE_AUDIO_SYSTEM;
constexpr int SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AVDeviceType_ARRAYSIZE = SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AVDeviceType_MAX + 1;

const std::string& SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_Name(SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType value);
template<typename T>
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_Name.");
  return SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_Name(static_cast<SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType>(enum_t_value));
}
bool SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType* value);
enum SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding : int {
  SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_COLOR_ENCODING_UNKNOWN = 0,
  SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_COLOR_ENCODING_RGB = 1,
  SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_COLOR_ENCODING_YUV444 = 2,
  SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_COLOR_ENCODING_YUV422 = 3,
  SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_COLOR_ENCODING_YUV420 = 4
};
bool SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_IsValid(int value);
constexpr SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_ColorEncoding_MIN = SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_COLOR_ENCODING_UNKNOWN;
constexpr SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_ColorEncoding_MAX = SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_COLOR_ENCODING_YUV420;
constexpr int SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_ColorEncoding_ARRAYSIZE = SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_ColorEncoding_MAX + 1;

const std::string& SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_Name(SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding value);
template<typename T>
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_Name.");
  return SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_Name(static_cast<SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding>(enum_t_value));
}
bool SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding* value);
enum SystemProfileProto_DemoModeDimensions_CustomizationFacet : int {
  SystemProfileProto_DemoModeDimensions_CustomizationFacet_UNDEFINED = 0,
  SystemProfileProto_DemoModeDimensions_CustomizationFacet_CLOUD_GAMING_DEVICE = 1,
  SystemProfileProto_DemoModeDimensions_CustomizationFacet_FEATURE_AWARE_DEVICE = 2
};
bool SystemProfileProto_DemoModeDimensions_CustomizationFacet_IsValid(int value);
constexpr SystemProfileProto_DemoModeDimensions_CustomizationFacet SystemProfileProto_DemoModeDimensions_CustomizationFacet_CustomizationFacet_MIN = SystemProfileProto_DemoModeDimensions_CustomizationFacet_UNDEFINED;
constexpr SystemProfileProto_DemoModeDimensions_CustomizationFacet SystemProfileProto_DemoModeDimensions_CustomizationFacet_CustomizationFacet_MAX = SystemProfileProto_DemoModeDimensions_CustomizationFacet_FEATURE_AWARE_DEVICE;
constexpr int SystemProfileProto_DemoModeDimensions_CustomizationFacet_CustomizationFacet_ARRAYSIZE = SystemProfileProto_DemoModeDimensions_CustomizationFacet_CustomizationFacet_MAX + 1;

const std::string& SystemProfileProto_DemoModeDimensions_CustomizationFacet_Name(SystemProfileProto_DemoModeDimensions_CustomizationFacet value);
template<typename T>
inline const std::string& SystemProfileProto_DemoModeDimensions_CustomizationFacet_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_DemoModeDimensions_CustomizationFacet>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_DemoModeDimensions_CustomizationFacet_Name.");
  return SystemProfileProto_DemoModeDimensions_CustomizationFacet_Name(static_cast<SystemProfileProto_DemoModeDimensions_CustomizationFacet>(enum_t_value));
}
bool SystemProfileProto_DemoModeDimensions_CustomizationFacet_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_DemoModeDimensions_CustomizationFacet* value);
enum SystemProfileProto_Channel : int {
  SystemProfileProto_Channel_CHANNEL_UNKNOWN = 0,
  SystemProfileProto_Channel_CHANNEL_CANARY = 1,
  SystemProfileProto_Channel_CHANNEL_DEV = 2,
  SystemProfileProto_Channel_CHANNEL_BETA = 3,
  SystemProfileProto_Channel_CHANNEL_STABLE = 4
};
bool SystemProfileProto_Channel_IsValid(int value);
constexpr SystemProfileProto_Channel SystemProfileProto_Channel_Channel_MIN = SystemProfileProto_Channel_CHANNEL_UNKNOWN;
constexpr SystemProfileProto_Channel SystemProfileProto_Channel_Channel_MAX = SystemProfileProto_Channel_CHANNEL_STABLE;
constexpr int SystemProfileProto_Channel_Channel_ARRAYSIZE = SystemProfileProto_Channel_Channel_MAX + 1;

const std::string& SystemProfileProto_Channel_Name(SystemProfileProto_Channel value);
template<typename T>
inline const std::string& SystemProfileProto_Channel_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_Channel>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_Channel_Name.");
  return SystemProfileProto_Channel_Name(static_cast<SystemProfileProto_Channel>(enum_t_value));
}
bool SystemProfileProto_Channel_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_Channel* value);
enum SystemProfileProto_ExtensionsState : int {
  SystemProfileProto_ExtensionsState_NO_EXTENSIONS = 0,
  SystemProfileProto_ExtensionsState_NO_OFFSTORE_VERIFIED = 1,
  SystemProfileProto_ExtensionsState_NO_OFFSTORE_UNVERIFIED = 2,
  SystemProfileProto_ExtensionsState_HAS_OFFSTORE = 3
};
bool SystemProfileProto_ExtensionsState_IsValid(int value);
constexpr SystemProfileProto_ExtensionsState SystemProfileProto_ExtensionsState_ExtensionsState_MIN = SystemProfileProto_ExtensionsState_NO_EXTENSIONS;
constexpr SystemProfileProto_ExtensionsState SystemProfileProto_ExtensionsState_ExtensionsState_MAX = SystemProfileProto_ExtensionsState_HAS_OFFSTORE;
constexpr int SystemProfileProto_ExtensionsState_ExtensionsState_ARRAYSIZE = SystemProfileProto_ExtensionsState_ExtensionsState_MAX + 1;

const std::string& SystemProfileProto_ExtensionsState_Name(SystemProfileProto_ExtensionsState value);
template<typename T>
inline const std::string& SystemProfileProto_ExtensionsState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_ExtensionsState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_ExtensionsState_Name.");
  return SystemProfileProto_ExtensionsState_Name(static_cast<SystemProfileProto_ExtensionsState>(enum_t_value));
}
bool SystemProfileProto_ExtensionsState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_ExtensionsState* value);
enum SystemProfileProto_UmaDefaultState : int {
  SystemProfileProto_UmaDefaultState_OPT_IN = 0,
  SystemProfileProto_UmaDefaultState_OPT_OUT = 1,
  SystemProfileProto_UmaDefaultState_POLICY_FORCED_ENABLED = 2,
  SystemProfileProto_UmaDefaultState_OPT_UNKNOWN = 3
};
bool SystemProfileProto_UmaDefaultState_IsValid(int value);
constexpr SystemProfileProto_UmaDefaultState SystemProfileProto_UmaDefaultState_UmaDefaultState_MIN = SystemProfileProto_UmaDefaultState_OPT_IN;
constexpr SystemProfileProto_UmaDefaultState SystemProfileProto_UmaDefaultState_UmaDefaultState_MAX = SystemProfileProto_UmaDefaultState_OPT_UNKNOWN;
constexpr int SystemProfileProto_UmaDefaultState_UmaDefaultState_ARRAYSIZE = SystemProfileProto_UmaDefaultState_UmaDefaultState_MAX + 1;

const std::string& SystemProfileProto_UmaDefaultState_Name(SystemProfileProto_UmaDefaultState value);
template<typename T>
inline const std::string& SystemProfileProto_UmaDefaultState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_UmaDefaultState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_UmaDefaultState_Name.");
  return SystemProfileProto_UmaDefaultState_Name(static_cast<SystemProfileProto_UmaDefaultState>(enum_t_value));
}
bool SystemProfileProto_UmaDefaultState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_UmaDefaultState* value);
enum SystemProfileProto_AntiVirusState : int {
  SystemProfileProto_AntiVirusState_STATE_ON = 0,
  SystemProfileProto_AntiVirusState_STATE_OFF = 1,
  SystemProfileProto_AntiVirusState_STATE_SNOOZED = 2,
  SystemProfileProto_AntiVirusState_STATE_EXPIRED = 3
};
bool SystemProfileProto_AntiVirusState_IsValid(int value);
constexpr SystemProfileProto_AntiVirusState SystemProfileProto_AntiVirusState_AntiVirusState_MIN = SystemProfileProto_AntiVirusState_STATE_ON;
constexpr SystemProfileProto_AntiVirusState SystemProfileProto_AntiVirusState_AntiVirusState_MAX = SystemProfileProto_AntiVirusState_STATE_EXPIRED;
constexpr int SystemProfileProto_AntiVirusState_AntiVirusState_ARRAYSIZE = SystemProfileProto_AntiVirusState_AntiVirusState_MAX + 1;

const std::string& SystemProfileProto_AntiVirusState_Name(SystemProfileProto_AntiVirusState value);
template<typename T>
inline const std::string& SystemProfileProto_AntiVirusState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_AntiVirusState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_AntiVirusState_Name.");
  return SystemProfileProto_AntiVirusState_Name(static_cast<SystemProfileProto_AntiVirusState>(enum_t_value));
}
bool SystemProfileProto_AntiVirusState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_AntiVirusState* value);
enum SystemProfileProto_ComponentId : int {
  SystemProfileProto_ComponentId_UNKNOWN = 1,
  SystemProfileProto_ComponentId_FILE_TYPE_POLICIES = 2,
  SystemProfileProto_ComponentId_ORIGIN_TRIALS = 3,
  SystemProfileProto_ComponentId_PEPPER_FLASH = 4,
  SystemProfileProto_ComponentId_PEPPER_FLASH_CHROMEOS = 5,
  SystemProfileProto_ComponentId_PNACL = 6,
  SystemProfileProto_ComponentId_RECOVERY = 7,
  SystemProfileProto_ComponentId_SSL_ERROR_ASSISTANT = 8,
  SystemProfileProto_ComponentId_STH_SET = 9,
  SystemProfileProto_ComponentId_CRL_SET = 10,
  SystemProfileProto_ComponentId_SUBRESOURCE_FILTER = 11,
  SystemProfileProto_ComponentId_SW_REPORTER = 12,
  SystemProfileProto_ComponentId_WIDEVINE_CDM = 13,
  SystemProfileProto_ComponentId_EPSON_INKJET_PRINTER_ESCPR = 14,
  SystemProfileProto_ComponentId_CROS_TERMINA = 15,
  SystemProfileProto_ComponentId_STAR_CUPS_DRIVER = 16,
  SystemProfileProto_ComponentId_SPEECH_SYNTHESIS_SV_SE = 17,
  SystemProfileProto_ComponentId_OPTIMIZATION_HINTS = 18,
  SystemProfileProto_ComponentId_DOWNLOADABLE_STRINGS = 19,
  SystemProfileProto_ComponentId_VR_ASSETS = 20,
  SystemProfileProto_ComponentId_RTANALYTICS_LIGHT = 21,
  SystemProfileProto_ComponentId_RTANALYTICS_FULL = 22,
  SystemProfileProto_ComponentId_CELLULAR = 23,
  SystemProfileProto_ComponentId_DEMO_MODE_RESOURCES = 24,
  SystemProfileProto_ComponentId_ON_DEVICE_HEAD_SUGGEST = 25,
  SystemProfileProto_ComponentId_CROS_SMART_DIM = 26,
  SystemProfileProto_ComponentId_ZXCVBN_DATA = 27,
  SystemProfileProto_ComponentId_AUTOFILL_REGEX_CONSTANTS = 28,
  SystemProfileProto_ComponentId_WEBVIEW_APPS_PACKAGE_NAMES_ALLOWLIST = 29,
  SystemProfileProto_ComponentId_MEDIA_FOUNDATION_WIDEVINE_CDM = 30,
  SystemProfileProto_ComponentId_CROWD_DENY = 31,
  SystemProfileProto_ComponentId_APP_PROVISIONING = 32,
  SystemProfileProto_ComponentId_AUTOFILL_STATES = 33,
  SystemProfileProto_ComponentId_CLIENT_SIDE_PHISHING = 34,
  SystemProfileProto_ComponentId_COMMERCE_HEURISTICS = 35,
  SystemProfileProto_ComponentId_CROW_DOMAIN_LIST = 36,
  SystemProfileProto_ComponentId_DEMO_MODE_APP = 37,
  SystemProfileProto_ComponentId_DESKTOP_SCREENSHOT_EDITOR = 38,
  SystemProfileProto_ComponentId_DESKTOP_SHARING_HUB = 39,
  SystemProfileProto_ComponentId_FIRST_PARTY_SETS = 40,
  SystemProfileProto_ComponentId_HYPHENATION = 41,
  SystemProfileProto_ComponentId_INTERVENTION_POLICY_DATABASE = 42,
  SystemProfileProto_ComponentId_LACROS_DOGFOOD_BETA = 43,
  SystemProfileProto_ComponentId_LACROS_DOGFOOD_CANARY = 44,
  SystemProfileProto_ComponentId_LACROS_DOGFOOD_DEV = 45,
  SystemProfileProto_ComponentId_LACROS_DOGFOOD_STABLE = 46,
  SystemProfileProto_ComponentId_MEI_PRELOAD = 47,
  SystemProfileProto_ComponentId_PKI_METADATA = 48,
  SystemProfileProto_ComponentId_REAL_TIME_URL_CHECKS_ALLOWLIST = 49,
  SystemProfileProto_ComponentId_RECOVERY_IMPROVED = 50,
  SystemProfileProto_ComponentId_SAFETY_TIPS = 51,
  SystemProfileProto_ComponentId_SCREEN_AI = 52,
  SystemProfileProto_ComponentId_SMART_DIM = 53,
  SystemProfileProto_ComponentId_SODA = 54,
  SystemProfileProto_ComponentId_SODA_DE_DE = 55,
  SystemProfileProto_ComponentId_SODA_EN_US = 56,
  SystemProfileProto_ComponentId_SODA_ES_ES = 57,
  SystemProfileProto_ComponentId_SODA_FR_FR = 58,
  SystemProfileProto_ComponentId_SODA_IT_IT = 59,
  SystemProfileProto_ComponentId_SODA_JA_JP = 60,
  SystemProfileProto_ComponentId_THIRD_PARTY_MODULE_LIST = 61,
  SystemProfileProto_ComponentId_TRUST_TOKEN_KEY_COMMITMENTS = 62,
  SystemProfileProto_ComponentId_THIRD_PARTY_COOKIE_DEPRECATION_METADATA = 63,
  SystemProfileProto_ComponentId_GROWTH_CAMPAIGNS = 64
};
bool SystemProfileProto_ComponentId_IsValid(int value);
constexpr SystemProfileProto_ComponentId SystemProfileProto_ComponentId_ComponentId_MIN = SystemProfileProto_ComponentId_UNKNOWN;
constexpr SystemProfileProto_ComponentId SystemProfileProto_ComponentId_ComponentId_MAX = SystemProfileProto_ComponentId_GROWTH_CAMPAIGNS;
constexpr int SystemProfileProto_ComponentId_ComponentId_ARRAYSIZE = SystemProfileProto_ComponentId_ComponentId_MAX + 1;

const std::string& SystemProfileProto_ComponentId_Name(SystemProfileProto_ComponentId value);
template<typename T>
inline const std::string& SystemProfileProto_ComponentId_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_ComponentId>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_ComponentId_Name.");
  return SystemProfileProto_ComponentId_Name(static_cast<SystemProfileProto_ComponentId>(enum_t_value));
}
bool SystemProfileProto_ComponentId_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_ComponentId* value);
enum SystemProfileProto_AppPackageNameAllowlistFilter : int {
  SystemProfileProto_AppPackageNameAllowlistFilter_SERVER_SIDE_FILTER_UNSPECIFIED = 0,
  SystemProfileProto_AppPackageNameAllowlistFilter_SERVER_SIDE_FILTER_REQUIRED = 1,
  SystemProfileProto_AppPackageNameAllowlistFilter_NO_SERVER_SIDE_FILTER_REQUIRED_FOR_SYSTEM_APPS = 3
};
bool SystemProfileProto_AppPackageNameAllowlistFilter_IsValid(int value);
constexpr SystemProfileProto_AppPackageNameAllowlistFilter SystemProfileProto_AppPackageNameAllowlistFilter_AppPackageNameAllowlistFilter_MIN = SystemProfileProto_AppPackageNameAllowlistFilter_SERVER_SIDE_FILTER_UNSPECIFIED;
constexpr SystemProfileProto_AppPackageNameAllowlistFilter SystemProfileProto_AppPackageNameAllowlistFilter_AppPackageNameAllowlistFilter_MAX = SystemProfileProto_AppPackageNameAllowlistFilter_NO_SERVER_SIDE_FILTER_REQUIRED_FOR_SYSTEM_APPS;
constexpr int SystemProfileProto_AppPackageNameAllowlistFilter_AppPackageNameAllowlistFilter_ARRAYSIZE = SystemProfileProto_AppPackageNameAllowlistFilter_AppPackageNameAllowlistFilter_MAX + 1;

const std::string& SystemProfileProto_AppPackageNameAllowlistFilter_Name(SystemProfileProto_AppPackageNameAllowlistFilter value);
template<typename T>
inline const std::string& SystemProfileProto_AppPackageNameAllowlistFilter_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_AppPackageNameAllowlistFilter>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_AppPackageNameAllowlistFilter_Name.");
  return SystemProfileProto_AppPackageNameAllowlistFilter_Name(static_cast<SystemProfileProto_AppPackageNameAllowlistFilter>(enum_t_value));
}
bool SystemProfileProto_AppPackageNameAllowlistFilter_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_AppPackageNameAllowlistFilter* value);
enum SystemProfileProto_ClientSideSamplingStatus : int {
  SystemProfileProto_ClientSideSamplingStatus_SAMPLING_UNKNOWN = 0,
  SystemProfileProto_ClientSideSamplingStatus_SAMPLING_APPLIED = 1,
  SystemProfileProto_ClientSideSamplingStatus_SAMPLING_NOT_APPLIED = 2
};
bool SystemProfileProto_ClientSideSamplingStatus_IsValid(int value);
constexpr SystemProfileProto_ClientSideSamplingStatus SystemProfileProto_ClientSideSamplingStatus_ClientSideSamplingStatus_MIN = SystemProfileProto_ClientSideSamplingStatus_SAMPLING_UNKNOWN;
constexpr SystemProfileProto_ClientSideSamplingStatus SystemProfileProto_ClientSideSamplingStatus_ClientSideSamplingStatus_MAX = SystemProfileProto_ClientSideSamplingStatus_SAMPLING_NOT_APPLIED;
constexpr int SystemProfileProto_ClientSideSamplingStatus_ClientSideSamplingStatus_ARRAYSIZE = SystemProfileProto_ClientSideSamplingStatus_ClientSideSamplingStatus_MAX + 1;

const std::string& SystemProfileProto_ClientSideSamplingStatus_Name(SystemProfileProto_ClientSideSamplingStatus value);
template<typename T>
inline const std::string& SystemProfileProto_ClientSideSamplingStatus_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_ClientSideSamplingStatus>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_ClientSideSamplingStatus_Name.");
  return SystemProfileProto_ClientSideSamplingStatus_Name(static_cast<SystemProfileProto_ClientSideSamplingStatus>(enum_t_value));
}
bool SystemProfileProto_ClientSideSamplingStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_ClientSideSamplingStatus* value);
enum SystemProfileProto_MetricsFilteringStatus : int {
  SystemProfileProto_MetricsFilteringStatus_METRICS_UNKNOWN = 0,
  SystemProfileProto_MetricsFilteringStatus_METRICS_ALL = 1,
  SystemProfileProto_MetricsFilteringStatus_METRICS_ONLY_CRITICAL = 2
};
bool SystemProfileProto_MetricsFilteringStatus_IsValid(int value);
constexpr SystemProfileProto_MetricsFilteringStatus SystemProfileProto_MetricsFilteringStatus_MetricsFilteringStatus_MIN = SystemProfileProto_MetricsFilteringStatus_METRICS_UNKNOWN;
constexpr SystemProfileProto_MetricsFilteringStatus SystemProfileProto_MetricsFilteringStatus_MetricsFilteringStatus_MAX = SystemProfileProto_MetricsFilteringStatus_METRICS_ONLY_CRITICAL;
constexpr int SystemProfileProto_MetricsFilteringStatus_MetricsFilteringStatus_ARRAYSIZE = SystemProfileProto_MetricsFilteringStatus_MetricsFilteringStatus_MAX + 1;

const std::string& SystemProfileProto_MetricsFilteringStatus_Name(SystemProfileProto_MetricsFilteringStatus value);
template<typename T>
inline const std::string& SystemProfileProto_MetricsFilteringStatus_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_MetricsFilteringStatus>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_MetricsFilteringStatus_Name.");
  return SystemProfileProto_MetricsFilteringStatus_Name(static_cast<SystemProfileProto_MetricsFilteringStatus>(enum_t_value));
}
bool SystemProfileProto_MetricsFilteringStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_MetricsFilteringStatus* value);
enum SystemProfileProto_InstallerPackage : int {
  SystemProfileProto_InstallerPackage_INSTALLER_PACKAGE_UNKNOWN = 0,
  SystemProfileProto_InstallerPackage_INSTALLER_PACKAGE_NONE = 1,
  SystemProfileProto_InstallerPackage_INSTALLER_PACKAGE_GOOGLE_PLAY_STORE = 2,
  SystemProfileProto_InstallerPackage_INSTALLER_PACKAGE_OTHER = 3
};
bool SystemProfileProto_InstallerPackage_IsValid(int value);
constexpr SystemProfileProto_InstallerPackage SystemProfileProto_InstallerPackage_InstallerPackage_MIN = SystemProfileProto_InstallerPackage_INSTALLER_PACKAGE_UNKNOWN;
constexpr SystemProfileProto_InstallerPackage SystemProfileProto_InstallerPackage_InstallerPackage_MAX = SystemProfileProto_InstallerPackage_INSTALLER_PACKAGE_OTHER;
constexpr int SystemProfileProto_InstallerPackage_InstallerPackage_ARRAYSIZE = SystemProfileProto_InstallerPackage_InstallerPackage_MAX + 1;

const std::string& SystemProfileProto_InstallerPackage_Name(SystemProfileProto_InstallerPackage value);
template<typename T>
inline const std::string& SystemProfileProto_InstallerPackage_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_InstallerPackage>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_InstallerPackage_Name.");
  return SystemProfileProto_InstallerPackage_Name(static_cast<SystemProfileProto_InstallerPackage>(enum_t_value));
}
bool SystemProfileProto_InstallerPackage_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_InstallerPackage* value);
enum SystemProfileProto_LTSChannel : int {
  SystemProfileProto_LTSChannel_LTS_CHANNEL_UNKNOWN = 0,
  SystemProfileProto_LTSChannel_LTS_CHANNEL_STABLE = 1,
  SystemProfileProto_LTSChannel_LTS_CHANNEL_LTC = 2,
  SystemProfileProto_LTSChannel_LTS_CHANNEL_LTS = 3
};
bool SystemProfileProto_LTSChannel_IsValid(int value);
constexpr SystemProfileProto_LTSChannel SystemProfileProto_LTSChannel_LTSChannel_MIN = SystemProfileProto_LTSChannel_LTS_CHANNEL_UNKNOWN;
constexpr SystemProfileProto_LTSChannel SystemProfileProto_LTSChannel_LTSChannel_MAX = SystemProfileProto_LTSChannel_LTS_CHANNEL_LTS;
constexpr int SystemProfileProto_LTSChannel_LTSChannel_ARRAYSIZE = SystemProfileProto_LTSChannel_LTSChannel_MAX + 1;

const std::string& SystemProfileProto_LTSChannel_Name(SystemProfileProto_LTSChannel value);
template<typename T>
inline const std::string& SystemProfileProto_LTSChannel_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SystemProfileProto_LTSChannel>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SystemProfileProto_LTSChannel_Name.");
  return SystemProfileProto_LTSChannel_Name(static_cast<SystemProfileProto_LTSChannel>(enum_t_value));
}
bool SystemProfileProto_LTSChannel_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SystemProfileProto_LTSChannel* value);
// ===================================================================

class SystemProfileProto_ClonedInstallInfo final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.ClonedInstallInfo) */ {
 public:
  inline SystemProfileProto_ClonedInstallInfo() : SystemProfileProto_ClonedInstallInfo(nullptr) {}
  ~SystemProfileProto_ClonedInstallInfo() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_ClonedInstallInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_ClonedInstallInfo(const SystemProfileProto_ClonedInstallInfo& from);
  SystemProfileProto_ClonedInstallInfo(SystemProfileProto_ClonedInstallInfo&& from) noexcept
    : SystemProfileProto_ClonedInstallInfo() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_ClonedInstallInfo& operator=(const SystemProfileProto_ClonedInstallInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_ClonedInstallInfo& operator=(SystemProfileProto_ClonedInstallInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_ClonedInstallInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_ClonedInstallInfo* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_ClonedInstallInfo*>(
               &_SystemProfileProto_ClonedInstallInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(SystemProfileProto_ClonedInstallInfo& a, SystemProfileProto_ClonedInstallInfo& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_ClonedInstallInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_ClonedInstallInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_ClonedInstallInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_ClonedInstallInfo>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_ClonedInstallInfo& from);
  void MergeFrom(const SystemProfileProto_ClonedInstallInfo& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_ClonedInstallInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.ClonedInstallInfo";
  }
  protected:
  explicit SystemProfileProto_ClonedInstallInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLastTimestampFieldNumber = 1,
    kClonedFromClientIdFieldNumber = 2,
    kFirstTimestampFieldNumber = 3,
    kCountFieldNumber = 4,
  };
  // optional int64 last_timestamp = 1;
  bool has_last_timestamp() const;
  private:
  bool _internal_has_last_timestamp() const;
  public:
  void clear_last_timestamp();
  int64_t last_timestamp() const;
  void set_last_timestamp(int64_t value);
  private:
  int64_t _internal_last_timestamp() const;
  void _internal_set_last_timestamp(int64_t value);
  public:

  // optional fixed64 cloned_from_client_id = 2;
  bool has_cloned_from_client_id() const;
  private:
  bool _internal_has_cloned_from_client_id() const;
  public:
  void clear_cloned_from_client_id();
  uint64_t cloned_from_client_id() const;
  void set_cloned_from_client_id(uint64_t value);
  private:
  uint64_t _internal_cloned_from_client_id() const;
  void _internal_set_cloned_from_client_id(uint64_t value);
  public:

  // optional int64 first_timestamp = 3;
  bool has_first_timestamp() const;
  private:
  bool _internal_has_first_timestamp() const;
  public:
  void clear_first_timestamp();
  int64_t first_timestamp() const;
  void set_first_timestamp(int64_t value);
  private:
  int64_t _internal_first_timestamp() const;
  void _internal_set_first_timestamp(int64_t value);
  public:

  // optional int32 count = 4;
  bool has_count() const;
  private:
  bool _internal_has_count() const;
  public:
  void clear_count();
  int32_t count() const;
  void set_count(int32_t value);
  private:
  int32_t _internal_count() const;
  void _internal_set_count(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.ClonedInstallInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int64_t last_timestamp_;
    uint64_t cloned_from_client_id_;
    int64_t first_timestamp_;
    int32_t count_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_OS_Arc final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.OS.Arc) */ {
 public:
  inline SystemProfileProto_OS_Arc() : SystemProfileProto_OS_Arc(nullptr) {}
  ~SystemProfileProto_OS_Arc() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_OS_Arc(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_OS_Arc(const SystemProfileProto_OS_Arc& from);
  SystemProfileProto_OS_Arc(SystemProfileProto_OS_Arc&& from) noexcept
    : SystemProfileProto_OS_Arc() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_OS_Arc& operator=(const SystemProfileProto_OS_Arc& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_OS_Arc& operator=(SystemProfileProto_OS_Arc&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_OS_Arc& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_OS_Arc* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_OS_Arc*>(
               &_SystemProfileProto_OS_Arc_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(SystemProfileProto_OS_Arc& a, SystemProfileProto_OS_Arc& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_OS_Arc* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_OS_Arc* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_OS_Arc* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_OS_Arc>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_OS_Arc& from);
  void MergeFrom(const SystemProfileProto_OS_Arc& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_OS_Arc* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.OS.Arc";
  }
  protected:
  explicit SystemProfileProto_OS_Arc(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kReleaseFieldNumber = 1,
  };
  // optional string release = 1;
  bool has_release() const;
  private:
  bool _internal_has_release() const;
  public:
  void clear_release();
  const std::string& release() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_release(ArgT0&& arg0, ArgT... args);
  std::string* mutable_release();
  PROTOBUF_NODISCARD std::string* release_release();
  void set_allocated_release(std::string* release);
  private:
  const std::string& _internal_release() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_release(const std::string& value);
  std::string* _internal_mutable_release();
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.OS.Arc)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr release_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_OS final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.OS) */ {
 public:
  inline SystemProfileProto_OS() : SystemProfileProto_OS(nullptr) {}
  ~SystemProfileProto_OS() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_OS(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_OS(const SystemProfileProto_OS& from);
  SystemProfileProto_OS(SystemProfileProto_OS&& from) noexcept
    : SystemProfileProto_OS() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_OS& operator=(const SystemProfileProto_OS& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_OS& operator=(SystemProfileProto_OS&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_OS& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_OS* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_OS*>(
               &_SystemProfileProto_OS_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(SystemProfileProto_OS& a, SystemProfileProto_OS& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_OS* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_OS* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_OS* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_OS>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_OS& from);
  void MergeFrom(const SystemProfileProto_OS& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_OS* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.OS";
  }
  protected:
  explicit SystemProfileProto_OS(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef SystemProfileProto_OS_Arc Arc;

  typedef SystemProfileProto_OS_DarkModeState DarkModeState;
  static constexpr DarkModeState UNKNOWN =
    SystemProfileProto_OS_DarkModeState_UNKNOWN;
  static constexpr DarkModeState DARK_MODE_SYSTEM =
    SystemProfileProto_OS_DarkModeState_DARK_MODE_SYSTEM;
  static constexpr DarkModeState DARK_MODE_APP =
    SystemProfileProto_OS_DarkModeState_DARK_MODE_APP;
  static constexpr DarkModeState LIGHT_MODE_SYSTEM =
    SystemProfileProto_OS_DarkModeState_LIGHT_MODE_SYSTEM;
  static constexpr DarkModeState LIGHT_MODE_APP =
    SystemProfileProto_OS_DarkModeState_LIGHT_MODE_APP;
  static inline bool DarkModeState_IsValid(int value) {
    return SystemProfileProto_OS_DarkModeState_IsValid(value);
  }
  static constexpr DarkModeState DarkModeState_MIN =
    SystemProfileProto_OS_DarkModeState_DarkModeState_MIN;
  static constexpr DarkModeState DarkModeState_MAX =
    SystemProfileProto_OS_DarkModeState_DarkModeState_MAX;
  static constexpr int DarkModeState_ARRAYSIZE =
    SystemProfileProto_OS_DarkModeState_DarkModeState_ARRAYSIZE;
  template<typename T>
  static inline const std::string& DarkModeState_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DarkModeState>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DarkModeState_Name.");
    return SystemProfileProto_OS_DarkModeState_Name(enum_t_value);
  }
  static inline bool DarkModeState_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DarkModeState* value) {
    return SystemProfileProto_OS_DarkModeState_Parse(name, value);
  }

  typedef SystemProfileProto_OS_XdgSessionType XdgSessionType;
  static constexpr XdgSessionType UNSET =
    SystemProfileProto_OS_XdgSessionType_UNSET;
  static constexpr XdgSessionType OTHER_SESSION_TYPE =
    SystemProfileProto_OS_XdgSessionType_OTHER_SESSION_TYPE;
  static constexpr XdgSessionType UNSPECIFIED =
    SystemProfileProto_OS_XdgSessionType_UNSPECIFIED;
  static constexpr XdgSessionType TTY =
    SystemProfileProto_OS_XdgSessionType_TTY;
  static constexpr XdgSessionType X11 =
    SystemProfileProto_OS_XdgSessionType_X11;
  static constexpr XdgSessionType WAYLAND =
    SystemProfileProto_OS_XdgSessionType_WAYLAND;
  static constexpr XdgSessionType MIR =
    SystemProfileProto_OS_XdgSessionType_MIR;
  static inline bool XdgSessionType_IsValid(int value) {
    return SystemProfileProto_OS_XdgSessionType_IsValid(value);
  }
  static constexpr XdgSessionType XdgSessionType_MIN =
    SystemProfileProto_OS_XdgSessionType_XdgSessionType_MIN;
  static constexpr XdgSessionType XdgSessionType_MAX =
    SystemProfileProto_OS_XdgSessionType_XdgSessionType_MAX;
  static constexpr int XdgSessionType_ARRAYSIZE =
    SystemProfileProto_OS_XdgSessionType_XdgSessionType_ARRAYSIZE;
  template<typename T>
  static inline const std::string& XdgSessionType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, XdgSessionType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function XdgSessionType_Name.");
    return SystemProfileProto_OS_XdgSessionType_Name(enum_t_value);
  }
  static inline bool XdgSessionType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      XdgSessionType* value) {
    return SystemProfileProto_OS_XdgSessionType_Parse(name, value);
  }

  typedef SystemProfileProto_OS_XdgCurrentDesktop XdgCurrentDesktop;
  static constexpr XdgCurrentDesktop OTHER =
    SystemProfileProto_OS_XdgCurrentDesktop_OTHER;
  static constexpr XdgCurrentDesktop CINNAMON =
    SystemProfileProto_OS_XdgCurrentDesktop_CINNAMON;
  static constexpr XdgCurrentDesktop DEEPIN =
    SystemProfileProto_OS_XdgCurrentDesktop_DEEPIN;
  static constexpr XdgCurrentDesktop GNOME =
    SystemProfileProto_OS_XdgCurrentDesktop_GNOME;
  static constexpr XdgCurrentDesktop KDE =
    SystemProfileProto_OS_XdgCurrentDesktop_KDE;
  static constexpr XdgCurrentDesktop PANTHEON =
    SystemProfileProto_OS_XdgCurrentDesktop_PANTHEON;
  static constexpr XdgCurrentDesktop UKUI =
    SystemProfileProto_OS_XdgCurrentDesktop_UKUI;
  static constexpr XdgCurrentDesktop UNITY =
    SystemProfileProto_OS_XdgCurrentDesktop_UNITY;
  static constexpr XdgCurrentDesktop XFCE =
    SystemProfileProto_OS_XdgCurrentDesktop_XFCE;
  static constexpr XdgCurrentDesktop LXQT =
    SystemProfileProto_OS_XdgCurrentDesktop_LXQT;
  static inline bool XdgCurrentDesktop_IsValid(int value) {
    return SystemProfileProto_OS_XdgCurrentDesktop_IsValid(value);
  }
  static constexpr XdgCurrentDesktop XdgCurrentDesktop_MIN =
    SystemProfileProto_OS_XdgCurrentDesktop_XdgCurrentDesktop_MIN;
  static constexpr XdgCurrentDesktop XdgCurrentDesktop_MAX =
    SystemProfileProto_OS_XdgCurrentDesktop_XdgCurrentDesktop_MAX;
  static constexpr int XdgCurrentDesktop_ARRAYSIZE =
    SystemProfileProto_OS_XdgCurrentDesktop_XdgCurrentDesktop_ARRAYSIZE;
  template<typename T>
  static inline const std::string& XdgCurrentDesktop_Name(T enum_t_value) {
    static_assert(::std::is_same<T, XdgCurrentDesktop>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function XdgCurrentDesktop_Name.");
    return SystemProfileProto_OS_XdgCurrentDesktop_Name(enum_t_value);
  }
  static inline bool XdgCurrentDesktop_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      XdgCurrentDesktop* value) {
    return SystemProfileProto_OS_XdgCurrentDesktop_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kVersionFieldNumber = 2,
    kBuildFingerprintFieldNumber = 3,
    kBuildNumberFieldNumber = 5,
    kKernelVersionFieldNumber = 6,
    kArcFieldNumber = 7,
    kDEPRECATEDIsJailbrokenFieldNumber = 4,
    kDarkModeStateFieldNumber = 8,
    kXdgSessionTypeFieldNumber = 9,
    kXdgCurrentDesktopFieldNumber = 10,
  };
  // optional string name = 1;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // optional string version = 2;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  const std::string& version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_version();
  PROTOBUF_NODISCARD std::string* release_version();
  void set_allocated_version(std::string* version);
  private:
  const std::string& _internal_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
  std::string* _internal_mutable_version();
  public:

  // optional string build_fingerprint = 3;
  bool has_build_fingerprint() const;
  private:
  bool _internal_has_build_fingerprint() const;
  public:
  void clear_build_fingerprint();
  const std::string& build_fingerprint() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_build_fingerprint(ArgT0&& arg0, ArgT... args);
  std::string* mutable_build_fingerprint();
  PROTOBUF_NODISCARD std::string* release_build_fingerprint();
  void set_allocated_build_fingerprint(std::string* build_fingerprint);
  private:
  const std::string& _internal_build_fingerprint() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_build_fingerprint(const std::string& value);
  std::string* _internal_mutable_build_fingerprint();
  public:

  // optional string build_number = 5;
  bool has_build_number() const;
  private:
  bool _internal_has_build_number() const;
  public:
  void clear_build_number();
  const std::string& build_number() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_build_number(ArgT0&& arg0, ArgT... args);
  std::string* mutable_build_number();
  PROTOBUF_NODISCARD std::string* release_build_number();
  void set_allocated_build_number(std::string* build_number);
  private:
  const std::string& _internal_build_number() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_build_number(const std::string& value);
  std::string* _internal_mutable_build_number();
  public:

  // optional string kernel_version = 6;
  bool has_kernel_version() const;
  private:
  bool _internal_has_kernel_version() const;
  public:
  void clear_kernel_version();
  const std::string& kernel_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_kernel_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_kernel_version();
  PROTOBUF_NODISCARD std::string* release_kernel_version();
  void set_allocated_kernel_version(std::string* kernel_version);
  private:
  const std::string& _internal_kernel_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_kernel_version(const std::string& value);
  std::string* _internal_mutable_kernel_version();
  public:

  // optional .metrics.SystemProfileProto.OS.Arc arc = 7;
  bool has_arc() const;
  private:
  bool _internal_has_arc() const;
  public:
  void clear_arc();
  const ::metrics::SystemProfileProto_OS_Arc& arc() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_OS_Arc* release_arc();
  ::metrics::SystemProfileProto_OS_Arc* mutable_arc();
  void set_allocated_arc(::metrics::SystemProfileProto_OS_Arc* arc);
  private:
  const ::metrics::SystemProfileProto_OS_Arc& _internal_arc() const;
  ::metrics::SystemProfileProto_OS_Arc* _internal_mutable_arc();
  public:
  void unsafe_arena_set_allocated_arc(
      ::metrics::SystemProfileProto_OS_Arc* arc);
  ::metrics::SystemProfileProto_OS_Arc* unsafe_arena_release_arc();

  // optional bool DEPRECATED_is_jailbroken = 4 [deprecated = true];
  PROTOBUF_DEPRECATED bool has_deprecated_is_jailbroken() const;
  private:
  bool _internal_has_deprecated_is_jailbroken() const;
  public:
  PROTOBUF_DEPRECATED void clear_deprecated_is_jailbroken();
  PROTOBUF_DEPRECATED bool deprecated_is_jailbroken() const;
  PROTOBUF_DEPRECATED void set_deprecated_is_jailbroken(bool value);
  private:
  bool _internal_deprecated_is_jailbroken() const;
  void _internal_set_deprecated_is_jailbroken(bool value);
  public:

  // optional .metrics.SystemProfileProto.OS.DarkModeState dark_mode_state = 8 [default = UNKNOWN];
  bool has_dark_mode_state() const;
  private:
  bool _internal_has_dark_mode_state() const;
  public:
  void clear_dark_mode_state();
  ::metrics::SystemProfileProto_OS_DarkModeState dark_mode_state() const;
  void set_dark_mode_state(::metrics::SystemProfileProto_OS_DarkModeState value);
  private:
  ::metrics::SystemProfileProto_OS_DarkModeState _internal_dark_mode_state() const;
  void _internal_set_dark_mode_state(::metrics::SystemProfileProto_OS_DarkModeState value);
  public:

  // optional .metrics.SystemProfileProto.OS.XdgSessionType xdg_session_type = 9;
  bool has_xdg_session_type() const;
  private:
  bool _internal_has_xdg_session_type() const;
  public:
  void clear_xdg_session_type();
  ::metrics::SystemProfileProto_OS_XdgSessionType xdg_session_type() const;
  void set_xdg_session_type(::metrics::SystemProfileProto_OS_XdgSessionType value);
  private:
  ::metrics::SystemProfileProto_OS_XdgSessionType _internal_xdg_session_type() const;
  void _internal_set_xdg_session_type(::metrics::SystemProfileProto_OS_XdgSessionType value);
  public:

  // optional .metrics.SystemProfileProto.OS.XdgCurrentDesktop xdg_current_desktop = 10;
  bool has_xdg_current_desktop() const;
  private:
  bool _internal_has_xdg_current_desktop() const;
  public:
  void clear_xdg_current_desktop();
  ::metrics::SystemProfileProto_OS_XdgCurrentDesktop xdg_current_desktop() const;
  void set_xdg_current_desktop(::metrics::SystemProfileProto_OS_XdgCurrentDesktop value);
  private:
  ::metrics::SystemProfileProto_OS_XdgCurrentDesktop _internal_xdg_current_desktop() const;
  void _internal_set_xdg_current_desktop(::metrics::SystemProfileProto_OS_XdgCurrentDesktop value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.OS)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr build_fingerprint_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr build_number_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr kernel_version_;
    ::metrics::SystemProfileProto_OS_Arc* arc_;
    bool deprecated_is_jailbroken_;
    int dark_mode_state_;
    int xdg_session_type_;
    int xdg_current_desktop_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_Hardware_CPU final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.Hardware.CPU) */ {
 public:
  inline SystemProfileProto_Hardware_CPU() : SystemProfileProto_Hardware_CPU(nullptr) {}
  ~SystemProfileProto_Hardware_CPU() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_Hardware_CPU(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_Hardware_CPU(const SystemProfileProto_Hardware_CPU& from);
  SystemProfileProto_Hardware_CPU(SystemProfileProto_Hardware_CPU&& from) noexcept
    : SystemProfileProto_Hardware_CPU() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_Hardware_CPU& operator=(const SystemProfileProto_Hardware_CPU& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_Hardware_CPU& operator=(SystemProfileProto_Hardware_CPU&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_Hardware_CPU& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_Hardware_CPU* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_Hardware_CPU*>(
               &_SystemProfileProto_Hardware_CPU_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(SystemProfileProto_Hardware_CPU& a, SystemProfileProto_Hardware_CPU& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_Hardware_CPU* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_Hardware_CPU* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_Hardware_CPU* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_Hardware_CPU>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_Hardware_CPU& from);
  void MergeFrom(const SystemProfileProto_Hardware_CPU& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_Hardware_CPU* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.Hardware.CPU";
  }
  protected:
  explicit SystemProfileProto_Hardware_CPU(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kVendorNameFieldNumber = 1,
    kSignatureFieldNumber = 2,
    kNumCoresFieldNumber = 3,
    kIsHypervisorFieldNumber = 4,
  };
  // optional string vendor_name = 1;
  bool has_vendor_name() const;
  private:
  bool _internal_has_vendor_name() const;
  public:
  void clear_vendor_name();
  const std::string& vendor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_vendor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_vendor_name();
  PROTOBUF_NODISCARD std::string* release_vendor_name();
  void set_allocated_vendor_name(std::string* vendor_name);
  private:
  const std::string& _internal_vendor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_vendor_name(const std::string& value);
  std::string* _internal_mutable_vendor_name();
  public:

  // optional uint32 signature = 2;
  bool has_signature() const;
  private:
  bool _internal_has_signature() const;
  public:
  void clear_signature();
  uint32_t signature() const;
  void set_signature(uint32_t value);
  private:
  uint32_t _internal_signature() const;
  void _internal_set_signature(uint32_t value);
  public:

  // optional uint32 num_cores = 3;
  bool has_num_cores() const;
  private:
  bool _internal_has_num_cores() const;
  public:
  void clear_num_cores();
  uint32_t num_cores() const;
  void set_num_cores(uint32_t value);
  private:
  uint32_t _internal_num_cores() const;
  void _internal_set_num_cores(uint32_t value);
  public:

  // optional bool is_hypervisor = 4;
  bool has_is_hypervisor() const;
  private:
  bool _internal_has_is_hypervisor() const;
  public:
  void clear_is_hypervisor();
  bool is_hypervisor() const;
  void set_is_hypervisor(bool value);
  private:
  bool _internal_is_hypervisor() const;
  void _internal_set_is_hypervisor(bool value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.Hardware.CPU)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vendor_name_;
    uint32_t signature_;
    uint32_t num_cores_;
    bool is_hypervisor_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_Hardware_Motherboard final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.Hardware.Motherboard) */ {
 public:
  inline SystemProfileProto_Hardware_Motherboard() : SystemProfileProto_Hardware_Motherboard(nullptr) {}
  ~SystemProfileProto_Hardware_Motherboard() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_Hardware_Motherboard(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_Hardware_Motherboard(const SystemProfileProto_Hardware_Motherboard& from);
  SystemProfileProto_Hardware_Motherboard(SystemProfileProto_Hardware_Motherboard&& from) noexcept
    : SystemProfileProto_Hardware_Motherboard() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_Hardware_Motherboard& operator=(const SystemProfileProto_Hardware_Motherboard& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_Hardware_Motherboard& operator=(SystemProfileProto_Hardware_Motherboard&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_Hardware_Motherboard& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_Hardware_Motherboard* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_Hardware_Motherboard*>(
               &_SystemProfileProto_Hardware_Motherboard_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(SystemProfileProto_Hardware_Motherboard& a, SystemProfileProto_Hardware_Motherboard& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_Hardware_Motherboard* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_Hardware_Motherboard* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_Hardware_Motherboard* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_Hardware_Motherboard>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_Hardware_Motherboard& from);
  void MergeFrom(const SystemProfileProto_Hardware_Motherboard& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_Hardware_Motherboard* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.Hardware.Motherboard";
  }
  protected:
  explicit SystemProfileProto_Hardware_Motherboard(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kManufacturerFieldNumber = 1,
    kModelFieldNumber = 2,
    kBiosManufacturerFieldNumber = 3,
    kBiosVersionFieldNumber = 4,
    kBiosTypeFieldNumber = 5,
  };
  // optional string manufacturer = 1;
  bool has_manufacturer() const;
  private:
  bool _internal_has_manufacturer() const;
  public:
  void clear_manufacturer();
  const std::string& manufacturer() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_manufacturer(ArgT0&& arg0, ArgT... args);
  std::string* mutable_manufacturer();
  PROTOBUF_NODISCARD std::string* release_manufacturer();
  void set_allocated_manufacturer(std::string* manufacturer);
  private:
  const std::string& _internal_manufacturer() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_manufacturer(const std::string& value);
  std::string* _internal_mutable_manufacturer();
  public:

  // optional string model = 2;
  bool has_model() const;
  private:
  bool _internal_has_model() const;
  public:
  void clear_model();
  const std::string& model() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_model(ArgT0&& arg0, ArgT... args);
  std::string* mutable_model();
  PROTOBUF_NODISCARD std::string* release_model();
  void set_allocated_model(std::string* model);
  private:
  const std::string& _internal_model() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model(const std::string& value);
  std::string* _internal_mutable_model();
  public:

  // optional string bios_manufacturer = 3;
  bool has_bios_manufacturer() const;
  private:
  bool _internal_has_bios_manufacturer() const;
  public:
  void clear_bios_manufacturer();
  const std::string& bios_manufacturer() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_bios_manufacturer(ArgT0&& arg0, ArgT... args);
  std::string* mutable_bios_manufacturer();
  PROTOBUF_NODISCARD std::string* release_bios_manufacturer();
  void set_allocated_bios_manufacturer(std::string* bios_manufacturer);
  private:
  const std::string& _internal_bios_manufacturer() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bios_manufacturer(const std::string& value);
  std::string* _internal_mutable_bios_manufacturer();
  public:

  // optional string bios_version = 4;
  bool has_bios_version() const;
  private:
  bool _internal_has_bios_version() const;
  public:
  void clear_bios_version();
  const std::string& bios_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_bios_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_bios_version();
  PROTOBUF_NODISCARD std::string* release_bios_version();
  void set_allocated_bios_version(std::string* bios_version);
  private:
  const std::string& _internal_bios_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bios_version(const std::string& value);
  std::string* _internal_mutable_bios_version();
  public:

  // optional .metrics.SystemProfileProto.Hardware.BiosType bios_type = 5;
  bool has_bios_type() const;
  private:
  bool _internal_has_bios_type() const;
  public:
  void clear_bios_type();
  ::metrics::SystemProfileProto_Hardware_BiosType bios_type() const;
  void set_bios_type(::metrics::SystemProfileProto_Hardware_BiosType value);
  private:
  ::metrics::SystemProfileProto_Hardware_BiosType _internal_bios_type() const;
  void _internal_set_bios_type(::metrics::SystemProfileProto_Hardware_BiosType value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.Hardware.Motherboard)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manufacturer_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bios_manufacturer_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bios_version_;
    int bios_type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_Hardware_Graphics final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.Hardware.Graphics) */ {
 public:
  inline SystemProfileProto_Hardware_Graphics() : SystemProfileProto_Hardware_Graphics(nullptr) {}
  ~SystemProfileProto_Hardware_Graphics() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_Hardware_Graphics(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_Hardware_Graphics(const SystemProfileProto_Hardware_Graphics& from);
  SystemProfileProto_Hardware_Graphics(SystemProfileProto_Hardware_Graphics&& from) noexcept
    : SystemProfileProto_Hardware_Graphics() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_Hardware_Graphics& operator=(const SystemProfileProto_Hardware_Graphics& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_Hardware_Graphics& operator=(SystemProfileProto_Hardware_Graphics&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_Hardware_Graphics& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_Hardware_Graphics* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_Hardware_Graphics*>(
               &_SystemProfileProto_Hardware_Graphics_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(SystemProfileProto_Hardware_Graphics& a, SystemProfileProto_Hardware_Graphics& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_Hardware_Graphics* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_Hardware_Graphics* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_Hardware_Graphics* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_Hardware_Graphics>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_Hardware_Graphics& from);
  void MergeFrom(const SystemProfileProto_Hardware_Graphics& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_Hardware_Graphics* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.Hardware.Graphics";
  }
  protected:
  explicit SystemProfileProto_Hardware_Graphics(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDriverVersionFieldNumber = 3,
    kGlVendorFieldNumber = 6,
    kGlRendererFieldNumber = 7,
    kVendorIdFieldNumber = 1,
    kDeviceIdFieldNumber = 2,
  };
  // optional string driver_version = 3;
  bool has_driver_version() const;
  private:
  bool _internal_has_driver_version() const;
  public:
  void clear_driver_version();
  const std::string& driver_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_driver_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_driver_version();
  PROTOBUF_NODISCARD std::string* release_driver_version();
  void set_allocated_driver_version(std::string* driver_version);
  private:
  const std::string& _internal_driver_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_driver_version(const std::string& value);
  std::string* _internal_mutable_driver_version();
  public:

  // optional string gl_vendor = 6;
  bool has_gl_vendor() const;
  private:
  bool _internal_has_gl_vendor() const;
  public:
  void clear_gl_vendor();
  const std::string& gl_vendor() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_gl_vendor(ArgT0&& arg0, ArgT... args);
  std::string* mutable_gl_vendor();
  PROTOBUF_NODISCARD std::string* release_gl_vendor();
  void set_allocated_gl_vendor(std::string* gl_vendor);
  private:
  const std::string& _internal_gl_vendor() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_gl_vendor(const std::string& value);
  std::string* _internal_mutable_gl_vendor();
  public:

  // optional string gl_renderer = 7;
  bool has_gl_renderer() const;
  private:
  bool _internal_has_gl_renderer() const;
  public:
  void clear_gl_renderer();
  const std::string& gl_renderer() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_gl_renderer(ArgT0&& arg0, ArgT... args);
  std::string* mutable_gl_renderer();
  PROTOBUF_NODISCARD std::string* release_gl_renderer();
  void set_allocated_gl_renderer(std::string* gl_renderer);
  private:
  const std::string& _internal_gl_renderer() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_gl_renderer(const std::string& value);
  std::string* _internal_mutable_gl_renderer();
  public:

  // optional uint32 vendor_id = 1;
  bool has_vendor_id() const;
  private:
  bool _internal_has_vendor_id() const;
  public:
  void clear_vendor_id();
  uint32_t vendor_id() const;
  void set_vendor_id(uint32_t value);
  private:
  uint32_t _internal_vendor_id() const;
  void _internal_set_vendor_id(uint32_t value);
  public:

  // optional uint32 device_id = 2;
  bool has_device_id() const;
  private:
  bool _internal_has_device_id() const;
  public:
  void clear_device_id();
  uint32_t device_id() const;
  void set_device_id(uint32_t value);
  private:
  uint32_t _internal_device_id() const;
  void _internal_set_device_id(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.Hardware.Graphics)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr driver_version_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gl_vendor_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gl_renderer_;
    uint32_t vendor_id_;
    uint32_t device_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_Hardware_InternalStorageDevice final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.Hardware.InternalStorageDevice) */ {
 public:
  inline SystemProfileProto_Hardware_InternalStorageDevice() : SystemProfileProto_Hardware_InternalStorageDevice(nullptr) {}
  ~SystemProfileProto_Hardware_InternalStorageDevice() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_Hardware_InternalStorageDevice(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_Hardware_InternalStorageDevice(const SystemProfileProto_Hardware_InternalStorageDevice& from);
  SystemProfileProto_Hardware_InternalStorageDevice(SystemProfileProto_Hardware_InternalStorageDevice&& from) noexcept
    : SystemProfileProto_Hardware_InternalStorageDevice() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_Hardware_InternalStorageDevice& operator=(const SystemProfileProto_Hardware_InternalStorageDevice& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_Hardware_InternalStorageDevice& operator=(SystemProfileProto_Hardware_InternalStorageDevice&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_Hardware_InternalStorageDevice& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_Hardware_InternalStorageDevice* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_Hardware_InternalStorageDevice*>(
               &_SystemProfileProto_Hardware_InternalStorageDevice_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(SystemProfileProto_Hardware_InternalStorageDevice& a, SystemProfileProto_Hardware_InternalStorageDevice& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_Hardware_InternalStorageDevice* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_Hardware_InternalStorageDevice* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_Hardware_InternalStorageDevice* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_Hardware_InternalStorageDevice>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_Hardware_InternalStorageDevice& from);
  void MergeFrom(const SystemProfileProto_Hardware_InternalStorageDevice& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_Hardware_InternalStorageDevice* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.Hardware.InternalStorageDevice";
  }
  protected:
  explicit SystemProfileProto_Hardware_InternalStorageDevice(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef SystemProfileProto_Hardware_InternalStorageDevice_Type Type;
  static constexpr Type TYPE_UNKNOWN =
    SystemProfileProto_Hardware_InternalStorageDevice_Type_TYPE_UNKNOWN;
  static constexpr Type TYPE_EMMC =
    SystemProfileProto_Hardware_InternalStorageDevice_Type_TYPE_EMMC;
  static constexpr Type TYPE_NVME =
    SystemProfileProto_Hardware_InternalStorageDevice_Type_TYPE_NVME;
  static constexpr Type TYPE_UFS =
    SystemProfileProto_Hardware_InternalStorageDevice_Type_TYPE_UFS;
  static constexpr Type TYPE_SD_EXPRESS_INTERNAL =
    SystemProfileProto_Hardware_InternalStorageDevice_Type_TYPE_SD_EXPRESS_INTERNAL;
  static inline bool Type_IsValid(int value) {
    return SystemProfileProto_Hardware_InternalStorageDevice_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    SystemProfileProto_Hardware_InternalStorageDevice_Type_Type_MIN;
  static constexpr Type Type_MAX =
    SystemProfileProto_Hardware_InternalStorageDevice_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    SystemProfileProto_Hardware_InternalStorageDevice_Type_Type_ARRAYSIZE;
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return SystemProfileProto_Hardware_InternalStorageDevice_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return SystemProfileProto_Hardware_InternalStorageDevice_Type_Parse(name, value);
  }

  typedef SystemProfileProto_Hardware_InternalStorageDevice_Purpose Purpose;
  static constexpr Purpose PURPOSE_UNKNOWN =
    SystemProfileProto_Hardware_InternalStorageDevice_Purpose_PURPOSE_UNKNOWN;
  static constexpr Purpose PURPOSE_BOOT =
    SystemProfileProto_Hardware_InternalStorageDevice_Purpose_PURPOSE_BOOT;
  static constexpr Purpose PURPOSE_SWAP =
    SystemProfileProto_Hardware_InternalStorageDevice_Purpose_PURPOSE_SWAP;
  static constexpr Purpose PURPOSE_BOOT_SWAP =
    SystemProfileProto_Hardware_InternalStorageDevice_Purpose_PURPOSE_BOOT_SWAP;
  static inline bool Purpose_IsValid(int value) {
    return SystemProfileProto_Hardware_InternalStorageDevice_Purpose_IsValid(value);
  }
  static constexpr Purpose Purpose_MIN =
    SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Purpose_MIN;
  static constexpr Purpose Purpose_MAX =
    SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Purpose_MAX;
  static constexpr int Purpose_ARRAYSIZE =
    SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Purpose_ARRAYSIZE;
  template<typename T>
  static inline const std::string& Purpose_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Purpose>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Purpose_Name.");
    return SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Name(enum_t_value);
  }
  static inline bool Purpose_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Purpose* value) {
    return SystemProfileProto_Hardware_InternalStorageDevice_Purpose_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kModelFieldNumber = 4,
    kProductIdFieldNumber = 2,
    kVendorIdFieldNumber = 1,
    kRevisionFieldNumber = 3,
    kFirmwareVersionFieldNumber = 6,
    kSizeMbFieldNumber = 5,
    kTypeFieldNumber = 7,
    kPurposeFieldNumber = 8,
  };
  // optional string model = 4;
  bool has_model() const;
  private:
  bool _internal_has_model() const;
  public:
  void clear_model();
  const std::string& model() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_model(ArgT0&& arg0, ArgT... args);
  std::string* mutable_model();
  PROTOBUF_NODISCARD std::string* release_model();
  void set_allocated_model(std::string* model);
  private:
  const std::string& _internal_model() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model(const std::string& value);
  std::string* _internal_mutable_model();
  public:

  // optional uint64 product_id = 2;
  bool has_product_id() const;
  private:
  bool _internal_has_product_id() const;
  public:
  void clear_product_id();
  uint64_t product_id() const;
  void set_product_id(uint64_t value);
  private:
  uint64_t _internal_product_id() const;
  void _internal_set_product_id(uint64_t value);
  public:

  // optional uint32 vendor_id = 1;
  bool has_vendor_id() const;
  private:
  bool _internal_has_vendor_id() const;
  public:
  void clear_vendor_id();
  uint32_t vendor_id() const;
  void set_vendor_id(uint32_t value);
  private:
  uint32_t _internal_vendor_id() const;
  void _internal_set_vendor_id(uint32_t value);
  public:

  // optional uint32 revision = 3;
  bool has_revision() const;
  private:
  bool _internal_has_revision() const;
  public:
  void clear_revision();
  uint32_t revision() const;
  void set_revision(uint32_t value);
  private:
  uint32_t _internal_revision() const;
  void _internal_set_revision(uint32_t value);
  public:

  // optional uint64 firmware_version = 6;
  bool has_firmware_version() const;
  private:
  bool _internal_has_firmware_version() const;
  public:
  void clear_firmware_version();
  uint64_t firmware_version() const;
  void set_firmware_version(uint64_t value);
  private:
  uint64_t _internal_firmware_version() const;
  void _internal_set_firmware_version(uint64_t value);
  public:

  // optional uint32 size_mb = 5;
  bool has_size_mb() const;
  private:
  bool _internal_has_size_mb() const;
  public:
  void clear_size_mb();
  uint32_t size_mb() const;
  void set_size_mb(uint32_t value);
  private:
  uint32_t _internal_size_mb() const;
  void _internal_set_size_mb(uint32_t value);
  public:

  // optional .metrics.SystemProfileProto.Hardware.InternalStorageDevice.Type type = 7;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Type type() const;
  void set_type(::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Type value);
  private:
  ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Type _internal_type() const;
  void _internal_set_type(::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Type value);
  public:

  // optional .metrics.SystemProfileProto.Hardware.InternalStorageDevice.Purpose purpose = 8;
  bool has_purpose() const;
  private:
  bool _internal_has_purpose() const;
  public:
  void clear_purpose();
  ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Purpose purpose() const;
  void set_purpose(::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Purpose value);
  private:
  ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Purpose _internal_purpose() const;
  void _internal_set_purpose(::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Purpose value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.Hardware.InternalStorageDevice)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_;
    uint64_t product_id_;
    uint32_t vendor_id_;
    uint32_t revision_;
    uint64_t firmware_version_;
    uint32_t size_mb_;
    int type_;
    int purpose_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_Hardware_Drive final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.Hardware.Drive) */ {
 public:
  inline SystemProfileProto_Hardware_Drive() : SystemProfileProto_Hardware_Drive(nullptr) {}
  ~SystemProfileProto_Hardware_Drive() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_Hardware_Drive(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_Hardware_Drive(const SystemProfileProto_Hardware_Drive& from);
  SystemProfileProto_Hardware_Drive(SystemProfileProto_Hardware_Drive&& from) noexcept
    : SystemProfileProto_Hardware_Drive() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_Hardware_Drive& operator=(const SystemProfileProto_Hardware_Drive& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_Hardware_Drive& operator=(SystemProfileProto_Hardware_Drive&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_Hardware_Drive& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_Hardware_Drive* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_Hardware_Drive*>(
               &_SystemProfileProto_Hardware_Drive_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(SystemProfileProto_Hardware_Drive& a, SystemProfileProto_Hardware_Drive& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_Hardware_Drive* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_Hardware_Drive* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_Hardware_Drive* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_Hardware_Drive>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_Hardware_Drive& from);
  void MergeFrom(const SystemProfileProto_Hardware_Drive& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_Hardware_Drive* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.Hardware.Drive";
  }
  protected:
  explicit SystemProfileProto_Hardware_Drive(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kHasSeekPenaltyFieldNumber = 1,
  };
  // optional bool has_seek_penalty = 1;
  bool has_has_seek_penalty() const;
  private:
  bool _internal_has_has_seek_penalty() const;
  public:
  void clear_has_seek_penalty();
  bool has_seek_penalty() const;
  void set_has_seek_penalty(bool value);
  private:
  bool _internal_has_seek_penalty() const;
  void _internal_set_has_seek_penalty(bool value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.Hardware.Drive)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    bool has_seek_penalty_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_Hardware final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.Hardware) */ {
 public:
  inline SystemProfileProto_Hardware() : SystemProfileProto_Hardware(nullptr) {}
  ~SystemProfileProto_Hardware() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_Hardware(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_Hardware(const SystemProfileProto_Hardware& from);
  SystemProfileProto_Hardware(SystemProfileProto_Hardware&& from) noexcept
    : SystemProfileProto_Hardware() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_Hardware& operator=(const SystemProfileProto_Hardware& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_Hardware& operator=(SystemProfileProto_Hardware&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_Hardware& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_Hardware* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_Hardware*>(
               &_SystemProfileProto_Hardware_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(SystemProfileProto_Hardware& a, SystemProfileProto_Hardware& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_Hardware* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_Hardware* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_Hardware* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_Hardware>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_Hardware& from);
  void MergeFrom(const SystemProfileProto_Hardware& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_Hardware* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.Hardware";
  }
  protected:
  explicit SystemProfileProto_Hardware(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef SystemProfileProto_Hardware_CPU CPU;
  typedef SystemProfileProto_Hardware_Motherboard Motherboard;
  typedef SystemProfileProto_Hardware_Graphics Graphics;
  typedef SystemProfileProto_Hardware_InternalStorageDevice InternalStorageDevice;
  typedef SystemProfileProto_Hardware_Drive Drive;

  typedef SystemProfileProto_Hardware_FormFactor FormFactor;
  static constexpr FormFactor FORM_FACTOR_UNKNOWN =
    SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_UNKNOWN;
  static constexpr FormFactor FORM_FACTOR_DESKTOP =
    SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_DESKTOP;
  static constexpr FormFactor FORM_FACTOR_PHONE =
    SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_PHONE;
  static constexpr FormFactor FORM_FACTOR_TABLET =
    SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_TABLET;
  static constexpr FormFactor FORM_FACTOR_TV =
    SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_TV;
  static constexpr FormFactor FORM_FACTOR_MEET_DEVICE =
    SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_MEET_DEVICE;
  static constexpr FormFactor FORM_FACTOR_AUTOMOTIVE =
    SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_AUTOMOTIVE;
  static constexpr FormFactor FORM_FACTOR_FOLDABLE =
    SystemProfileProto_Hardware_FormFactor_FORM_FACTOR_FOLDABLE;
  static inline bool FormFactor_IsValid(int value) {
    return SystemProfileProto_Hardware_FormFactor_IsValid(value);
  }
  static constexpr FormFactor FormFactor_MIN =
    SystemProfileProto_Hardware_FormFactor_FormFactor_MIN;
  static constexpr FormFactor FormFactor_MAX =
    SystemProfileProto_Hardware_FormFactor_FormFactor_MAX;
  static constexpr int FormFactor_ARRAYSIZE =
    SystemProfileProto_Hardware_FormFactor_FormFactor_ARRAYSIZE;
  template<typename T>
  static inline const std::string& FormFactor_Name(T enum_t_value) {
    static_assert(::std::is_same<T, FormFactor>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function FormFactor_Name.");
    return SystemProfileProto_Hardware_FormFactor_Name(enum_t_value);
  }
  static inline bool FormFactor_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      FormFactor* value) {
    return SystemProfileProto_Hardware_FormFactor_Parse(name, value);
  }

  typedef SystemProfileProto_Hardware_BiosType BiosType;
  static constexpr BiosType BIOS_TYPE_UNKNOWN =
    SystemProfileProto_Hardware_BiosType_BIOS_TYPE_UNKNOWN;
  static constexpr BiosType BIOS_TYPE_LEGACY =
    SystemProfileProto_Hardware_BiosType_BIOS_TYPE_LEGACY;
  static constexpr BiosType BIOS_TYPE_UEFI =
    SystemProfileProto_Hardware_BiosType_BIOS_TYPE_UEFI;
  static inline bool BiosType_IsValid(int value) {
    return SystemProfileProto_Hardware_BiosType_IsValid(value);
  }
  static constexpr BiosType BiosType_MIN =
    SystemProfileProto_Hardware_BiosType_BiosType_MIN;
  static constexpr BiosType BiosType_MAX =
    SystemProfileProto_Hardware_BiosType_BiosType_MAX;
  static constexpr int BiosType_ARRAYSIZE =
    SystemProfileProto_Hardware_BiosType_BiosType_ARRAYSIZE;
  template<typename T>
  static inline const std::string& BiosType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, BiosType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function BiosType_Name.");
    return SystemProfileProto_Hardware_BiosType_Name(enum_t_value);
  }
  static inline bool BiosType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      BiosType* value) {
    return SystemProfileProto_Hardware_BiosType_Parse(name, value);
  }

  typedef SystemProfileProto_Hardware_TpmType TpmType;
  static constexpr TpmType TPM_TYPE_UNKNOWN =
    SystemProfileProto_Hardware_TpmType_TPM_TYPE_UNKNOWN;
  static constexpr TpmType TPM_TYPE_1 =
    SystemProfileProto_Hardware_TpmType_TPM_TYPE_1;
  static constexpr TpmType TPM_TYPE_CR50 =
    SystemProfileProto_Hardware_TpmType_TPM_TYPE_CR50;
  static constexpr TpmType TPM_TYPE_TI50 =
    SystemProfileProto_Hardware_TpmType_TPM_TYPE_TI50;
  static constexpr TpmType TPM_TYPE_RUNTIME_SELECTION =
    SystemProfileProto_Hardware_TpmType_TPM_TYPE_RUNTIME_SELECTION;
  static constexpr TpmType TPM_TYPE_GENERIC_2 =
    SystemProfileProto_Hardware_TpmType_TPM_TYPE_GENERIC_2;
  static inline bool TpmType_IsValid(int value) {
    return SystemProfileProto_Hardware_TpmType_IsValid(value);
  }
  static constexpr TpmType TpmType_MIN =
    SystemProfileProto_Hardware_TpmType_TpmType_MIN;
  static constexpr TpmType TpmType_MAX =
    SystemProfileProto_Hardware_TpmType_TpmType_MAX;
  static constexpr int TpmType_ARRAYSIZE =
    SystemProfileProto_Hardware_TpmType_TpmType_ARRAYSIZE;
  template<typename T>
  static inline const std::string& TpmType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, TpmType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function TpmType_Name.");
    return SystemProfileProto_Hardware_TpmType_Name(enum_t_value);
  }
  static inline bool TpmType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      TpmType* value) {
    return SystemProfileProto_Hardware_TpmType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kInternalStorageDevicesFieldNumber = 20,
    kCpuArchitectureFieldNumber = 1,
    kHardwareClassFieldNumber = 4,
    kFullHardwareClassFieldNumber = 18,
    kAppCpuArchitectureFieldNumber = 21,
    kCellularDeviceVariantFieldNumber = 24,
    kTpmRwFirmwareVersionFieldNumber = 27,
    kGpuFieldNumber = 8,
    kCpuFieldNumber = 13,
    kAppDriveFieldNumber = 16,
    kUserDataDriveFieldNumber = 17,
    kMotherboardFieldNumber = 25,
    kSystemRamMbFieldNumber = 2,
    kDllBaseFieldNumber = 3,
    kScreenCountFieldNumber = 5,
    kPrimaryScreenWidthFieldNumber = 6,
    kPrimaryScreenHeightFieldNumber = 7,
    kMaxDpiXFieldNumber = 9,
    kMaxDpiYFieldNumber = 10,
    kPrimaryScreenScaleFactorFieldNumber = 12,
    kInternalDisplaySupportsTouchFieldNumber = 14,
    kFormFactorFieldNumber = 22,
    kTpmFirmwareVersionFieldNumber = 26,
    kTpmTypeFieldNumber = 23,
  };
  // repeated .metrics.SystemProfileProto.Hardware.InternalStorageDevice internal_storage_devices = 20;
  int internal_storage_devices_size() const;
  private:
  int _internal_internal_storage_devices_size() const;
  public:
  void clear_internal_storage_devices();
  ::metrics::SystemProfileProto_Hardware_InternalStorageDevice* mutable_internal_storage_devices(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_Hardware_InternalStorageDevice >*
      mutable_internal_storage_devices();
  private:
  const ::metrics::SystemProfileProto_Hardware_InternalStorageDevice& _internal_internal_storage_devices(int index) const;
  ::metrics::SystemProfileProto_Hardware_InternalStorageDevice* _internal_add_internal_storage_devices();
  public:
  const ::metrics::SystemProfileProto_Hardware_InternalStorageDevice& internal_storage_devices(int index) const;
  ::metrics::SystemProfileProto_Hardware_InternalStorageDevice* add_internal_storage_devices();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_Hardware_InternalStorageDevice >&
      internal_storage_devices() const;

  // optional string cpu_architecture = 1;
  bool has_cpu_architecture() const;
  private:
  bool _internal_has_cpu_architecture() const;
  public:
  void clear_cpu_architecture();
  const std::string& cpu_architecture() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_cpu_architecture(ArgT0&& arg0, ArgT... args);
  std::string* mutable_cpu_architecture();
  PROTOBUF_NODISCARD std::string* release_cpu_architecture();
  void set_allocated_cpu_architecture(std::string* cpu_architecture);
  private:
  const std::string& _internal_cpu_architecture() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cpu_architecture(const std::string& value);
  std::string* _internal_mutable_cpu_architecture();
  public:

  // optional string hardware_class = 4;
  bool has_hardware_class() const;
  private:
  bool _internal_has_hardware_class() const;
  public:
  void clear_hardware_class();
  const std::string& hardware_class() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_hardware_class(ArgT0&& arg0, ArgT... args);
  std::string* mutable_hardware_class();
  PROTOBUF_NODISCARD std::string* release_hardware_class();
  void set_allocated_hardware_class(std::string* hardware_class);
  private:
  const std::string& _internal_hardware_class() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hardware_class(const std::string& value);
  std::string* _internal_mutable_hardware_class();
  public:

  // optional string full_hardware_class = 18;
  bool has_full_hardware_class() const;
  private:
  bool _internal_has_full_hardware_class() const;
  public:
  void clear_full_hardware_class();
  const std::string& full_hardware_class() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_full_hardware_class(ArgT0&& arg0, ArgT... args);
  std::string* mutable_full_hardware_class();
  PROTOBUF_NODISCARD std::string* release_full_hardware_class();
  void set_allocated_full_hardware_class(std::string* full_hardware_class);
  private:
  const std::string& _internal_full_hardware_class() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_full_hardware_class(const std::string& value);
  std::string* _internal_mutable_full_hardware_class();
  public:

  // optional string app_cpu_architecture = 21;
  bool has_app_cpu_architecture() const;
  private:
  bool _internal_has_app_cpu_architecture() const;
  public:
  void clear_app_cpu_architecture();
  const std::string& app_cpu_architecture() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_app_cpu_architecture(ArgT0&& arg0, ArgT... args);
  std::string* mutable_app_cpu_architecture();
  PROTOBUF_NODISCARD std::string* release_app_cpu_architecture();
  void set_allocated_app_cpu_architecture(std::string* app_cpu_architecture);
  private:
  const std::string& _internal_app_cpu_architecture() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_app_cpu_architecture(const std::string& value);
  std::string* _internal_mutable_app_cpu_architecture();
  public:

  // optional string cellular_device_variant = 24;
  bool has_cellular_device_variant() const;
  private:
  bool _internal_has_cellular_device_variant() const;
  public:
  void clear_cellular_device_variant();
  const std::string& cellular_device_variant() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_cellular_device_variant(ArgT0&& arg0, ArgT... args);
  std::string* mutable_cellular_device_variant();
  PROTOBUF_NODISCARD std::string* release_cellular_device_variant();
  void set_allocated_cellular_device_variant(std::string* cellular_device_variant);
  private:
  const std::string& _internal_cellular_device_variant() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cellular_device_variant(const std::string& value);
  std::string* _internal_mutable_cellular_device_variant();
  public:

  // optional string tpm_rw_firmware_version = 27;
  bool has_tpm_rw_firmware_version() const;
  private:
  bool _internal_has_tpm_rw_firmware_version() const;
  public:
  void clear_tpm_rw_firmware_version();
  const std::string& tpm_rw_firmware_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_tpm_rw_firmware_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_tpm_rw_firmware_version();
  PROTOBUF_NODISCARD std::string* release_tpm_rw_firmware_version();
  void set_allocated_tpm_rw_firmware_version(std::string* tpm_rw_firmware_version);
  private:
  const std::string& _internal_tpm_rw_firmware_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tpm_rw_firmware_version(const std::string& value);
  std::string* _internal_mutable_tpm_rw_firmware_version();
  public:

  // optional .metrics.SystemProfileProto.Hardware.Graphics gpu = 8;
  bool has_gpu() const;
  private:
  bool _internal_has_gpu() const;
  public:
  void clear_gpu();
  const ::metrics::SystemProfileProto_Hardware_Graphics& gpu() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_Hardware_Graphics* release_gpu();
  ::metrics::SystemProfileProto_Hardware_Graphics* mutable_gpu();
  void set_allocated_gpu(::metrics::SystemProfileProto_Hardware_Graphics* gpu);
  private:
  const ::metrics::SystemProfileProto_Hardware_Graphics& _internal_gpu() const;
  ::metrics::SystemProfileProto_Hardware_Graphics* _internal_mutable_gpu();
  public:
  void unsafe_arena_set_allocated_gpu(
      ::metrics::SystemProfileProto_Hardware_Graphics* gpu);
  ::metrics::SystemProfileProto_Hardware_Graphics* unsafe_arena_release_gpu();

  // optional .metrics.SystemProfileProto.Hardware.CPU cpu = 13;
  bool has_cpu() const;
  private:
  bool _internal_has_cpu() const;
  public:
  void clear_cpu();
  const ::metrics::SystemProfileProto_Hardware_CPU& cpu() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_Hardware_CPU* release_cpu();
  ::metrics::SystemProfileProto_Hardware_CPU* mutable_cpu();
  void set_allocated_cpu(::metrics::SystemProfileProto_Hardware_CPU* cpu);
  private:
  const ::metrics::SystemProfileProto_Hardware_CPU& _internal_cpu() const;
  ::metrics::SystemProfileProto_Hardware_CPU* _internal_mutable_cpu();
  public:
  void unsafe_arena_set_allocated_cpu(
      ::metrics::SystemProfileProto_Hardware_CPU* cpu);
  ::metrics::SystemProfileProto_Hardware_CPU* unsafe_arena_release_cpu();

  // optional .metrics.SystemProfileProto.Hardware.Drive app_drive = 16;
  bool has_app_drive() const;
  private:
  bool _internal_has_app_drive() const;
  public:
  void clear_app_drive();
  const ::metrics::SystemProfileProto_Hardware_Drive& app_drive() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_Hardware_Drive* release_app_drive();
  ::metrics::SystemProfileProto_Hardware_Drive* mutable_app_drive();
  void set_allocated_app_drive(::metrics::SystemProfileProto_Hardware_Drive* app_drive);
  private:
  const ::metrics::SystemProfileProto_Hardware_Drive& _internal_app_drive() const;
  ::metrics::SystemProfileProto_Hardware_Drive* _internal_mutable_app_drive();
  public:
  void unsafe_arena_set_allocated_app_drive(
      ::metrics::SystemProfileProto_Hardware_Drive* app_drive);
  ::metrics::SystemProfileProto_Hardware_Drive* unsafe_arena_release_app_drive();

  // optional .metrics.SystemProfileProto.Hardware.Drive user_data_drive = 17;
  bool has_user_data_drive() const;
  private:
  bool _internal_has_user_data_drive() const;
  public:
  void clear_user_data_drive();
  const ::metrics::SystemProfileProto_Hardware_Drive& user_data_drive() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_Hardware_Drive* release_user_data_drive();
  ::metrics::SystemProfileProto_Hardware_Drive* mutable_user_data_drive();
  void set_allocated_user_data_drive(::metrics::SystemProfileProto_Hardware_Drive* user_data_drive);
  private:
  const ::metrics::SystemProfileProto_Hardware_Drive& _internal_user_data_drive() const;
  ::metrics::SystemProfileProto_Hardware_Drive* _internal_mutable_user_data_drive();
  public:
  void unsafe_arena_set_allocated_user_data_drive(
      ::metrics::SystemProfileProto_Hardware_Drive* user_data_drive);
  ::metrics::SystemProfileProto_Hardware_Drive* unsafe_arena_release_user_data_drive();

  // optional .metrics.SystemProfileProto.Hardware.Motherboard motherboard = 25;
  bool has_motherboard() const;
  private:
  bool _internal_has_motherboard() const;
  public:
  void clear_motherboard();
  const ::metrics::SystemProfileProto_Hardware_Motherboard& motherboard() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_Hardware_Motherboard* release_motherboard();
  ::metrics::SystemProfileProto_Hardware_Motherboard* mutable_motherboard();
  void set_allocated_motherboard(::metrics::SystemProfileProto_Hardware_Motherboard* motherboard);
  private:
  const ::metrics::SystemProfileProto_Hardware_Motherboard& _internal_motherboard() const;
  ::metrics::SystemProfileProto_Hardware_Motherboard* _internal_mutable_motherboard();
  public:
  void unsafe_arena_set_allocated_motherboard(
      ::metrics::SystemProfileProto_Hardware_Motherboard* motherboard);
  ::metrics::SystemProfileProto_Hardware_Motherboard* unsafe_arena_release_motherboard();

  // optional int64 system_ram_mb = 2;
  bool has_system_ram_mb() const;
  private:
  bool _internal_has_system_ram_mb() const;
  public:
  void clear_system_ram_mb();
  int64_t system_ram_mb() const;
  void set_system_ram_mb(int64_t value);
  private:
  int64_t _internal_system_ram_mb() const;
  void _internal_set_system_ram_mb(int64_t value);
  public:

  // optional int64 dll_base = 3;
  bool has_dll_base() const;
  private:
  bool _internal_has_dll_base() const;
  public:
  void clear_dll_base();
  int64_t dll_base() const;
  void set_dll_base(int64_t value);
  private:
  int64_t _internal_dll_base() const;
  void _internal_set_dll_base(int64_t value);
  public:

  // optional int32 screen_count = 5;
  bool has_screen_count() const;
  private:
  bool _internal_has_screen_count() const;
  public:
  void clear_screen_count();
  int32_t screen_count() const;
  void set_screen_count(int32_t value);
  private:
  int32_t _internal_screen_count() const;
  void _internal_set_screen_count(int32_t value);
  public:

  // optional int32 primary_screen_width = 6;
  bool has_primary_screen_width() const;
  private:
  bool _internal_has_primary_screen_width() const;
  public:
  void clear_primary_screen_width();
  int32_t primary_screen_width() const;
  void set_primary_screen_width(int32_t value);
  private:
  int32_t _internal_primary_screen_width() const;
  void _internal_set_primary_screen_width(int32_t value);
  public:

  // optional int32 primary_screen_height = 7;
  bool has_primary_screen_height() const;
  private:
  bool _internal_has_primary_screen_height() const;
  public:
  void clear_primary_screen_height();
  int32_t primary_screen_height() const;
  void set_primary_screen_height(int32_t value);
  private:
  int32_t _internal_primary_screen_height() const;
  void _internal_set_primary_screen_height(int32_t value);
  public:

  // optional float max_dpi_x = 9;
  bool has_max_dpi_x() const;
  private:
  bool _internal_has_max_dpi_x() const;
  public:
  void clear_max_dpi_x();
  float max_dpi_x() const;
  void set_max_dpi_x(float value);
  private:
  float _internal_max_dpi_x() const;
  void _internal_set_max_dpi_x(float value);
  public:

  // optional float max_dpi_y = 10;
  bool has_max_dpi_y() const;
  private:
  bool _internal_has_max_dpi_y() const;
  public:
  void clear_max_dpi_y();
  float max_dpi_y() const;
  void set_max_dpi_y(float value);
  private:
  float _internal_max_dpi_y() const;
  void _internal_set_max_dpi_y(float value);
  public:

  // optional float primary_screen_scale_factor = 12;
  bool has_primary_screen_scale_factor() const;
  private:
  bool _internal_has_primary_screen_scale_factor() const;
  public:
  void clear_primary_screen_scale_factor();
  float primary_screen_scale_factor() const;
  void set_primary_screen_scale_factor(float value);
  private:
  float _internal_primary_screen_scale_factor() const;
  void _internal_set_primary_screen_scale_factor(float value);
  public:

  // optional bool internal_display_supports_touch = 14;
  bool has_internal_display_supports_touch() const;
  private:
  bool _internal_has_internal_display_supports_touch() const;
  public:
  void clear_internal_display_supports_touch();
  bool internal_display_supports_touch() const;
  void set_internal_display_supports_touch(bool value);
  private:
  bool _internal_internal_display_supports_touch() const;
  void _internal_set_internal_display_supports_touch(bool value);
  public:

  // optional .metrics.SystemProfileProto.Hardware.FormFactor form_factor = 22;
  bool has_form_factor() const;
  private:
  bool _internal_has_form_factor() const;
  public:
  void clear_form_factor();
  ::metrics::SystemProfileProto_Hardware_FormFactor form_factor() const;
  void set_form_factor(::metrics::SystemProfileProto_Hardware_FormFactor value);
  private:
  ::metrics::SystemProfileProto_Hardware_FormFactor _internal_form_factor() const;
  void _internal_set_form_factor(::metrics::SystemProfileProto_Hardware_FormFactor value);
  public:

  // optional uint64 tpm_firmware_version = 26;
  bool has_tpm_firmware_version() const;
  private:
  bool _internal_has_tpm_firmware_version() const;
  public:
  void clear_tpm_firmware_version();
  uint64_t tpm_firmware_version() const;
  void set_tpm_firmware_version(uint64_t value);
  private:
  uint64_t _internal_tpm_firmware_version() const;
  void _internal_set_tpm_firmware_version(uint64_t value);
  public:

  // optional .metrics.SystemProfileProto.Hardware.TpmType tpm_type = 23;
  bool has_tpm_type() const;
  private:
  bool _internal_has_tpm_type() const;
  public:
  void clear_tpm_type();
  ::metrics::SystemProfileProto_Hardware_TpmType tpm_type() const;
  void set_tpm_type(::metrics::SystemProfileProto_Hardware_TpmType value);
  private:
  ::metrics::SystemProfileProto_Hardware_TpmType _internal_tpm_type() const;
  void _internal_set_tpm_type(::metrics::SystemProfileProto_Hardware_TpmType value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.Hardware)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_Hardware_InternalStorageDevice > internal_storage_devices_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cpu_architecture_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hardware_class_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr full_hardware_class_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr app_cpu_architecture_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cellular_device_variant_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tpm_rw_firmware_version_;
    ::metrics::SystemProfileProto_Hardware_Graphics* gpu_;
    ::metrics::SystemProfileProto_Hardware_CPU* cpu_;
    ::metrics::SystemProfileProto_Hardware_Drive* app_drive_;
    ::metrics::SystemProfileProto_Hardware_Drive* user_data_drive_;
    ::metrics::SystemProfileProto_Hardware_Motherboard* motherboard_;
    int64_t system_ram_mb_;
    int64_t dll_base_;
    int32_t screen_count_;
    int32_t primary_screen_width_;
    int32_t primary_screen_height_;
    float max_dpi_x_;
    float max_dpi_y_;
    float primary_screen_scale_factor_;
    bool internal_display_supports_touch_;
    int form_factor_;
    uint64_t tpm_firmware_version_;
    int tpm_type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_Network final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.Network) */ {
 public:
  inline SystemProfileProto_Network() : SystemProfileProto_Network(nullptr) {}
  ~SystemProfileProto_Network() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_Network(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_Network(const SystemProfileProto_Network& from);
  SystemProfileProto_Network(SystemProfileProto_Network&& from) noexcept
    : SystemProfileProto_Network() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_Network& operator=(const SystemProfileProto_Network& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_Network& operator=(SystemProfileProto_Network&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_Network& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_Network* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_Network*>(
               &_SystemProfileProto_Network_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(SystemProfileProto_Network& a, SystemProfileProto_Network& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_Network* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_Network* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_Network* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_Network>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_Network& from);
  void MergeFrom(const SystemProfileProto_Network& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_Network* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.Network";
  }
  protected:
  explicit SystemProfileProto_Network(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef SystemProfileProto_Network_ConnectionType ConnectionType;
  static constexpr ConnectionType CONNECTION_UNKNOWN =
    SystemProfileProto_Network_ConnectionType_CONNECTION_UNKNOWN;
  static constexpr ConnectionType CONNECTION_ETHERNET =
    SystemProfileProto_Network_ConnectionType_CONNECTION_ETHERNET;
  static constexpr ConnectionType CONNECTION_WIFI =
    SystemProfileProto_Network_ConnectionType_CONNECTION_WIFI;
  static constexpr ConnectionType CONNECTION_2G =
    SystemProfileProto_Network_ConnectionType_CONNECTION_2G;
  static constexpr ConnectionType CONNECTION_3G =
    SystemProfileProto_Network_ConnectionType_CONNECTION_3G;
  static constexpr ConnectionType CONNECTION_4G =
    SystemProfileProto_Network_ConnectionType_CONNECTION_4G;
  static constexpr ConnectionType CONNECTION_BLUETOOTH =
    SystemProfileProto_Network_ConnectionType_CONNECTION_BLUETOOTH;
  static constexpr ConnectionType CONNECTION_NONE =
    SystemProfileProto_Network_ConnectionType_CONNECTION_NONE;
  static constexpr ConnectionType CONNECTION_AMBIGUOUS =
    SystemProfileProto_Network_ConnectionType_CONNECTION_AMBIGUOUS;
  static constexpr ConnectionType CONNECTION_5G =
    SystemProfileProto_Network_ConnectionType_CONNECTION_5G;
  static inline bool ConnectionType_IsValid(int value) {
    return SystemProfileProto_Network_ConnectionType_IsValid(value);
  }
  static constexpr ConnectionType ConnectionType_MIN =
    SystemProfileProto_Network_ConnectionType_ConnectionType_MIN;
  static constexpr ConnectionType ConnectionType_MAX =
    SystemProfileProto_Network_ConnectionType_ConnectionType_MAX;
  static constexpr int ConnectionType_ARRAYSIZE =
    SystemProfileProto_Network_ConnectionType_ConnectionType_ARRAYSIZE;
  template<typename T>
  static inline const std::string& ConnectionType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ConnectionType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ConnectionType_Name.");
    return SystemProfileProto_Network_ConnectionType_Name(enum_t_value);
  }
  static inline bool ConnectionType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ConnectionType* value) {
    return SystemProfileProto_Network_ConnectionType_Parse(name, value);
  }

  typedef SystemProfileProto_Network_WifiPHYLayerProtocol WifiPHYLayerProtocol;
  static constexpr WifiPHYLayerProtocol WIFI_PHY_LAYER_PROTOCOL_NONE =
    SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_NONE;
  static constexpr WifiPHYLayerProtocol WIFI_PHY_LAYER_PROTOCOL_ANCIENT =
    SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_ANCIENT;
  static constexpr WifiPHYLayerProtocol WIFI_PHY_LAYER_PROTOCOL_A =
    SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_A;
  static constexpr WifiPHYLayerProtocol WIFI_PHY_LAYER_PROTOCOL_B =
    SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_B;
  static constexpr WifiPHYLayerProtocol WIFI_PHY_LAYER_PROTOCOL_G =
    SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_G;
  static constexpr WifiPHYLayerProtocol WIFI_PHY_LAYER_PROTOCOL_N =
    SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_N;
  static constexpr WifiPHYLayerProtocol WIFI_PHY_LAYER_PROTOCOL_UNKNOWN =
    SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_UNKNOWN;
  static constexpr WifiPHYLayerProtocol WIFI_PHY_LAYER_PROTOCOL_AC =
    SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_AC;
  static constexpr WifiPHYLayerProtocol WIFI_PHY_LAYER_PROTOCOL_AD =
    SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_AD;
  static constexpr WifiPHYLayerProtocol WIFI_PHY_LAYER_PROTOCOL_AX =
    SystemProfileProto_Network_WifiPHYLayerProtocol_WIFI_PHY_LAYER_PROTOCOL_AX;
  static inline bool WifiPHYLayerProtocol_IsValid(int value) {
    return SystemProfileProto_Network_WifiPHYLayerProtocol_IsValid(value);
  }
  static constexpr WifiPHYLayerProtocol WifiPHYLayerProtocol_MIN =
    SystemProfileProto_Network_WifiPHYLayerProtocol_WifiPHYLayerProtocol_MIN;
  static constexpr WifiPHYLayerProtocol WifiPHYLayerProtocol_MAX =
    SystemProfileProto_Network_WifiPHYLayerProtocol_WifiPHYLayerProtocol_MAX;
  static constexpr int WifiPHYLayerProtocol_ARRAYSIZE =
    SystemProfileProto_Network_WifiPHYLayerProtocol_WifiPHYLayerProtocol_ARRAYSIZE;
  template<typename T>
  static inline const std::string& WifiPHYLayerProtocol_Name(T enum_t_value) {
    static_assert(::std::is_same<T, WifiPHYLayerProtocol>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function WifiPHYLayerProtocol_Name.");
    return SystemProfileProto_Network_WifiPHYLayerProtocol_Name(enum_t_value);
  }
  static inline bool WifiPHYLayerProtocol_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      WifiPHYLayerProtocol* value) {
    return SystemProfileProto_Network_WifiPHYLayerProtocol_Parse(name, value);
  }

  typedef SystemProfileProto_Network_EffectiveConnectionType EffectiveConnectionType;
  static constexpr EffectiveConnectionType EFFECTIVE_CONNECTION_TYPE_UNKNOWN =
    SystemProfileProto_Network_EffectiveConnectionType_EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
  PROTOBUF_DEPRECATED_ENUM static constexpr EffectiveConnectionType DEPRECATED_EFFECTIVE_CONNECTION_TYPE_AMBIGUOUS =
    SystemProfileProto_Network_EffectiveConnectionType_DEPRECATED_EFFECTIVE_CONNECTION_TYPE_AMBIGUOUS;
  static constexpr EffectiveConnectionType EFFECTIVE_CONNECTION_TYPE_OFFLINE =
    SystemProfileProto_Network_EffectiveConnectionType_EFFECTIVE_CONNECTION_TYPE_OFFLINE;
  static constexpr EffectiveConnectionType EFFECTIVE_CONNECTION_TYPE_SLOW_2G =
    SystemProfileProto_Network_EffectiveConnectionType_EFFECTIVE_CONNECTION_TYPE_SLOW_2G;
  static constexpr EffectiveConnectionType EFFECTIVE_CONNECTION_TYPE_2G =
    SystemProfileProto_Network_EffectiveConnectionType_EFFECTIVE_CONNECTION_TYPE_2G;
  static constexpr EffectiveConnectionType EFFECTIVE_CONNECTION_TYPE_3G =
    SystemProfileProto_Network_EffectiveConnectionType_EFFECTIVE_CONNECTION_TYPE_3G;
  static constexpr EffectiveConnectionType EFFECTIVE_CONNECTION_TYPE_4G =
    SystemProfileProto_Network_EffectiveConnectionType_EFFECTIVE_CONNECTION_TYPE_4G;
  static inline bool EffectiveConnectionType_IsValid(int value) {
    return SystemProfileProto_Network_EffectiveConnectionType_IsValid(value);
  }
  static constexpr EffectiveConnectionType EffectiveConnectionType_MIN =
    SystemProfileProto_Network_EffectiveConnectionType_EffectiveConnectionType_MIN;
  static constexpr EffectiveConnectionType EffectiveConnectionType_MAX =
    SystemProfileProto_Network_EffectiveConnectionType_EffectiveConnectionType_MAX;
  static constexpr int EffectiveConnectionType_ARRAYSIZE =
    SystemProfileProto_Network_EffectiveConnectionType_EffectiveConnectionType_ARRAYSIZE;
  template<typename T>
  static inline const std::string& EffectiveConnectionType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, EffectiveConnectionType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function EffectiveConnectionType_Name.");
    return SystemProfileProto_Network_EffectiveConnectionType_Name(enum_t_value);
  }
  static inline bool EffectiveConnectionType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      EffectiveConnectionType* value) {
    return SystemProfileProto_Network_EffectiveConnectionType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kConnectionTypeFieldNumber = 2,
    kConnectionTypeIsAmbiguousFieldNumber = 1,
    kWifiPhyLayerProtocolIsAmbiguousFieldNumber = 3,
    kWifiPhyLayerProtocolFieldNumber = 4,
    kMinEffectiveConnectionTypeFieldNumber = 7,
    kMaxEffectiveConnectionTypeFieldNumber = 8,
  };
  // optional .metrics.SystemProfileProto.Network.ConnectionType connection_type = 2;
  bool has_connection_type() const;
  private:
  bool _internal_has_connection_type() const;
  public:
  void clear_connection_type();
  ::metrics::SystemProfileProto_Network_ConnectionType connection_type() const;
  void set_connection_type(::metrics::SystemProfileProto_Network_ConnectionType value);
  private:
  ::metrics::SystemProfileProto_Network_ConnectionType _internal_connection_type() const;
  void _internal_set_connection_type(::metrics::SystemProfileProto_Network_ConnectionType value);
  public:

  // optional bool connection_type_is_ambiguous = 1;
  bool has_connection_type_is_ambiguous() const;
  private:
  bool _internal_has_connection_type_is_ambiguous() const;
  public:
  void clear_connection_type_is_ambiguous();
  bool connection_type_is_ambiguous() const;
  void set_connection_type_is_ambiguous(bool value);
  private:
  bool _internal_connection_type_is_ambiguous() const;
  void _internal_set_connection_type_is_ambiguous(bool value);
  public:

  // optional bool wifi_phy_layer_protocol_is_ambiguous = 3;
  bool has_wifi_phy_layer_protocol_is_ambiguous() const;
  private:
  bool _internal_has_wifi_phy_layer_protocol_is_ambiguous() const;
  public:
  void clear_wifi_phy_layer_protocol_is_ambiguous();
  bool wifi_phy_layer_protocol_is_ambiguous() const;
  void set_wifi_phy_layer_protocol_is_ambiguous(bool value);
  private:
  bool _internal_wifi_phy_layer_protocol_is_ambiguous() const;
  void _internal_set_wifi_phy_layer_protocol_is_ambiguous(bool value);
  public:

  // optional .metrics.SystemProfileProto.Network.WifiPHYLayerProtocol wifi_phy_layer_protocol = 4;
  bool has_wifi_phy_layer_protocol() const;
  private:
  bool _internal_has_wifi_phy_layer_protocol() const;
  public:
  void clear_wifi_phy_layer_protocol();
  ::metrics::SystemProfileProto_Network_WifiPHYLayerProtocol wifi_phy_layer_protocol() const;
  void set_wifi_phy_layer_protocol(::metrics::SystemProfileProto_Network_WifiPHYLayerProtocol value);
  private:
  ::metrics::SystemProfileProto_Network_WifiPHYLayerProtocol _internal_wifi_phy_layer_protocol() const;
  void _internal_set_wifi_phy_layer_protocol(::metrics::SystemProfileProto_Network_WifiPHYLayerProtocol value);
  public:

  // optional .metrics.SystemProfileProto.Network.EffectiveConnectionType min_effective_connection_type = 7;
  bool has_min_effective_connection_type() const;
  private:
  bool _internal_has_min_effective_connection_type() const;
  public:
  void clear_min_effective_connection_type();
  ::metrics::SystemProfileProto_Network_EffectiveConnectionType min_effective_connection_type() const;
  void set_min_effective_connection_type(::metrics::SystemProfileProto_Network_EffectiveConnectionType value);
  private:
  ::metrics::SystemProfileProto_Network_EffectiveConnectionType _internal_min_effective_connection_type() const;
  void _internal_set_min_effective_connection_type(::metrics::SystemProfileProto_Network_EffectiveConnectionType value);
  public:

  // optional .metrics.SystemProfileProto.Network.EffectiveConnectionType max_effective_connection_type = 8;
  bool has_max_effective_connection_type() const;
  private:
  bool _internal_has_max_effective_connection_type() const;
  public:
  void clear_max_effective_connection_type();
  ::metrics::SystemProfileProto_Network_EffectiveConnectionType max_effective_connection_type() const;
  void set_max_effective_connection_type(::metrics::SystemProfileProto_Network_EffectiveConnectionType value);
  private:
  ::metrics::SystemProfileProto_Network_EffectiveConnectionType _internal_max_effective_connection_type() const;
  void _internal_set_max_effective_connection_type(::metrics::SystemProfileProto_Network_EffectiveConnectionType value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.Network)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int connection_type_;
    bool connection_type_is_ambiguous_;
    bool wifi_phy_layer_protocol_is_ambiguous_;
    int wifi_phy_layer_protocol_;
    int min_effective_connection_type_;
    int max_effective_connection_type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_GoogleUpdate_ProductInfo final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.GoogleUpdate.ProductInfo) */ {
 public:
  inline SystemProfileProto_GoogleUpdate_ProductInfo() : SystemProfileProto_GoogleUpdate_ProductInfo(nullptr) {}
  ~SystemProfileProto_GoogleUpdate_ProductInfo() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_GoogleUpdate_ProductInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_GoogleUpdate_ProductInfo(const SystemProfileProto_GoogleUpdate_ProductInfo& from);
  SystemProfileProto_GoogleUpdate_ProductInfo(SystemProfileProto_GoogleUpdate_ProductInfo&& from) noexcept
    : SystemProfileProto_GoogleUpdate_ProductInfo() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_GoogleUpdate_ProductInfo& operator=(const SystemProfileProto_GoogleUpdate_ProductInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_GoogleUpdate_ProductInfo& operator=(SystemProfileProto_GoogleUpdate_ProductInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_GoogleUpdate_ProductInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_GoogleUpdate_ProductInfo* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_GoogleUpdate_ProductInfo*>(
               &_SystemProfileProto_GoogleUpdate_ProductInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(SystemProfileProto_GoogleUpdate_ProductInfo& a, SystemProfileProto_GoogleUpdate_ProductInfo& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_GoogleUpdate_ProductInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_GoogleUpdate_ProductInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_GoogleUpdate_ProductInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_GoogleUpdate_ProductInfo>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_GoogleUpdate_ProductInfo& from);
  void MergeFrom(const SystemProfileProto_GoogleUpdate_ProductInfo& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_GoogleUpdate_ProductInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.GoogleUpdate.ProductInfo";
  }
  protected:
  explicit SystemProfileProto_GoogleUpdate_ProductInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult InstallResult;
  static constexpr InstallResult INSTALL_RESULT_SUCCESS =
    SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_INSTALL_RESULT_SUCCESS;
  static constexpr InstallResult INSTALL_RESULT_FAILED_CUSTOM_ERROR =
    SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_INSTALL_RESULT_FAILED_CUSTOM_ERROR;
  static constexpr InstallResult INSTALL_RESULT_FAILED_MSI_ERROR =
    SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_INSTALL_RESULT_FAILED_MSI_ERROR;
  static constexpr InstallResult INSTALL_RESULT_FAILED_SYSTEM_ERROR =
    SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_INSTALL_RESULT_FAILED_SYSTEM_ERROR;
  static constexpr InstallResult INSTALL_RESULT_EXIT_CODE =
    SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_INSTALL_RESULT_EXIT_CODE;
  static inline bool InstallResult_IsValid(int value) {
    return SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_IsValid(value);
  }
  static constexpr InstallResult InstallResult_MIN =
    SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_InstallResult_MIN;
  static constexpr InstallResult InstallResult_MAX =
    SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_InstallResult_MAX;
  static constexpr int InstallResult_ARRAYSIZE =
    SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_InstallResult_ARRAYSIZE;
  template<typename T>
  static inline const std::string& InstallResult_Name(T enum_t_value) {
    static_assert(::std::is_same<T, InstallResult>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function InstallResult_Name.");
    return SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_Name(enum_t_value);
  }
  static inline bool InstallResult_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      InstallResult* value) {
    return SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kVersionFieldNumber = 1,
    kLastUpdateSuccessTimestampFieldNumber = 2,
    kLastResultFieldNumber = 3,
    kLastErrorFieldNumber = 4,
    kLastExtraErrorFieldNumber = 5,
  };
  // optional string version = 1;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  const std::string& version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_version();
  PROTOBUF_NODISCARD std::string* release_version();
  void set_allocated_version(std::string* version);
  private:
  const std::string& _internal_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
  std::string* _internal_mutable_version();
  public:

  // optional int64 last_update_success_timestamp = 2;
  bool has_last_update_success_timestamp() const;
  private:
  bool _internal_has_last_update_success_timestamp() const;
  public:
  void clear_last_update_success_timestamp();
  int64_t last_update_success_timestamp() const;
  void set_last_update_success_timestamp(int64_t value);
  private:
  int64_t _internal_last_update_success_timestamp() const;
  void _internal_set_last_update_success_timestamp(int64_t value);
  public:

  // optional .metrics.SystemProfileProto.GoogleUpdate.ProductInfo.InstallResult last_result = 3;
  bool has_last_result() const;
  private:
  bool _internal_has_last_result() const;
  public:
  void clear_last_result();
  ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult last_result() const;
  void set_last_result(::metrics::SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult value);
  private:
  ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult _internal_last_result() const;
  void _internal_set_last_result(::metrics::SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult value);
  public:

  // optional int32 last_error = 4;
  bool has_last_error() const;
  private:
  bool _internal_has_last_error() const;
  public:
  void clear_last_error();
  int32_t last_error() const;
  void set_last_error(int32_t value);
  private:
  int32_t _internal_last_error() const;
  void _internal_set_last_error(int32_t value);
  public:

  // optional int32 last_extra_error = 5;
  bool has_last_extra_error() const;
  private:
  bool _internal_has_last_extra_error() const;
  public:
  void clear_last_extra_error();
  int32_t last_extra_error() const;
  void set_last_extra_error(int32_t value);
  private:
  int32_t _internal_last_extra_error() const;
  void _internal_set_last_extra_error(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.GoogleUpdate.ProductInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
    int64_t last_update_success_timestamp_;
    int last_result_;
    int32_t last_error_;
    int32_t last_extra_error_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_GoogleUpdate final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.GoogleUpdate) */ {
 public:
  inline SystemProfileProto_GoogleUpdate() : SystemProfileProto_GoogleUpdate(nullptr) {}
  ~SystemProfileProto_GoogleUpdate() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_GoogleUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_GoogleUpdate(const SystemProfileProto_GoogleUpdate& from);
  SystemProfileProto_GoogleUpdate(SystemProfileProto_GoogleUpdate&& from) noexcept
    : SystemProfileProto_GoogleUpdate() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_GoogleUpdate& operator=(const SystemProfileProto_GoogleUpdate& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_GoogleUpdate& operator=(SystemProfileProto_GoogleUpdate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_GoogleUpdate& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_GoogleUpdate* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_GoogleUpdate*>(
               &_SystemProfileProto_GoogleUpdate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(SystemProfileProto_GoogleUpdate& a, SystemProfileProto_GoogleUpdate& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_GoogleUpdate* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_GoogleUpdate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_GoogleUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_GoogleUpdate>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_GoogleUpdate& from);
  void MergeFrom(const SystemProfileProto_GoogleUpdate& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_GoogleUpdate* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.GoogleUpdate";
  }
  protected:
  explicit SystemProfileProto_GoogleUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef SystemProfileProto_GoogleUpdate_ProductInfo ProductInfo;

  // accessors -------------------------------------------------------

  enum : int {
    kGoogleUpdateStatusFieldNumber = 4,
    kClientStatusFieldNumber = 5,
    kLastAutomaticStartTimestampFieldNumber = 2,
    kLastUpdateCheckTimestampFieldNumber = 3,
    kIsSystemInstallFieldNumber = 1,
  };
  // optional .metrics.SystemProfileProto.GoogleUpdate.ProductInfo google_update_status = 4;
  bool has_google_update_status() const;
  private:
  bool _internal_has_google_update_status() const;
  public:
  void clear_google_update_status();
  const ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo& google_update_status() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* release_google_update_status();
  ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* mutable_google_update_status();
  void set_allocated_google_update_status(::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* google_update_status);
  private:
  const ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo& _internal_google_update_status() const;
  ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* _internal_mutable_google_update_status();
  public:
  void unsafe_arena_set_allocated_google_update_status(
      ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* google_update_status);
  ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* unsafe_arena_release_google_update_status();

  // optional .metrics.SystemProfileProto.GoogleUpdate.ProductInfo client_status = 5;
  bool has_client_status() const;
  private:
  bool _internal_has_client_status() const;
  public:
  void clear_client_status();
  const ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo& client_status() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* release_client_status();
  ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* mutable_client_status();
  void set_allocated_client_status(::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* client_status);
  private:
  const ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo& _internal_client_status() const;
  ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* _internal_mutable_client_status();
  public:
  void unsafe_arena_set_allocated_client_status(
      ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* client_status);
  ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* unsafe_arena_release_client_status();

  // optional int64 last_automatic_start_timestamp = 2;
  bool has_last_automatic_start_timestamp() const;
  private:
  bool _internal_has_last_automatic_start_timestamp() const;
  public:
  void clear_last_automatic_start_timestamp();
  int64_t last_automatic_start_timestamp() const;
  void set_last_automatic_start_timestamp(int64_t value);
  private:
  int64_t _internal_last_automatic_start_timestamp() const;
  void _internal_set_last_automatic_start_timestamp(int64_t value);
  public:

  // optional int64 last_update_check_timestamp = 3;
  bool has_last_update_check_timestamp() const;
  private:
  bool _internal_has_last_update_check_timestamp() const;
  public:
  void clear_last_update_check_timestamp();
  int64_t last_update_check_timestamp() const;
  void set_last_update_check_timestamp(int64_t value);
  private:
  int64_t _internal_last_update_check_timestamp() const;
  void _internal_set_last_update_check_timestamp(int64_t value);
  public:

  // optional bool is_system_install = 1;
  bool has_is_system_install() const;
  private:
  bool _internal_has_is_system_install() const;
  public:
  void clear_is_system_install();
  bool is_system_install() const;
  void set_is_system_install(bool value);
  private:
  bool _internal_is_system_install() const;
  void _internal_set_is_system_install(bool value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.GoogleUpdate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* google_update_status_;
    ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* client_status_;
    int64_t last_automatic_start_timestamp_;
    int64_t last_update_check_timestamp_;
    bool is_system_install_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_Stability final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.Stability) */ {
 public:
  inline SystemProfileProto_Stability() : SystemProfileProto_Stability(nullptr) {}
  ~SystemProfileProto_Stability() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_Stability(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_Stability(const SystemProfileProto_Stability& from);
  SystemProfileProto_Stability(SystemProfileProto_Stability&& from) noexcept
    : SystemProfileProto_Stability() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_Stability& operator=(const SystemProfileProto_Stability& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_Stability& operator=(SystemProfileProto_Stability&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_Stability& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_Stability* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_Stability*>(
               &_SystemProfileProto_Stability_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(SystemProfileProto_Stability& a, SystemProfileProto_Stability& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_Stability* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_Stability* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_Stability* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_Stability>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_Stability& from);
  void MergeFrom(const SystemProfileProto_Stability& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_Stability* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.Stability";
  }
  protected:
  explicit SystemProfileProto_Stability(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIncrementalUptimeSecFieldNumber = 1,
    kPageLoadCountFieldNumber = 2,
    kOtherUserCrashCountFieldNumber = 7,
    kKernelCrashCountFieldNumber = 8,
    kUncleanSystemShutdownCountFieldNumber = 9,
    kLaunchCountFieldNumber = 15,
    kRendererLaunchCountFieldNumber = 26,
    kUptimeSecFieldNumber = 23,
    kFromPreviousRunFieldNumber = 29,
    kCrashCountDueToGmsCoreUpdateFieldNumber = 30,
  };
  // optional int64 incremental_uptime_sec = 1;
  bool has_incremental_uptime_sec() const;
  private:
  bool _internal_has_incremental_uptime_sec() const;
  public:
  void clear_incremental_uptime_sec();
  int64_t incremental_uptime_sec() const;
  void set_incremental_uptime_sec(int64_t value);
  private:
  int64_t _internal_incremental_uptime_sec() const;
  void _internal_set_incremental_uptime_sec(int64_t value);
  public:

  // optional int32 page_load_count = 2;
  bool has_page_load_count() const;
  private:
  bool _internal_has_page_load_count() const;
  public:
  void clear_page_load_count();
  int32_t page_load_count() const;
  void set_page_load_count(int32_t value);
  private:
  int32_t _internal_page_load_count() const;
  void _internal_set_page_load_count(int32_t value);
  public:

  // optional int32 other_user_crash_count = 7;
  bool has_other_user_crash_count() const;
  private:
  bool _internal_has_other_user_crash_count() const;
  public:
  void clear_other_user_crash_count();
  int32_t other_user_crash_count() const;
  void set_other_user_crash_count(int32_t value);
  private:
  int32_t _internal_other_user_crash_count() const;
  void _internal_set_other_user_crash_count(int32_t value);
  public:

  // optional int32 kernel_crash_count = 8;
  bool has_kernel_crash_count() const;
  private:
  bool _internal_has_kernel_crash_count() const;
  public:
  void clear_kernel_crash_count();
  int32_t kernel_crash_count() const;
  void set_kernel_crash_count(int32_t value);
  private:
  int32_t _internal_kernel_crash_count() const;
  void _internal_set_kernel_crash_count(int32_t value);
  public:

  // optional int32 unclean_system_shutdown_count = 9;
  bool has_unclean_system_shutdown_count() const;
  private:
  bool _internal_has_unclean_system_shutdown_count() const;
  public:
  void clear_unclean_system_shutdown_count();
  int32_t unclean_system_shutdown_count() const;
  void set_unclean_system_shutdown_count(int32_t value);
  private:
  int32_t _internal_unclean_system_shutdown_count() const;
  void _internal_set_unclean_system_shutdown_count(int32_t value);
  public:

  // optional int32 launch_count = 15;
  bool has_launch_count() const;
  private:
  bool _internal_has_launch_count() const;
  public:
  void clear_launch_count();
  int32_t launch_count() const;
  void set_launch_count(int32_t value);
  private:
  int32_t _internal_launch_count() const;
  void _internal_set_launch_count(int32_t value);
  public:

  // optional int32 renderer_launch_count = 26;
  bool has_renderer_launch_count() const;
  private:
  bool _internal_has_renderer_launch_count() const;
  public:
  void clear_renderer_launch_count();
  int32_t renderer_launch_count() const;
  void set_renderer_launch_count(int32_t value);
  private:
  int32_t _internal_renderer_launch_count() const;
  void _internal_set_renderer_launch_count(int32_t value);
  public:

  // optional int64 uptime_sec = 23;
  bool has_uptime_sec() const;
  private:
  bool _internal_has_uptime_sec() const;
  public:
  void clear_uptime_sec();
  int64_t uptime_sec() const;
  void set_uptime_sec(int64_t value);
  private:
  int64_t _internal_uptime_sec() const;
  void _internal_set_uptime_sec(int64_t value);
  public:

  // optional bool from_previous_run = 29;
  bool has_from_previous_run() const;
  private:
  bool _internal_has_from_previous_run() const;
  public:
  void clear_from_previous_run();
  bool from_previous_run() const;
  void set_from_previous_run(bool value);
  private:
  bool _internal_from_previous_run() const;
  void _internal_set_from_previous_run(bool value);
  public:

  // optional int32 crash_count_due_to_gms_core_update = 30;
  bool has_crash_count_due_to_gms_core_update() const;
  private:
  bool _internal_has_crash_count_due_to_gms_core_update() const;
  public:
  void clear_crash_count_due_to_gms_core_update();
  int32_t crash_count_due_to_gms_core_update() const;
  void set_crash_count_due_to_gms_core_update(int32_t value);
  private:
  int32_t _internal_crash_count_due_to_gms_core_update() const;
  void _internal_set_crash_count_due_to_gms_core_update(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.Stability)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int64_t incremental_uptime_sec_;
    int32_t page_load_count_;
    int32_t other_user_crash_count_;
    int32_t kernel_crash_count_;
    int32_t unclean_system_shutdown_count_;
    int32_t launch_count_;
    int32_t renderer_launch_count_;
    int64_t uptime_sec_;
    bool from_previous_run_;
    int32_t crash_count_due_to_gms_core_update_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_FieldTrial final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.FieldTrial) */ {
 public:
  inline SystemProfileProto_FieldTrial() : SystemProfileProto_FieldTrial(nullptr) {}
  ~SystemProfileProto_FieldTrial() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_FieldTrial(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_FieldTrial(const SystemProfileProto_FieldTrial& from);
  SystemProfileProto_FieldTrial(SystemProfileProto_FieldTrial&& from) noexcept
    : SystemProfileProto_FieldTrial() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_FieldTrial& operator=(const SystemProfileProto_FieldTrial& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_FieldTrial& operator=(SystemProfileProto_FieldTrial&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_FieldTrial& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_FieldTrial* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_FieldTrial*>(
               &_SystemProfileProto_FieldTrial_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(SystemProfileProto_FieldTrial& a, SystemProfileProto_FieldTrial& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_FieldTrial* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_FieldTrial* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_FieldTrial* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_FieldTrial>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_FieldTrial& from);
  void MergeFrom(const SystemProfileProto_FieldTrial& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_FieldTrial* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.FieldTrial";
  }
  protected:
  explicit SystemProfileProto_FieldTrial(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameIdFieldNumber = 1,
    kGroupIdFieldNumber = 2,
  };
  // optional fixed32 name_id = 1;
  bool has_name_id() const;
  private:
  bool _internal_has_name_id() const;
  public:
  void clear_name_id();
  uint32_t name_id() const;
  void set_name_id(uint32_t value);
  private:
  uint32_t _internal_name_id() const;
  void _internal_set_name_id(uint32_t value);
  public:

  // optional fixed32 group_id = 2;
  bool has_group_id() const;
  private:
  bool _internal_has_group_id() const;
  public:
  void clear_group_id();
  uint32_t group_id() const;
  void set_group_id(uint32_t value);
  private:
  uint32_t _internal_group_id() const;
  void _internal_set_group_id(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.FieldTrial)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t name_id_;
    uint32_t group_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_ExternalAudioVideoDevice_AudioDescription final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription) */ {
 public:
  inline SystemProfileProto_ExternalAudioVideoDevice_AudioDescription() : SystemProfileProto_ExternalAudioVideoDevice_AudioDescription(nullptr) {}
  ~SystemProfileProto_ExternalAudioVideoDevice_AudioDescription() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_ExternalAudioVideoDevice_AudioDescription(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription(const SystemProfileProto_ExternalAudioVideoDevice_AudioDescription& from);
  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription(SystemProfileProto_ExternalAudioVideoDevice_AudioDescription&& from) noexcept
    : SystemProfileProto_ExternalAudioVideoDevice_AudioDescription() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_ExternalAudioVideoDevice_AudioDescription& operator=(const SystemProfileProto_ExternalAudioVideoDevice_AudioDescription& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_ExternalAudioVideoDevice_AudioDescription& operator=(SystemProfileProto_ExternalAudioVideoDevice_AudioDescription&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_ExternalAudioVideoDevice_AudioDescription& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_ExternalAudioVideoDevice_AudioDescription*>(
               &_SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(SystemProfileProto_ExternalAudioVideoDevice_AudioDescription& a, SystemProfileProto_ExternalAudioVideoDevice_AudioDescription& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_ExternalAudioVideoDevice_AudioDescription>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_ExternalAudioVideoDevice_AudioDescription& from);
  void MergeFrom(const SystemProfileProto_ExternalAudioVideoDevice_AudioDescription& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription";
  }
  protected:
  explicit SystemProfileProto_ExternalAudioVideoDevice_AudioDescription(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat AudioFormat;
  static constexpr AudioFormat AUDIO_FORMAT_UNKNOWN =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_UNKNOWN;
  static constexpr AudioFormat AUDIO_FORMAT_LPCM =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_LPCM;
  static constexpr AudioFormat AUDIO_FORMAT_AC_3 =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_AC_3;
  static constexpr AudioFormat AUDIO_FORMAT_MPEG1 =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_MPEG1;
  static constexpr AudioFormat AUDIO_FORMAT_MP3 =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_MP3;
  static constexpr AudioFormat AUDIO_FORMAT_MPEG2 =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_MPEG2;
  static constexpr AudioFormat AUDIO_FORMAT_AAC =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_AAC;
  static constexpr AudioFormat AUDIO_FORMAT_DTS =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_DTS;
  static constexpr AudioFormat AUDIO_FORMAT_ATRAC =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_ATRAC;
  static constexpr AudioFormat AUDIO_FORMAT_ONE_BIT =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_ONE_BIT;
  static constexpr AudioFormat AUDIO_FORMAT_DD_PLUS =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_DD_PLUS;
  static constexpr AudioFormat AUDIO_FORMAT_DTS_HD =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_DTS_HD;
  static constexpr AudioFormat AUDIO_FORMAT_MLP_DOLBY_TRUEHD =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_MLP_DOLBY_TRUEHD;
  static constexpr AudioFormat AUDIO_FORMAT_DST_AUDIO =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_DST_AUDIO;
  static constexpr AudioFormat AUDIO_FORMAT_MICROSOFT_WMA_PRO =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AUDIO_FORMAT_MICROSOFT_WMA_PRO;
  static inline bool AudioFormat_IsValid(int value) {
    return SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_IsValid(value);
  }
  static constexpr AudioFormat AudioFormat_MIN =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AudioFormat_MIN;
  static constexpr AudioFormat AudioFormat_MAX =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AudioFormat_MAX;
  static constexpr int AudioFormat_ARRAYSIZE =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_AudioFormat_ARRAYSIZE;
  template<typename T>
  static inline const std::string& AudioFormat_Name(T enum_t_value) {
    static_assert(::std::is_same<T, AudioFormat>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function AudioFormat_Name.");
    return SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_Name(enum_t_value);
  }
  static inline bool AudioFormat_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      AudioFormat* value) {
    return SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_Parse(name, value);
  }

  typedef SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode OutputMode;
  static constexpr OutputMode ANALOG =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_ANALOG;
  static constexpr OutputMode DIGITAL =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_DIGITAL;
  static inline bool OutputMode_IsValid(int value) {
    return SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_IsValid(value);
  }
  static constexpr OutputMode OutputMode_MIN =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_OutputMode_MIN;
  static constexpr OutputMode OutputMode_MAX =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_OutputMode_MAX;
  static constexpr int OutputMode_ARRAYSIZE =
    SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_OutputMode_ARRAYSIZE;
  template<typename T>
  static inline const std::string& OutputMode_Name(T enum_t_value) {
    static_assert(::std::is_same<T, OutputMode>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function OutputMode_Name.");
    return SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_Name(enum_t_value);
  }
  static inline bool OutputMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      OutputMode* value) {
    return SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kSampleFrequencyHzFieldNumber = 3,
    kAudioFormatFieldNumber = 1,
    kNumChannelsFieldNumber = 2,
    kMaxBitRatePerSecondFieldNumber = 4,
    kBitDepthFieldNumber = 5,
    kOutputModeFieldNumber = 6,
  };
  // repeated int32 sample_frequency_hz = 3;
  int sample_frequency_hz_size() const;
  private:
  int _internal_sample_frequency_hz_size() const;
  public:
  void clear_sample_frequency_hz();
  private:
  int32_t _internal_sample_frequency_hz(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_sample_frequency_hz() const;
  void _internal_add_sample_frequency_hz(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_sample_frequency_hz();
  public:
  int32_t sample_frequency_hz(int index) const;
  void set_sample_frequency_hz(int index, int32_t value);
  void add_sample_frequency_hz(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      sample_frequency_hz() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_sample_frequency_hz();

  // optional .metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.AudioFormat audio_format = 1;
  bool has_audio_format() const;
  private:
  bool _internal_has_audio_format() const;
  public:
  void clear_audio_format();
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat audio_format() const;
  void set_audio_format(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat value);
  private:
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat _internal_audio_format() const;
  void _internal_set_audio_format(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat value);
  public:

  // optional int32 num_channels = 2;
  bool has_num_channels() const;
  private:
  bool _internal_has_num_channels() const;
  public:
  void clear_num_channels();
  int32_t num_channels() const;
  void set_num_channels(int32_t value);
  private:
  int32_t _internal_num_channels() const;
  void _internal_set_num_channels(int32_t value);
  public:

  // optional int32 max_bit_rate_per_second = 4;
  bool has_max_bit_rate_per_second() const;
  private:
  bool _internal_has_max_bit_rate_per_second() const;
  public:
  void clear_max_bit_rate_per_second();
  int32_t max_bit_rate_per_second() const;
  void set_max_bit_rate_per_second(int32_t value);
  private:
  int32_t _internal_max_bit_rate_per_second() const;
  void _internal_set_max_bit_rate_per_second(int32_t value);
  public:

  // optional int32 bit_depth = 5;
  bool has_bit_depth() const;
  private:
  bool _internal_has_bit_depth() const;
  public:
  void clear_bit_depth();
  int32_t bit_depth() const;
  void set_bit_depth(int32_t value);
  private:
  int32_t _internal_bit_depth() const;
  void _internal_set_bit_depth(int32_t value);
  public:

  // optional .metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.OutputMode output_mode = 6;
  bool has_output_mode() const;
  private:
  bool _internal_has_output_mode() const;
  public:
  void clear_output_mode();
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode output_mode() const;
  void set_output_mode(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode value);
  private:
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode _internal_output_mode() const;
  void _internal_set_output_mode(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > sample_frequency_hz_;
    int audio_format_;
    int32_t num_channels_;
    int32_t max_bit_rate_per_second_;
    int32_t bit_depth_;
    int output_mode_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_ExternalAudioVideoDevice_CECCommand final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand) */ {
 public:
  inline SystemProfileProto_ExternalAudioVideoDevice_CECCommand() : SystemProfileProto_ExternalAudioVideoDevice_CECCommand(nullptr) {}
  ~SystemProfileProto_ExternalAudioVideoDevice_CECCommand() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_ExternalAudioVideoDevice_CECCommand(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_ExternalAudioVideoDevice_CECCommand(const SystemProfileProto_ExternalAudioVideoDevice_CECCommand& from);
  SystemProfileProto_ExternalAudioVideoDevice_CECCommand(SystemProfileProto_ExternalAudioVideoDevice_CECCommand&& from) noexcept
    : SystemProfileProto_ExternalAudioVideoDevice_CECCommand() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_ExternalAudioVideoDevice_CECCommand& operator=(const SystemProfileProto_ExternalAudioVideoDevice_CECCommand& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_ExternalAudioVideoDevice_CECCommand& operator=(SystemProfileProto_ExternalAudioVideoDevice_CECCommand&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_ExternalAudioVideoDevice_CECCommand& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_ExternalAudioVideoDevice_CECCommand* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_ExternalAudioVideoDevice_CECCommand*>(
               &_SystemProfileProto_ExternalAudioVideoDevice_CECCommand_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(SystemProfileProto_ExternalAudioVideoDevice_CECCommand& a, SystemProfileProto_ExternalAudioVideoDevice_CECCommand& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_ExternalAudioVideoDevice_CECCommand* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_ExternalAudioVideoDevice_CECCommand* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_ExternalAudioVideoDevice_CECCommand* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_ExternalAudioVideoDevice_CECCommand>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_ExternalAudioVideoDevice_CECCommand& from);
  void MergeFrom(const SystemProfileProto_ExternalAudioVideoDevice_CECCommand& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_ExternalAudioVideoDevice_CECCommand* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand";
  }
  protected:
  explicit SystemProfileProto_ExternalAudioVideoDevice_CECCommand(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOpcodeFieldNumber = 1,
    kNumReceivedDirectFieldNumber = 2,
    kNumReceivedBroadcastFieldNumber = 3,
    kNumSentDirectFieldNumber = 4,
    kNumSentBroadcastFieldNumber = 5,
    kNumAbortedUnknownReasonFieldNumber = 6,
    kNumAbortedUnrecognizedFieldNumber = 7,
  };
  // optional int32 opcode = 1;
  bool has_opcode() const;
  private:
  bool _internal_has_opcode() const;
  public:
  void clear_opcode();
  int32_t opcode() const;
  void set_opcode(int32_t value);
  private:
  int32_t _internal_opcode() const;
  void _internal_set_opcode(int32_t value);
  public:

  // optional int32 num_received_direct = 2;
  bool has_num_received_direct() const;
  private:
  bool _internal_has_num_received_direct() const;
  public:
  void clear_num_received_direct();
  int32_t num_received_direct() const;
  void set_num_received_direct(int32_t value);
  private:
  int32_t _internal_num_received_direct() const;
  void _internal_set_num_received_direct(int32_t value);
  public:

  // optional int32 num_received_broadcast = 3;
  bool has_num_received_broadcast() const;
  private:
  bool _internal_has_num_received_broadcast() const;
  public:
  void clear_num_received_broadcast();
  int32_t num_received_broadcast() const;
  void set_num_received_broadcast(int32_t value);
  private:
  int32_t _internal_num_received_broadcast() const;
  void _internal_set_num_received_broadcast(int32_t value);
  public:

  // optional int32 num_sent_direct = 4;
  bool has_num_sent_direct() const;
  private:
  bool _internal_has_num_sent_direct() const;
  public:
  void clear_num_sent_direct();
  int32_t num_sent_direct() const;
  void set_num_sent_direct(int32_t value);
  private:
  int32_t _internal_num_sent_direct() const;
  void _internal_set_num_sent_direct(int32_t value);
  public:

  // optional int32 num_sent_broadcast = 5;
  bool has_num_sent_broadcast() const;
  private:
  bool _internal_has_num_sent_broadcast() const;
  public:
  void clear_num_sent_broadcast();
  int32_t num_sent_broadcast() const;
  void set_num_sent_broadcast(int32_t value);
  private:
  int32_t _internal_num_sent_broadcast() const;
  void _internal_set_num_sent_broadcast(int32_t value);
  public:

  // optional int32 num_aborted_unknown_reason = 6;
  bool has_num_aborted_unknown_reason() const;
  private:
  bool _internal_has_num_aborted_unknown_reason() const;
  public:
  void clear_num_aborted_unknown_reason();
  int32_t num_aborted_unknown_reason() const;
  void set_num_aborted_unknown_reason(int32_t value);
  private:
  int32_t _internal_num_aborted_unknown_reason() const;
  void _internal_set_num_aborted_unknown_reason(int32_t value);
  public:

  // optional int32 num_aborted_unrecognized = 7;
  bool has_num_aborted_unrecognized() const;
  private:
  bool _internal_has_num_aborted_unrecognized() const;
  public:
  void clear_num_aborted_unrecognized();
  int32_t num_aborted_unrecognized() const;
  void set_num_aborted_unrecognized(int32_t value);
  private:
  int32_t _internal_num_aborted_unrecognized() const;
  void _internal_set_num_aborted_unrecognized(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t opcode_;
    int32_t num_received_direct_;
    int32_t num_received_broadcast_;
    int32_t num_sent_direct_;
    int32_t num_sent_broadcast_;
    int32_t num_aborted_unknown_reason_;
    int32_t num_aborted_unrecognized_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_ExternalAudioVideoDevice final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.ExternalAudioVideoDevice) */ {
 public:
  inline SystemProfileProto_ExternalAudioVideoDevice() : SystemProfileProto_ExternalAudioVideoDevice(nullptr) {}
  ~SystemProfileProto_ExternalAudioVideoDevice() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_ExternalAudioVideoDevice(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_ExternalAudioVideoDevice(const SystemProfileProto_ExternalAudioVideoDevice& from);
  SystemProfileProto_ExternalAudioVideoDevice(SystemProfileProto_ExternalAudioVideoDevice&& from) noexcept
    : SystemProfileProto_ExternalAudioVideoDevice() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_ExternalAudioVideoDevice& operator=(const SystemProfileProto_ExternalAudioVideoDevice& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_ExternalAudioVideoDevice& operator=(SystemProfileProto_ExternalAudioVideoDevice&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_ExternalAudioVideoDevice& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_ExternalAudioVideoDevice* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_ExternalAudioVideoDevice*>(
               &_SystemProfileProto_ExternalAudioVideoDevice_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(SystemProfileProto_ExternalAudioVideoDevice& a, SystemProfileProto_ExternalAudioVideoDevice& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_ExternalAudioVideoDevice* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_ExternalAudioVideoDevice* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_ExternalAudioVideoDevice* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_ExternalAudioVideoDevice>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_ExternalAudioVideoDevice& from);
  void MergeFrom(const SystemProfileProto_ExternalAudioVideoDevice& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_ExternalAudioVideoDevice* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.ExternalAudioVideoDevice";
  }
  protected:
  explicit SystemProfileProto_ExternalAudioVideoDevice(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef SystemProfileProto_ExternalAudioVideoDevice_AudioDescription AudioDescription;
  typedef SystemProfileProto_ExternalAudioVideoDevice_CECCommand CECCommand;

  typedef SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType AVDeviceType;
  static constexpr AVDeviceType AV_DEVICE_TYPE_UNKNOWN =
    SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AV_DEVICE_TYPE_UNKNOWN;
  static constexpr AVDeviceType AV_DEVICE_TYPE_TV =
    SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AV_DEVICE_TYPE_TV;
  static constexpr AVDeviceType AV_DEVICE_TYPE_RECORDER =
    SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AV_DEVICE_TYPE_RECORDER;
  static constexpr AVDeviceType AV_DEVICE_TYPE_TUNER =
    SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AV_DEVICE_TYPE_TUNER;
  static constexpr AVDeviceType AV_DEVICE_TYPE_PLAYER =
    SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AV_DEVICE_TYPE_PLAYER;
  static constexpr AVDeviceType AV_DEVICE_TYPE_AUDIO_SYSTEM =
    SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AV_DEVICE_TYPE_AUDIO_SYSTEM;
  static inline bool AVDeviceType_IsValid(int value) {
    return SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_IsValid(value);
  }
  static constexpr AVDeviceType AVDeviceType_MIN =
    SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AVDeviceType_MIN;
  static constexpr AVDeviceType AVDeviceType_MAX =
    SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AVDeviceType_MAX;
  static constexpr int AVDeviceType_ARRAYSIZE =
    SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_AVDeviceType_ARRAYSIZE;
  template<typename T>
  static inline const std::string& AVDeviceType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, AVDeviceType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function AVDeviceType_Name.");
    return SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_Name(enum_t_value);
  }
  static inline bool AVDeviceType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      AVDeviceType* value) {
    return SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_Parse(name, value);
  }

  typedef SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding ColorEncoding;
  static constexpr ColorEncoding COLOR_ENCODING_UNKNOWN =
    SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_COLOR_ENCODING_UNKNOWN;
  static constexpr ColorEncoding COLOR_ENCODING_RGB =
    SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_COLOR_ENCODING_RGB;
  static constexpr ColorEncoding COLOR_ENCODING_YUV444 =
    SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_COLOR_ENCODING_YUV444;
  static constexpr ColorEncoding COLOR_ENCODING_YUV422 =
    SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_COLOR_ENCODING_YUV422;
  static constexpr ColorEncoding COLOR_ENCODING_YUV420 =
    SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_COLOR_ENCODING_YUV420;
  static inline bool ColorEncoding_IsValid(int value) {
    return SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_IsValid(value);
  }
  static constexpr ColorEncoding ColorEncoding_MIN =
    SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_ColorEncoding_MIN;
  static constexpr ColorEncoding ColorEncoding_MAX =
    SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_ColorEncoding_MAX;
  static constexpr int ColorEncoding_ARRAYSIZE =
    SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_ColorEncoding_ARRAYSIZE;
  template<typename T>
  static inline const std::string& ColorEncoding_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ColorEncoding>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ColorEncoding_Name.");
    return SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_Name(enum_t_value);
  }
  static inline bool ColorEncoding_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ColorEncoding* value) {
    return SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kAvDeviceTypeFieldNumber = 4,
    kAudioDescriptionFieldNumber = 9,
    kCecCommandFieldNumber = 13,
    kManufacturerNameFieldNumber = 1,
    kModelNameFieldNumber = 2,
    kProductCodeFieldNumber = 3,
    kManufactureYearFieldNumber = 5,
    kManufactureWeekFieldNumber = 6,
    kHorizontalResolutionFieldNumber = 7,
    kVerticalResolutionFieldNumber = 8,
    kPositionInSetupFieldNumber = 10,
    kCecVersionFieldNumber = 12,
    kFrameRateFieldNumber = 14,
    kColorEncodingFieldNumber = 15,
    kBitDepthFieldNumber = 16,
    kTmdsFieldNumber = 17,
    kIsInPathToTvFieldNumber = 11,
    kHdr10SupportFieldNumber = 18,
    kDolbyVisionSupportFieldNumber = 19,
    kYuvSupportFieldNumber = 21,
    kEotfSupportFieldNumber = 20,
    kYuv420SupportFieldNumber = 22,
    kMaximumSupportedHdcpVersionFieldNumber = 23,
    kCurrentHdcpVersionFieldNumber = 24,
  };
  // repeated .metrics.SystemProfileProto.ExternalAudioVideoDevice.AVDeviceType av_device_type = 4;
  int av_device_type_size() const;
  private:
  int _internal_av_device_type_size() const;
  public:
  void clear_av_device_type();
  private:
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType _internal_av_device_type(int index) const;
  void _internal_add_av_device_type(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_av_device_type();
  public:
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType av_device_type(int index) const;
  void set_av_device_type(int index, ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType value);
  void add_av_device_type(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& av_device_type() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_av_device_type();

  // repeated .metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription audio_description = 9;
  int audio_description_size() const;
  private:
  int _internal_audio_description_size() const;
  public:
  void clear_audio_description();
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* mutable_audio_description(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription >*
      mutable_audio_description();
  private:
  const ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription& _internal_audio_description(int index) const;
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* _internal_add_audio_description();
  public:
  const ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription& audio_description(int index) const;
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* add_audio_description();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription >&
      audio_description() const;

  // repeated .metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand cec_command = 13;
  int cec_command_size() const;
  private:
  int _internal_cec_command_size() const;
  public:
  void clear_cec_command();
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand* mutable_cec_command(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand >*
      mutable_cec_command();
  private:
  const ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand& _internal_cec_command(int index) const;
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand* _internal_add_cec_command();
  public:
  const ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand& cec_command(int index) const;
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand* add_cec_command();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand >&
      cec_command() const;

  // optional string manufacturer_name = 1;
  bool has_manufacturer_name() const;
  private:
  bool _internal_has_manufacturer_name() const;
  public:
  void clear_manufacturer_name();
  const std::string& manufacturer_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_manufacturer_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_manufacturer_name();
  PROTOBUF_NODISCARD std::string* release_manufacturer_name();
  void set_allocated_manufacturer_name(std::string* manufacturer_name);
  private:
  const std::string& _internal_manufacturer_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_manufacturer_name(const std::string& value);
  std::string* _internal_mutable_manufacturer_name();
  public:

  // optional string model_name = 2;
  bool has_model_name() const;
  private:
  bool _internal_has_model_name() const;
  public:
  void clear_model_name();
  const std::string& model_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_model_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_model_name();
  PROTOBUF_NODISCARD std::string* release_model_name();
  void set_allocated_model_name(std::string* model_name);
  private:
  const std::string& _internal_model_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model_name(const std::string& value);
  std::string* _internal_mutable_model_name();
  public:

  // optional string product_code = 3;
  bool has_product_code() const;
  private:
  bool _internal_has_product_code() const;
  public:
  void clear_product_code();
  const std::string& product_code() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_product_code(ArgT0&& arg0, ArgT... args);
  std::string* mutable_product_code();
  PROTOBUF_NODISCARD std::string* release_product_code();
  void set_allocated_product_code(std::string* product_code);
  private:
  const std::string& _internal_product_code() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_product_code(const std::string& value);
  std::string* _internal_mutable_product_code();
  public:

  // optional int32 manufacture_year = 5;
  bool has_manufacture_year() const;
  private:
  bool _internal_has_manufacture_year() const;
  public:
  void clear_manufacture_year();
  int32_t manufacture_year() const;
  void set_manufacture_year(int32_t value);
  private:
  int32_t _internal_manufacture_year() const;
  void _internal_set_manufacture_year(int32_t value);
  public:

  // optional int32 manufacture_week = 6;
  bool has_manufacture_week() const;
  private:
  bool _internal_has_manufacture_week() const;
  public:
  void clear_manufacture_week();
  int32_t manufacture_week() const;
  void set_manufacture_week(int32_t value);
  private:
  int32_t _internal_manufacture_week() const;
  void _internal_set_manufacture_week(int32_t value);
  public:

  // optional int32 horizontal_resolution = 7;
  bool has_horizontal_resolution() const;
  private:
  bool _internal_has_horizontal_resolution() const;
  public:
  void clear_horizontal_resolution();
  int32_t horizontal_resolution() const;
  void set_horizontal_resolution(int32_t value);
  private:
  int32_t _internal_horizontal_resolution() const;
  void _internal_set_horizontal_resolution(int32_t value);
  public:

  // optional int32 vertical_resolution = 8;
  bool has_vertical_resolution() const;
  private:
  bool _internal_has_vertical_resolution() const;
  public:
  void clear_vertical_resolution();
  int32_t vertical_resolution() const;
  void set_vertical_resolution(int32_t value);
  private:
  int32_t _internal_vertical_resolution() const;
  void _internal_set_vertical_resolution(int32_t value);
  public:

  // optional int32 position_in_setup = 10;
  bool has_position_in_setup() const;
  private:
  bool _internal_has_position_in_setup() const;
  public:
  void clear_position_in_setup();
  int32_t position_in_setup() const;
  void set_position_in_setup(int32_t value);
  private:
  int32_t _internal_position_in_setup() const;
  void _internal_set_position_in_setup(int32_t value);
  public:

  // optional int32 cec_version = 12;
  bool has_cec_version() const;
  private:
  bool _internal_has_cec_version() const;
  public:
  void clear_cec_version();
  int32_t cec_version() const;
  void set_cec_version(int32_t value);
  private:
  int32_t _internal_cec_version() const;
  void _internal_set_cec_version(int32_t value);
  public:

  // optional int32 frame_rate = 14;
  bool has_frame_rate() const;
  private:
  bool _internal_has_frame_rate() const;
  public:
  void clear_frame_rate();
  int32_t frame_rate() const;
  void set_frame_rate(int32_t value);
  private:
  int32_t _internal_frame_rate() const;
  void _internal_set_frame_rate(int32_t value);
  public:

  // optional .metrics.SystemProfileProto.ExternalAudioVideoDevice.ColorEncoding color_encoding = 15;
  bool has_color_encoding() const;
  private:
  bool _internal_has_color_encoding() const;
  public:
  void clear_color_encoding();
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding color_encoding() const;
  void set_color_encoding(::metrics::SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding value);
  private:
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding _internal_color_encoding() const;
  void _internal_set_color_encoding(::metrics::SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding value);
  public:

  // optional int32 bit_depth = 16;
  bool has_bit_depth() const;
  private:
  bool _internal_has_bit_depth() const;
  public:
  void clear_bit_depth();
  int32_t bit_depth() const;
  void set_bit_depth(int32_t value);
  private:
  int32_t _internal_bit_depth() const;
  void _internal_set_bit_depth(int32_t value);
  public:

  // optional int32 tmds = 17;
  bool has_tmds() const;
  private:
  bool _internal_has_tmds() const;
  public:
  void clear_tmds();
  int32_t tmds() const;
  void set_tmds(int32_t value);
  private:
  int32_t _internal_tmds() const;
  void _internal_set_tmds(int32_t value);
  public:

  // optional bool is_in_path_to_tv = 11;
  bool has_is_in_path_to_tv() const;
  private:
  bool _internal_has_is_in_path_to_tv() const;
  public:
  void clear_is_in_path_to_tv();
  bool is_in_path_to_tv() const;
  void set_is_in_path_to_tv(bool value);
  private:
  bool _internal_is_in_path_to_tv() const;
  void _internal_set_is_in_path_to_tv(bool value);
  public:

  // optional bool hdr10_support = 18;
  bool has_hdr10_support() const;
  private:
  bool _internal_has_hdr10_support() const;
  public:
  void clear_hdr10_support();
  bool hdr10_support() const;
  void set_hdr10_support(bool value);
  private:
  bool _internal_hdr10_support() const;
  void _internal_set_hdr10_support(bool value);
  public:

  // optional bool dolby_vision_support = 19;
  bool has_dolby_vision_support() const;
  private:
  bool _internal_has_dolby_vision_support() const;
  public:
  void clear_dolby_vision_support();
  bool dolby_vision_support() const;
  void set_dolby_vision_support(bool value);
  private:
  bool _internal_dolby_vision_support() const;
  void _internal_set_dolby_vision_support(bool value);
  public:

  // optional bool yuv_support = 21;
  bool has_yuv_support() const;
  private:
  bool _internal_has_yuv_support() const;
  public:
  void clear_yuv_support();
  bool yuv_support() const;
  void set_yuv_support(bool value);
  private:
  bool _internal_yuv_support() const;
  void _internal_set_yuv_support(bool value);
  public:

  // optional int32 eotf_support = 20;
  bool has_eotf_support() const;
  private:
  bool _internal_has_eotf_support() const;
  public:
  void clear_eotf_support();
  int32_t eotf_support() const;
  void set_eotf_support(int32_t value);
  private:
  int32_t _internal_eotf_support() const;
  void _internal_set_eotf_support(int32_t value);
  public:

  // optional bool yuv_420_support = 22;
  bool has_yuv_420_support() const;
  private:
  bool _internal_has_yuv_420_support() const;
  public:
  void clear_yuv_420_support();
  bool yuv_420_support() const;
  void set_yuv_420_support(bool value);
  private:
  bool _internal_yuv_420_support() const;
  void _internal_set_yuv_420_support(bool value);
  public:

  // optional int32 maximum_supported_hdcp_version = 23;
  bool has_maximum_supported_hdcp_version() const;
  private:
  bool _internal_has_maximum_supported_hdcp_version() const;
  public:
  void clear_maximum_supported_hdcp_version();
  int32_t maximum_supported_hdcp_version() const;
  void set_maximum_supported_hdcp_version(int32_t value);
  private:
  int32_t _internal_maximum_supported_hdcp_version() const;
  void _internal_set_maximum_supported_hdcp_version(int32_t value);
  public:

  // optional int32 current_hdcp_version = 24;
  bool has_current_hdcp_version() const;
  private:
  bool _internal_has_current_hdcp_version() const;
  public:
  void clear_current_hdcp_version();
  int32_t current_hdcp_version() const;
  void set_current_hdcp_version(int32_t value);
  private:
  int32_t _internal_current_hdcp_version() const;
  void _internal_set_current_hdcp_version(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.ExternalAudioVideoDevice)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> av_device_type_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription > audio_description_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand > cec_command_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manufacturer_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr product_code_;
    int32_t manufacture_year_;
    int32_t manufacture_week_;
    int32_t horizontal_resolution_;
    int32_t vertical_resolution_;
    int32_t position_in_setup_;
    int32_t cec_version_;
    int32_t frame_rate_;
    int color_encoding_;
    int32_t bit_depth_;
    int32_t tmds_;
    bool is_in_path_to_tv_;
    bool hdr10_support_;
    bool dolby_vision_support_;
    bool yuv_support_;
    int32_t eotf_support_;
    bool yuv_420_support_;
    int32_t maximum_supported_hdcp_version_;
    int32_t current_hdcp_version_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_ExternalAccessPoint final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.ExternalAccessPoint) */ {
 public:
  inline SystemProfileProto_ExternalAccessPoint() : SystemProfileProto_ExternalAccessPoint(nullptr) {}
  ~SystemProfileProto_ExternalAccessPoint() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_ExternalAccessPoint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_ExternalAccessPoint(const SystemProfileProto_ExternalAccessPoint& from);
  SystemProfileProto_ExternalAccessPoint(SystemProfileProto_ExternalAccessPoint&& from) noexcept
    : SystemProfileProto_ExternalAccessPoint() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_ExternalAccessPoint& operator=(const SystemProfileProto_ExternalAccessPoint& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_ExternalAccessPoint& operator=(SystemProfileProto_ExternalAccessPoint&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_ExternalAccessPoint& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_ExternalAccessPoint* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_ExternalAccessPoint*>(
               &_SystemProfileProto_ExternalAccessPoint_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(SystemProfileProto_ExternalAccessPoint& a, SystemProfileProto_ExternalAccessPoint& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_ExternalAccessPoint* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_ExternalAccessPoint* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_ExternalAccessPoint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_ExternalAccessPoint>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_ExternalAccessPoint& from);
  void MergeFrom(const SystemProfileProto_ExternalAccessPoint& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_ExternalAccessPoint* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.ExternalAccessPoint";
  }
  protected:
  explicit SystemProfileProto_ExternalAccessPoint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kManufacturerFieldNumber = 1,
    kModelNameFieldNumber = 2,
    kModelNumberFieldNumber = 3,
    kDeviceNameFieldNumber = 4,
  };
  // optional string manufacturer = 1;
  bool has_manufacturer() const;
  private:
  bool _internal_has_manufacturer() const;
  public:
  void clear_manufacturer();
  const std::string& manufacturer() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_manufacturer(ArgT0&& arg0, ArgT... args);
  std::string* mutable_manufacturer();
  PROTOBUF_NODISCARD std::string* release_manufacturer();
  void set_allocated_manufacturer(std::string* manufacturer);
  private:
  const std::string& _internal_manufacturer() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_manufacturer(const std::string& value);
  std::string* _internal_mutable_manufacturer();
  public:

  // optional string model_name = 2;
  bool has_model_name() const;
  private:
  bool _internal_has_model_name() const;
  public:
  void clear_model_name();
  const std::string& model_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_model_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_model_name();
  PROTOBUF_NODISCARD std::string* release_model_name();
  void set_allocated_model_name(std::string* model_name);
  private:
  const std::string& _internal_model_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model_name(const std::string& value);
  std::string* _internal_mutable_model_name();
  public:

  // optional string model_number = 3;
  bool has_model_number() const;
  private:
  bool _internal_has_model_number() const;
  public:
  void clear_model_number();
  const std::string& model_number() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_model_number(ArgT0&& arg0, ArgT... args);
  std::string* mutable_model_number();
  PROTOBUF_NODISCARD std::string* release_model_number();
  void set_allocated_model_number(std::string* model_number);
  private:
  const std::string& _internal_model_number() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model_number(const std::string& value);
  std::string* _internal_mutable_model_number();
  public:

  // optional string device_name = 4;
  bool has_device_name() const;
  private:
  bool _internal_has_device_name() const;
  public:
  void clear_device_name();
  const std::string& device_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_name();
  PROTOBUF_NODISCARD std::string* release_device_name();
  void set_allocated_device_name(std::string* device_name);
  private:
  const std::string& _internal_device_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_name(const std::string& value);
  std::string* _internal_mutable_device_name();
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.ExternalAccessPoint)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manufacturer_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_number_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_name_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_AntiVirusProduct final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.AntiVirusProduct) */ {
 public:
  inline SystemProfileProto_AntiVirusProduct() : SystemProfileProto_AntiVirusProduct(nullptr) {}
  ~SystemProfileProto_AntiVirusProduct() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_AntiVirusProduct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_AntiVirusProduct(const SystemProfileProto_AntiVirusProduct& from);
  SystemProfileProto_AntiVirusProduct(SystemProfileProto_AntiVirusProduct&& from) noexcept
    : SystemProfileProto_AntiVirusProduct() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_AntiVirusProduct& operator=(const SystemProfileProto_AntiVirusProduct& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_AntiVirusProduct& operator=(SystemProfileProto_AntiVirusProduct&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_AntiVirusProduct& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_AntiVirusProduct* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_AntiVirusProduct*>(
               &_SystemProfileProto_AntiVirusProduct_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(SystemProfileProto_AntiVirusProduct& a, SystemProfileProto_AntiVirusProduct& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_AntiVirusProduct* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_AntiVirusProduct* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_AntiVirusProduct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_AntiVirusProduct>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_AntiVirusProduct& from);
  void MergeFrom(const SystemProfileProto_AntiVirusProduct& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_AntiVirusProduct* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.AntiVirusProduct";
  }
  protected:
  explicit SystemProfileProto_AntiVirusProduct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProductNameFieldNumber = 1,
    kProductVersionFieldNumber = 3,
    kProductNameHashFieldNumber = 2,
    kProductVersionHashFieldNumber = 4,
    kProductStateFieldNumber = 5,
  };
  // optional string product_name = 1;
  bool has_product_name() const;
  private:
  bool _internal_has_product_name() const;
  public:
  void clear_product_name();
  const std::string& product_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_product_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_product_name();
  PROTOBUF_NODISCARD std::string* release_product_name();
  void set_allocated_product_name(std::string* product_name);
  private:
  const std::string& _internal_product_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_product_name(const std::string& value);
  std::string* _internal_mutable_product_name();
  public:

  // optional string product_version = 3;
  bool has_product_version() const;
  private:
  bool _internal_has_product_version() const;
  public:
  void clear_product_version();
  const std::string& product_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_product_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_product_version();
  PROTOBUF_NODISCARD std::string* release_product_version();
  void set_allocated_product_version(std::string* product_version);
  private:
  const std::string& _internal_product_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_product_version(const std::string& value);
  std::string* _internal_mutable_product_version();
  public:

  // optional fixed32 product_name_hash = 2;
  bool has_product_name_hash() const;
  private:
  bool _internal_has_product_name_hash() const;
  public:
  void clear_product_name_hash();
  uint32_t product_name_hash() const;
  void set_product_name_hash(uint32_t value);
  private:
  uint32_t _internal_product_name_hash() const;
  void _internal_set_product_name_hash(uint32_t value);
  public:

  // optional fixed32 product_version_hash = 4;
  bool has_product_version_hash() const;
  private:
  bool _internal_has_product_version_hash() const;
  public:
  void clear_product_version_hash();
  uint32_t product_version_hash() const;
  void set_product_version_hash(uint32_t value);
  private:
  uint32_t _internal_product_version_hash() const;
  void _internal_set_product_version_hash(uint32_t value);
  public:

  // optional .metrics.SystemProfileProto.AntiVirusState product_state = 5;
  bool has_product_state() const;
  private:
  bool _internal_has_product_state() const;
  public:
  void clear_product_state();
  ::metrics::SystemProfileProto_AntiVirusState product_state() const;
  void set_product_state(::metrics::SystemProfileProto_AntiVirusState value);
  private:
  ::metrics::SystemProfileProto_AntiVirusState _internal_product_state() const;
  void _internal_set_product_state(::metrics::SystemProfileProto_AntiVirusState value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.AntiVirusProduct)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr product_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr product_version_;
    uint32_t product_name_hash_;
    uint32_t product_version_hash_;
    int product_state_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_ChromeComponent final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.ChromeComponent) */ {
 public:
  inline SystemProfileProto_ChromeComponent() : SystemProfileProto_ChromeComponent(nullptr) {}
  ~SystemProfileProto_ChromeComponent() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_ChromeComponent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_ChromeComponent(const SystemProfileProto_ChromeComponent& from);
  SystemProfileProto_ChromeComponent(SystemProfileProto_ChromeComponent&& from) noexcept
    : SystemProfileProto_ChromeComponent() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_ChromeComponent& operator=(const SystemProfileProto_ChromeComponent& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_ChromeComponent& operator=(SystemProfileProto_ChromeComponent&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_ChromeComponent& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_ChromeComponent* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_ChromeComponent*>(
               &_SystemProfileProto_ChromeComponent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  friend void swap(SystemProfileProto_ChromeComponent& a, SystemProfileProto_ChromeComponent& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_ChromeComponent* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_ChromeComponent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_ChromeComponent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_ChromeComponent>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_ChromeComponent& from);
  void MergeFrom(const SystemProfileProto_ChromeComponent& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_ChromeComponent* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.ChromeComponent";
  }
  protected:
  explicit SystemProfileProto_ChromeComponent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kVersionFieldNumber = 2,
    kOmahaFingerprintFieldNumber = 3,
    kCohortHashFieldNumber = 4,
    kComponentIdFieldNumber = 1,
  };
  // optional string version = 2;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  const std::string& version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_version();
  PROTOBUF_NODISCARD std::string* release_version();
  void set_allocated_version(std::string* version);
  private:
  const std::string& _internal_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
  std::string* _internal_mutable_version();
  public:

  // optional fixed32 omaha_fingerprint = 3;
  bool has_omaha_fingerprint() const;
  private:
  bool _internal_has_omaha_fingerprint() const;
  public:
  void clear_omaha_fingerprint();
  uint32_t omaha_fingerprint() const;
  void set_omaha_fingerprint(uint32_t value);
  private:
  uint32_t _internal_omaha_fingerprint() const;
  void _internal_set_omaha_fingerprint(uint32_t value);
  public:

  // optional fixed32 cohort_hash = 4;
  bool has_cohort_hash() const;
  private:
  bool _internal_has_cohort_hash() const;
  public:
  void clear_cohort_hash();
  uint32_t cohort_hash() const;
  void set_cohort_hash(uint32_t value);
  private:
  uint32_t _internal_cohort_hash() const;
  void _internal_set_cohort_hash(uint32_t value);
  public:

  // optional .metrics.SystemProfileProto.ComponentId component_id = 1 [default = UNKNOWN];
  bool has_component_id() const;
  private:
  bool _internal_has_component_id() const;
  public:
  void clear_component_id();
  ::metrics::SystemProfileProto_ComponentId component_id() const;
  void set_component_id(::metrics::SystemProfileProto_ComponentId value);
  private:
  ::metrics::SystemProfileProto_ComponentId _internal_component_id() const;
  void _internal_set_component_id(::metrics::SystemProfileProto_ComponentId value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.ChromeComponent)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
    uint32_t omaha_fingerprint_;
    uint32_t cohort_hash_;
    int component_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_LinkedAndroidPhoneData final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.LinkedAndroidPhoneData) */ {
 public:
  inline SystemProfileProto_LinkedAndroidPhoneData() : SystemProfileProto_LinkedAndroidPhoneData(nullptr) {}
  ~SystemProfileProto_LinkedAndroidPhoneData() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_LinkedAndroidPhoneData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_LinkedAndroidPhoneData(const SystemProfileProto_LinkedAndroidPhoneData& from);
  SystemProfileProto_LinkedAndroidPhoneData(SystemProfileProto_LinkedAndroidPhoneData&& from) noexcept
    : SystemProfileProto_LinkedAndroidPhoneData() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_LinkedAndroidPhoneData& operator=(const SystemProfileProto_LinkedAndroidPhoneData& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_LinkedAndroidPhoneData& operator=(SystemProfileProto_LinkedAndroidPhoneData&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_LinkedAndroidPhoneData& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_LinkedAndroidPhoneData* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_LinkedAndroidPhoneData*>(
               &_SystemProfileProto_LinkedAndroidPhoneData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  friend void swap(SystemProfileProto_LinkedAndroidPhoneData& a, SystemProfileProto_LinkedAndroidPhoneData& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_LinkedAndroidPhoneData* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_LinkedAndroidPhoneData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_LinkedAndroidPhoneData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_LinkedAndroidPhoneData>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_LinkedAndroidPhoneData& from);
  void MergeFrom(const SystemProfileProto_LinkedAndroidPhoneData& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_LinkedAndroidPhoneData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.LinkedAndroidPhoneData";
  }
  protected:
  explicit SystemProfileProto_LinkedAndroidPhoneData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPhoneModelNameHashFieldNumber = 1,
    kIsSmartlockEnabledFieldNumber = 2,
    kIsInstantTetheringEnabledFieldNumber = 3,
    kIsMessagesEnabledFieldNumber = 4,
  };
  // optional fixed32 phone_model_name_hash = 1;
  bool has_phone_model_name_hash() const;
  private:
  bool _internal_has_phone_model_name_hash() const;
  public:
  void clear_phone_model_name_hash();
  uint32_t phone_model_name_hash() const;
  void set_phone_model_name_hash(uint32_t value);
  private:
  uint32_t _internal_phone_model_name_hash() const;
  void _internal_set_phone_model_name_hash(uint32_t value);
  public:

  // optional bool is_smartlock_enabled = 2;
  bool has_is_smartlock_enabled() const;
  private:
  bool _internal_has_is_smartlock_enabled() const;
  public:
  void clear_is_smartlock_enabled();
  bool is_smartlock_enabled() const;
  void set_is_smartlock_enabled(bool value);
  private:
  bool _internal_is_smartlock_enabled() const;
  void _internal_set_is_smartlock_enabled(bool value);
  public:

  // optional bool is_instant_tethering_enabled = 3;
  bool has_is_instant_tethering_enabled() const;
  private:
  bool _internal_has_is_instant_tethering_enabled() const;
  public:
  void clear_is_instant_tethering_enabled();
  bool is_instant_tethering_enabled() const;
  void set_is_instant_tethering_enabled(bool value);
  private:
  bool _internal_is_instant_tethering_enabled() const;
  void _internal_set_is_instant_tethering_enabled(bool value);
  public:

  // optional bool is_messages_enabled = 4 [deprecated = true];
  PROTOBUF_DEPRECATED bool has_is_messages_enabled() const;
  private:
  bool _internal_has_is_messages_enabled() const;
  public:
  PROTOBUF_DEPRECATED void clear_is_messages_enabled();
  PROTOBUF_DEPRECATED bool is_messages_enabled() const;
  PROTOBUF_DEPRECATED void set_is_messages_enabled(bool value);
  private:
  bool _internal_is_messages_enabled() const;
  void _internal_set_is_messages_enabled(bool value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.LinkedAndroidPhoneData)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t phone_model_name_hash_;
    bool is_smartlock_enabled_;
    bool is_instant_tethering_enabled_;
    bool is_messages_enabled_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_DemoModeDimensions_Retailer final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.DemoModeDimensions.Retailer) */ {
 public:
  inline SystemProfileProto_DemoModeDimensions_Retailer() : SystemProfileProto_DemoModeDimensions_Retailer(nullptr) {}
  ~SystemProfileProto_DemoModeDimensions_Retailer() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_DemoModeDimensions_Retailer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_DemoModeDimensions_Retailer(const SystemProfileProto_DemoModeDimensions_Retailer& from);
  SystemProfileProto_DemoModeDimensions_Retailer(SystemProfileProto_DemoModeDimensions_Retailer&& from) noexcept
    : SystemProfileProto_DemoModeDimensions_Retailer() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_DemoModeDimensions_Retailer& operator=(const SystemProfileProto_DemoModeDimensions_Retailer& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_DemoModeDimensions_Retailer& operator=(SystemProfileProto_DemoModeDimensions_Retailer&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_DemoModeDimensions_Retailer& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_DemoModeDimensions_Retailer* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_DemoModeDimensions_Retailer*>(
               &_SystemProfileProto_DemoModeDimensions_Retailer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  friend void swap(SystemProfileProto_DemoModeDimensions_Retailer& a, SystemProfileProto_DemoModeDimensions_Retailer& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_DemoModeDimensions_Retailer* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_DemoModeDimensions_Retailer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_DemoModeDimensions_Retailer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_DemoModeDimensions_Retailer>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_DemoModeDimensions_Retailer& from);
  void MergeFrom(const SystemProfileProto_DemoModeDimensions_Retailer& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_DemoModeDimensions_Retailer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.DemoModeDimensions.Retailer";
  }
  protected:
  explicit SystemProfileProto_DemoModeDimensions_Retailer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRetailerIdFieldNumber = 1,
    kStoreIdFieldNumber = 2,
  };
  // optional string retailer_id = 1;
  bool has_retailer_id() const;
  private:
  bool _internal_has_retailer_id() const;
  public:
  void clear_retailer_id();
  const std::string& retailer_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_retailer_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_retailer_id();
  PROTOBUF_NODISCARD std::string* release_retailer_id();
  void set_allocated_retailer_id(std::string* retailer_id);
  private:
  const std::string& _internal_retailer_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_retailer_id(const std::string& value);
  std::string* _internal_mutable_retailer_id();
  public:

  // optional string store_id = 2;
  bool has_store_id() const;
  private:
  bool _internal_has_store_id() const;
  public:
  void clear_store_id();
  const std::string& store_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_store_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_store_id();
  PROTOBUF_NODISCARD std::string* release_store_id();
  void set_allocated_store_id(std::string* store_id);
  private:
  const std::string& _internal_store_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_store_id(const std::string& value);
  std::string* _internal_mutable_store_id();
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.DemoModeDimensions.Retailer)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr retailer_id_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr store_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto_DemoModeDimensions final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto.DemoModeDimensions) */ {
 public:
  inline SystemProfileProto_DemoModeDimensions() : SystemProfileProto_DemoModeDimensions(nullptr) {}
  ~SystemProfileProto_DemoModeDimensions() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto_DemoModeDimensions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto_DemoModeDimensions(const SystemProfileProto_DemoModeDimensions& from);
  SystemProfileProto_DemoModeDimensions(SystemProfileProto_DemoModeDimensions&& from) noexcept
    : SystemProfileProto_DemoModeDimensions() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto_DemoModeDimensions& operator=(const SystemProfileProto_DemoModeDimensions& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto_DemoModeDimensions& operator=(SystemProfileProto_DemoModeDimensions&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto_DemoModeDimensions& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto_DemoModeDimensions* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto_DemoModeDimensions*>(
               &_SystemProfileProto_DemoModeDimensions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  friend void swap(SystemProfileProto_DemoModeDimensions& a, SystemProfileProto_DemoModeDimensions& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto_DemoModeDimensions* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto_DemoModeDimensions* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto_DemoModeDimensions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto_DemoModeDimensions>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto_DemoModeDimensions& from);
  void MergeFrom(const SystemProfileProto_DemoModeDimensions& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto_DemoModeDimensions* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto.DemoModeDimensions";
  }
  protected:
  explicit SystemProfileProto_DemoModeDimensions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef SystemProfileProto_DemoModeDimensions_Retailer Retailer;

  typedef SystemProfileProto_DemoModeDimensions_CustomizationFacet CustomizationFacet;
  static constexpr CustomizationFacet UNDEFINED =
    SystemProfileProto_DemoModeDimensions_CustomizationFacet_UNDEFINED;
  static constexpr CustomizationFacet CLOUD_GAMING_DEVICE =
    SystemProfileProto_DemoModeDimensions_CustomizationFacet_CLOUD_GAMING_DEVICE;
  static constexpr CustomizationFacet FEATURE_AWARE_DEVICE =
    SystemProfileProto_DemoModeDimensions_CustomizationFacet_FEATURE_AWARE_DEVICE;
  static inline bool CustomizationFacet_IsValid(int value) {
    return SystemProfileProto_DemoModeDimensions_CustomizationFacet_IsValid(value);
  }
  static constexpr CustomizationFacet CustomizationFacet_MIN =
    SystemProfileProto_DemoModeDimensions_CustomizationFacet_CustomizationFacet_MIN;
  static constexpr CustomizationFacet CustomizationFacet_MAX =
    SystemProfileProto_DemoModeDimensions_CustomizationFacet_CustomizationFacet_MAX;
  static constexpr int CustomizationFacet_ARRAYSIZE =
    SystemProfileProto_DemoModeDimensions_CustomizationFacet_CustomizationFacet_ARRAYSIZE;
  template<typename T>
  static inline const std::string& CustomizationFacet_Name(T enum_t_value) {
    static_assert(::std::is_same<T, CustomizationFacet>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function CustomizationFacet_Name.");
    return SystemProfileProto_DemoModeDimensions_CustomizationFacet_Name(enum_t_value);
  }
  static inline bool CustomizationFacet_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      CustomizationFacet* value) {
    return SystemProfileProto_DemoModeDimensions_CustomizationFacet_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kCustomizationFacetFieldNumber = 3,
    kCountryFieldNumber = 1,
    kAppVersionFieldNumber = 4,
    kResourcesVersionFieldNumber = 5,
    kRetailerFieldNumber = 2,
  };
  // repeated .metrics.SystemProfileProto.DemoModeDimensions.CustomizationFacet customization_facet = 3 [packed = true];
  int customization_facet_size() const;
  private:
  int _internal_customization_facet_size() const;
  public:
  void clear_customization_facet();
  private:
  ::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet _internal_customization_facet(int index) const;
  void _internal_add_customization_facet(::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_customization_facet();
  public:
  ::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet customization_facet(int index) const;
  void set_customization_facet(int index, ::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet value);
  void add_customization_facet(::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& customization_facet() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_customization_facet();

  // optional string country = 1;
  bool has_country() const;
  private:
  bool _internal_has_country() const;
  public:
  void clear_country();
  const std::string& country() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_country(ArgT0&& arg0, ArgT... args);
  std::string* mutable_country();
  PROTOBUF_NODISCARD std::string* release_country();
  void set_allocated_country(std::string* country);
  private:
  const std::string& _internal_country() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_country(const std::string& value);
  std::string* _internal_mutable_country();
  public:

  // optional string app_version = 4;
  bool has_app_version() const;
  private:
  bool _internal_has_app_version() const;
  public:
  void clear_app_version();
  const std::string& app_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_app_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_app_version();
  PROTOBUF_NODISCARD std::string* release_app_version();
  void set_allocated_app_version(std::string* app_version);
  private:
  const std::string& _internal_app_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_app_version(const std::string& value);
  std::string* _internal_mutable_app_version();
  public:

  // optional string resources_version = 5;
  bool has_resources_version() const;
  private:
  bool _internal_has_resources_version() const;
  public:
  void clear_resources_version();
  const std::string& resources_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_resources_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_resources_version();
  PROTOBUF_NODISCARD std::string* release_resources_version();
  void set_allocated_resources_version(std::string* resources_version);
  private:
  const std::string& _internal_resources_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_resources_version(const std::string& value);
  std::string* _internal_mutable_resources_version();
  public:

  // optional .metrics.SystemProfileProto.DemoModeDimensions.Retailer retailer = 2;
  bool has_retailer() const;
  private:
  bool _internal_has_retailer() const;
  public:
  void clear_retailer();
  const ::metrics::SystemProfileProto_DemoModeDimensions_Retailer& retailer() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* release_retailer();
  ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* mutable_retailer();
  void set_allocated_retailer(::metrics::SystemProfileProto_DemoModeDimensions_Retailer* retailer);
  private:
  const ::metrics::SystemProfileProto_DemoModeDimensions_Retailer& _internal_retailer() const;
  ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* _internal_mutable_retailer();
  public:
  void unsafe_arena_set_allocated_retailer(
      ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* retailer);
  ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* unsafe_arena_release_retailer();

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto.DemoModeDimensions)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> customization_facet_;
    mutable std::atomic<int> _customization_facet_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr country_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr app_version_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr resources_version_;
    ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* retailer_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// -------------------------------------------------------------------

class SystemProfileProto final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.SystemProfileProto) */ {
 public:
  inline SystemProfileProto() : SystemProfileProto(nullptr) {}
  ~SystemProfileProto() override;
  explicit PROTOBUF_CONSTEXPR SystemProfileProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SystemProfileProto(const SystemProfileProto& from);
  SystemProfileProto(SystemProfileProto&& from) noexcept
    : SystemProfileProto() {
    *this = ::std::move(from);
  }

  inline SystemProfileProto& operator=(const SystemProfileProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline SystemProfileProto& operator=(SystemProfileProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemProfileProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemProfileProto* internal_default_instance() {
    return reinterpret_cast<const SystemProfileProto*>(
               &_SystemProfileProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  friend void swap(SystemProfileProto& a, SystemProfileProto& b) {
    a.Swap(&b);
  }
  PROTOBUF_NOINLINE void Swap(SystemProfileProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemProfileProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SystemProfileProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemProfileProto>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SystemProfileProto& from);
  void MergeFrom(const SystemProfileProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SystemProfileProto* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "metrics.SystemProfileProto";
  }
  protected:
  explicit SystemProfileProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef SystemProfileProto_ClonedInstallInfo ClonedInstallInfo;
  typedef SystemProfileProto_OS OS;
  typedef SystemProfileProto_Hardware Hardware;
  typedef SystemProfileProto_Network Network;
  typedef SystemProfileProto_GoogleUpdate GoogleUpdate;
  typedef SystemProfileProto_Stability Stability;
  typedef SystemProfileProto_FieldTrial FieldTrial;
  typedef SystemProfileProto_ExternalAudioVideoDevice ExternalAudioVideoDevice;
  typedef SystemProfileProto_ExternalAccessPoint ExternalAccessPoint;
  typedef SystemProfileProto_AntiVirusProduct AntiVirusProduct;
  typedef SystemProfileProto_ChromeComponent ChromeComponent;
  typedef SystemProfileProto_LinkedAndroidPhoneData LinkedAndroidPhoneData;
  typedef SystemProfileProto_DemoModeDimensions DemoModeDimensions;

  typedef SystemProfileProto_Channel Channel;
  static constexpr Channel CHANNEL_UNKNOWN =
    SystemProfileProto_Channel_CHANNEL_UNKNOWN;
  static constexpr Channel CHANNEL_CANARY =
    SystemProfileProto_Channel_CHANNEL_CANARY;
  static constexpr Channel CHANNEL_DEV =
    SystemProfileProto_Channel_CHANNEL_DEV;
  static constexpr Channel CHANNEL_BETA =
    SystemProfileProto_Channel_CHANNEL_BETA;
  static constexpr Channel CHANNEL_STABLE =
    SystemProfileProto_Channel_CHANNEL_STABLE;
  static inline bool Channel_IsValid(int value) {
    return SystemProfileProto_Channel_IsValid(value);
  }
  static constexpr Channel Channel_MIN =
    SystemProfileProto_Channel_Channel_MIN;
  static constexpr Channel Channel_MAX =
    SystemProfileProto_Channel_Channel_MAX;
  static constexpr int Channel_ARRAYSIZE =
    SystemProfileProto_Channel_Channel_ARRAYSIZE;
  template<typename T>
  static inline const std::string& Channel_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Channel>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Channel_Name.");
    return SystemProfileProto_Channel_Name(enum_t_value);
  }
  static inline bool Channel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Channel* value) {
    return SystemProfileProto_Channel_Parse(name, value);
  }

  typedef SystemProfileProto_ExtensionsState ExtensionsState;
  static constexpr ExtensionsState NO_EXTENSIONS =
    SystemProfileProto_ExtensionsState_NO_EXTENSIONS;
  static constexpr ExtensionsState NO_OFFSTORE_VERIFIED =
    SystemProfileProto_ExtensionsState_NO_OFFSTORE_VERIFIED;
  static constexpr ExtensionsState NO_OFFSTORE_UNVERIFIED =
    SystemProfileProto_ExtensionsState_NO_OFFSTORE_UNVERIFIED;
  static constexpr ExtensionsState HAS_OFFSTORE =
    SystemProfileProto_ExtensionsState_HAS_OFFSTORE;
  static inline bool ExtensionsState_IsValid(int value) {
    return SystemProfileProto_ExtensionsState_IsValid(value);
  }
  static constexpr ExtensionsState ExtensionsState_MIN =
    SystemProfileProto_ExtensionsState_ExtensionsState_MIN;
  static constexpr ExtensionsState ExtensionsState_MAX =
    SystemProfileProto_ExtensionsState_ExtensionsState_MAX;
  static constexpr int ExtensionsState_ARRAYSIZE =
    SystemProfileProto_ExtensionsState_ExtensionsState_ARRAYSIZE;
  template<typename T>
  static inline const std::string& ExtensionsState_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ExtensionsState>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ExtensionsState_Name.");
    return SystemProfileProto_ExtensionsState_Name(enum_t_value);
  }
  static inline bool ExtensionsState_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ExtensionsState* value) {
    return SystemProfileProto_ExtensionsState_Parse(name, value);
  }

  typedef SystemProfileProto_UmaDefaultState UmaDefaultState;
  static constexpr UmaDefaultState OPT_IN =
    SystemProfileProto_UmaDefaultState_OPT_IN;
  static constexpr UmaDefaultState OPT_OUT =
    SystemProfileProto_UmaDefaultState_OPT_OUT;
  static constexpr UmaDefaultState POLICY_FORCED_ENABLED =
    SystemProfileProto_UmaDefaultState_POLICY_FORCED_ENABLED;
  static constexpr UmaDefaultState OPT_UNKNOWN =
    SystemProfileProto_UmaDefaultState_OPT_UNKNOWN;
  static inline bool UmaDefaultState_IsValid(int value) {
    return SystemProfileProto_UmaDefaultState_IsValid(value);
  }
  static constexpr UmaDefaultState UmaDefaultState_MIN =
    SystemProfileProto_UmaDefaultState_UmaDefaultState_MIN;
  static constexpr UmaDefaultState UmaDefaultState_MAX =
    SystemProfileProto_UmaDefaultState_UmaDefaultState_MAX;
  static constexpr int UmaDefaultState_ARRAYSIZE =
    SystemProfileProto_UmaDefaultState_UmaDefaultState_ARRAYSIZE;
  template<typename T>
  static inline const std::string& UmaDefaultState_Name(T enum_t_value) {
    static_assert(::std::is_same<T, UmaDefaultState>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function UmaDefaultState_Name.");
    return SystemProfileProto_UmaDefaultState_Name(enum_t_value);
  }
  static inline bool UmaDefaultState_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      UmaDefaultState* value) {
    return SystemProfileProto_UmaDefaultState_Parse(name, value);
  }

  typedef SystemProfileProto_AntiVirusState AntiVirusState;
  static constexpr AntiVirusState STATE_ON =
    SystemProfileProto_AntiVirusState_STATE_ON;
  static constexpr AntiVirusState STATE_OFF =
    SystemProfileProto_AntiVirusState_STATE_OFF;
  static constexpr AntiVirusState STATE_SNOOZED =
    SystemProfileProto_AntiVirusState_STATE_SNOOZED;
  static constexpr AntiVirusState STATE_EXPIRED =
    SystemProfileProto_AntiVirusState_STATE_EXPIRED;
  static inline bool AntiVirusState_IsValid(int value) {
    return SystemProfileProto_AntiVirusState_IsValid(value);
  }
  static constexpr AntiVirusState AntiVirusState_MIN =
    SystemProfileProto_AntiVirusState_AntiVirusState_MIN;
  static constexpr AntiVirusState AntiVirusState_MAX =
    SystemProfileProto_AntiVirusState_AntiVirusState_MAX;
  static constexpr int AntiVirusState_ARRAYSIZE =
    SystemProfileProto_AntiVirusState_AntiVirusState_ARRAYSIZE;
  template<typename T>
  static inline const std::string& AntiVirusState_Name(T enum_t_value) {
    static_assert(::std::is_same<T, AntiVirusState>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function AntiVirusState_Name.");
    return SystemProfileProto_AntiVirusState_Name(enum_t_value);
  }
  static inline bool AntiVirusState_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      AntiVirusState* value) {
    return SystemProfileProto_AntiVirusState_Parse(name, value);
  }

  typedef SystemProfileProto_ComponentId ComponentId;
  static constexpr ComponentId UNKNOWN =
    SystemProfileProto_ComponentId_UNKNOWN;
  static constexpr ComponentId FILE_TYPE_POLICIES =
    SystemProfileProto_ComponentId_FILE_TYPE_POLICIES;
  static constexpr ComponentId ORIGIN_TRIALS =
    SystemProfileProto_ComponentId_ORIGIN_TRIALS;
  static constexpr ComponentId PEPPER_FLASH =
    SystemProfileProto_ComponentId_PEPPER_FLASH;
  static constexpr ComponentId PEPPER_FLASH_CHROMEOS =
    SystemProfileProto_ComponentId_PEPPER_FLASH_CHROMEOS;
  static constexpr ComponentId PNACL =
    SystemProfileProto_ComponentId_PNACL;
  static constexpr ComponentId RECOVERY =
    SystemProfileProto_ComponentId_RECOVERY;
  static constexpr ComponentId SSL_ERROR_ASSISTANT =
    SystemProfileProto_ComponentId_SSL_ERROR_ASSISTANT;
  static constexpr ComponentId STH_SET =
    SystemProfileProto_ComponentId_STH_SET;
  static constexpr ComponentId CRL_SET =
    SystemProfileProto_ComponentId_CRL_SET;
  static constexpr ComponentId SUBRESOURCE_FILTER =
    SystemProfileProto_ComponentId_SUBRESOURCE_FILTER;
  static constexpr ComponentId SW_REPORTER =
    SystemProfileProto_ComponentId_SW_REPORTER;
  static constexpr ComponentId WIDEVINE_CDM =
    SystemProfileProto_ComponentId_WIDEVINE_CDM;
  static constexpr ComponentId EPSON_INKJET_PRINTER_ESCPR =
    SystemProfileProto_ComponentId_EPSON_INKJET_PRINTER_ESCPR;
  static constexpr ComponentId CROS_TERMINA =
    SystemProfileProto_ComponentId_CROS_TERMINA;
  static constexpr ComponentId STAR_CUPS_DRIVER =
    SystemProfileProto_ComponentId_STAR_CUPS_DRIVER;
  static constexpr ComponentId SPEECH_SYNTHESIS_SV_SE =
    SystemProfileProto_ComponentId_SPEECH_SYNTHESIS_SV_SE;
  static constexpr ComponentId OPTIMIZATION_HINTS =
    SystemProfileProto_ComponentId_OPTIMIZATION_HINTS;
  static constexpr ComponentId DOWNLOADABLE_STRINGS =
    SystemProfileProto_ComponentId_DOWNLOADABLE_STRINGS;
  static constexpr ComponentId VR_ASSETS =
    SystemProfileProto_ComponentId_VR_ASSETS;
  static constexpr ComponentId RTANALYTICS_LIGHT =
    SystemProfileProto_ComponentId_RTANALYTICS_LIGHT;
  static constexpr ComponentId RTANALYTICS_FULL =
    SystemProfileProto_ComponentId_RTANALYTICS_FULL;
  static constexpr ComponentId CELLULAR =
    SystemProfileProto_ComponentId_CELLULAR;
  static constexpr ComponentId DEMO_MODE_RESOURCES =
    SystemProfileProto_ComponentId_DEMO_MODE_RESOURCES;
  static constexpr ComponentId ON_DEVICE_HEAD_SUGGEST =
    SystemProfileProto_ComponentId_ON_DEVICE_HEAD_SUGGEST;
  static constexpr ComponentId CROS_SMART_DIM =
    SystemProfileProto_ComponentId_CROS_SMART_DIM;
  static constexpr ComponentId ZXCVBN_DATA =
    SystemProfileProto_ComponentId_ZXCVBN_DATA;
  static constexpr ComponentId AUTOFILL_REGEX_CONSTANTS =
    SystemProfileProto_ComponentId_AUTOFILL_REGEX_CONSTANTS;
  static constexpr ComponentId WEBVIEW_APPS_PACKAGE_NAMES_ALLOWLIST =
    SystemProfileProto_ComponentId_WEBVIEW_APPS_PACKAGE_NAMES_ALLOWLIST;
  static constexpr ComponentId MEDIA_FOUNDATION_WIDEVINE_CDM =
    SystemProfileProto_ComponentId_MEDIA_FOUNDATION_WIDEVINE_CDM;
  static constexpr ComponentId CROWD_DENY =
    SystemProfileProto_ComponentId_CROWD_DENY;
  static constexpr ComponentId APP_PROVISIONING =
    SystemProfileProto_ComponentId_APP_PROVISIONING;
  static constexpr ComponentId AUTOFILL_STATES =
    SystemProfileProto_ComponentId_AUTOFILL_STATES;
  static constexpr ComponentId CLIENT_SIDE_PHISHING =
    SystemProfileProto_ComponentId_CLIENT_SIDE_PHISHING;
  static constexpr ComponentId COMMERCE_HEURISTICS =
    SystemProfileProto_ComponentId_COMMERCE_HEURISTICS;
  static constexpr ComponentId CROW_DOMAIN_LIST =
    SystemProfileProto_ComponentId_CROW_DOMAIN_LIST;
  static constexpr ComponentId DEMO_MODE_APP =
    SystemProfileProto_ComponentId_DEMO_MODE_APP;
  static constexpr ComponentId DESKTOP_SCREENSHOT_EDITOR =
    SystemProfileProto_ComponentId_DESKTOP_SCREENSHOT_EDITOR;
  static constexpr ComponentId DESKTOP_SHARING_HUB =
    SystemProfileProto_ComponentId_DESKTOP_SHARING_HUB;
  static constexpr ComponentId FIRST_PARTY_SETS =
    SystemProfileProto_ComponentId_FIRST_PARTY_SETS;
  static constexpr ComponentId HYPHENATION =
    SystemProfileProto_ComponentId_HYPHENATION;
  static constexpr ComponentId INTERVENTION_POLICY_DATABASE =
    SystemProfileProto_ComponentId_INTERVENTION_POLICY_DATABASE;
  static constexpr ComponentId LACROS_DOGFOOD_BETA =
    SystemProfileProto_ComponentId_LACROS_DOGFOOD_BETA;
  static constexpr ComponentId LACROS_DOGFOOD_CANARY =
    SystemProfileProto_ComponentId_LACROS_DOGFOOD_CANARY;
  static constexpr ComponentId LACROS_DOGFOOD_DEV =
    SystemProfileProto_ComponentId_LACROS_DOGFOOD_DEV;
  static constexpr ComponentId LACROS_DOGFOOD_STABLE =
    SystemProfileProto_ComponentId_LACROS_DOGFOOD_STABLE;
  static constexpr ComponentId MEI_PRELOAD =
    SystemProfileProto_ComponentId_MEI_PRELOAD;
  static constexpr ComponentId PKI_METADATA =
    SystemProfileProto_ComponentId_PKI_METADATA;
  static constexpr ComponentId REAL_TIME_URL_CHECKS_ALLOWLIST =
    SystemProfileProto_ComponentId_REAL_TIME_URL_CHECKS_ALLOWLIST;
  static constexpr ComponentId RECOVERY_IMPROVED =
    SystemProfileProto_ComponentId_RECOVERY_IMPROVED;
  static constexpr ComponentId SAFETY_TIPS =
    SystemProfileProto_ComponentId_SAFETY_TIPS;
  static constexpr ComponentId SCREEN_AI =
    SystemProfileProto_ComponentId_SCREEN_AI;
  static constexpr ComponentId SMART_DIM =
    SystemProfileProto_ComponentId_SMART_DIM;
  static constexpr ComponentId SODA =
    SystemProfileProto_ComponentId_SODA;
  static constexpr ComponentId SODA_DE_DE =
    SystemProfileProto_ComponentId_SODA_DE_DE;
  static constexpr ComponentId SODA_EN_US =
    SystemProfileProto_ComponentId_SODA_EN_US;
  static constexpr ComponentId SODA_ES_ES =
    SystemProfileProto_ComponentId_SODA_ES_ES;
  static constexpr ComponentId SODA_FR_FR =
    SystemProfileProto_ComponentId_SODA_FR_FR;
  static constexpr ComponentId SODA_IT_IT =
    SystemProfileProto_ComponentId_SODA_IT_IT;
  static constexpr ComponentId SODA_JA_JP =
    SystemProfileProto_ComponentId_SODA_JA_JP;
  static constexpr ComponentId THIRD_PARTY_MODULE_LIST =
    SystemProfileProto_ComponentId_THIRD_PARTY_MODULE_LIST;
  static constexpr ComponentId TRUST_TOKEN_KEY_COMMITMENTS =
    SystemProfileProto_ComponentId_TRUST_TOKEN_KEY_COMMITMENTS;
  static constexpr ComponentId THIRD_PARTY_COOKIE_DEPRECATION_METADATA =
    SystemProfileProto_ComponentId_THIRD_PARTY_COOKIE_DEPRECATION_METADATA;
  static constexpr ComponentId GROWTH_CAMPAIGNS =
    SystemProfileProto_ComponentId_GROWTH_CAMPAIGNS;
  static inline bool ComponentId_IsValid(int value) {
    return SystemProfileProto_ComponentId_IsValid(value);
  }
  static constexpr ComponentId ComponentId_MIN =
    SystemProfileProto_ComponentId_ComponentId_MIN;
  static constexpr ComponentId ComponentId_MAX =
    SystemProfileProto_ComponentId_ComponentId_MAX;
  static constexpr int ComponentId_ARRAYSIZE =
    SystemProfileProto_ComponentId_ComponentId_ARRAYSIZE;
  template<typename T>
  static inline const std::string& ComponentId_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ComponentId>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ComponentId_Name.");
    return SystemProfileProto_ComponentId_Name(enum_t_value);
  }
  static inline bool ComponentId_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ComponentId* value) {
    return SystemProfileProto_ComponentId_Parse(name, value);
  }

  typedef SystemProfileProto_AppPackageNameAllowlistFilter AppPackageNameAllowlistFilter;
  static constexpr AppPackageNameAllowlistFilter SERVER_SIDE_FILTER_UNSPECIFIED =
    SystemProfileProto_AppPackageNameAllowlistFilter_SERVER_SIDE_FILTER_UNSPECIFIED;
  static constexpr AppPackageNameAllowlistFilter SERVER_SIDE_FILTER_REQUIRED =
    SystemProfileProto_AppPackageNameAllowlistFilter_SERVER_SIDE_FILTER_REQUIRED;
  static constexpr AppPackageNameAllowlistFilter NO_SERVER_SIDE_FILTER_REQUIRED_FOR_SYSTEM_APPS =
    SystemProfileProto_AppPackageNameAllowlistFilter_NO_SERVER_SIDE_FILTER_REQUIRED_FOR_SYSTEM_APPS;
  static inline bool AppPackageNameAllowlistFilter_IsValid(int value) {
    return SystemProfileProto_AppPackageNameAllowlistFilter_IsValid(value);
  }
  static constexpr AppPackageNameAllowlistFilter AppPackageNameAllowlistFilter_MIN =
    SystemProfileProto_AppPackageNameAllowlistFilter_AppPackageNameAllowlistFilter_MIN;
  static constexpr AppPackageNameAllowlistFilter AppPackageNameAllowlistFilter_MAX =
    SystemProfileProto_AppPackageNameAllowlistFilter_AppPackageNameAllowlistFilter_MAX;
  static constexpr int AppPackageNameAllowlistFilter_ARRAYSIZE =
    SystemProfileProto_AppPackageNameAllowlistFilter_AppPackageNameAllowlistFilter_ARRAYSIZE;
  template<typename T>
  static inline const std::string& AppPackageNameAllowlistFilter_Name(T enum_t_value) {
    static_assert(::std::is_same<T, AppPackageNameAllowlistFilter>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function AppPackageNameAllowlistFilter_Name.");
    return SystemProfileProto_AppPackageNameAllowlistFilter_Name(enum_t_value);
  }
  static inline bool AppPackageNameAllowlistFilter_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      AppPackageNameAllowlistFilter* value) {
    return SystemProfileProto_AppPackageNameAllowlistFilter_Parse(name, value);
  }

  typedef SystemProfileProto_ClientSideSamplingStatus ClientSideSamplingStatus;
  static constexpr ClientSideSamplingStatus SAMPLING_UNKNOWN =
    SystemProfileProto_ClientSideSamplingStatus_SAMPLING_UNKNOWN;
  static constexpr ClientSideSamplingStatus SAMPLING_APPLIED =
    SystemProfileProto_ClientSideSamplingStatus_SAMPLING_APPLIED;
  static constexpr ClientSideSamplingStatus SAMPLING_NOT_APPLIED =
    SystemProfileProto_ClientSideSamplingStatus_SAMPLING_NOT_APPLIED;
  static inline bool ClientSideSamplingStatus_IsValid(int value) {
    return SystemProfileProto_ClientSideSamplingStatus_IsValid(value);
  }
  static constexpr ClientSideSamplingStatus ClientSideSamplingStatus_MIN =
    SystemProfileProto_ClientSideSamplingStatus_ClientSideSamplingStatus_MIN;
  static constexpr ClientSideSamplingStatus ClientSideSamplingStatus_MAX =
    SystemProfileProto_ClientSideSamplingStatus_ClientSideSamplingStatus_MAX;
  static constexpr int ClientSideSamplingStatus_ARRAYSIZE =
    SystemProfileProto_ClientSideSamplingStatus_ClientSideSamplingStatus_ARRAYSIZE;
  template<typename T>
  static inline const std::string& ClientSideSamplingStatus_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ClientSideSamplingStatus>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ClientSideSamplingStatus_Name.");
    return SystemProfileProto_ClientSideSamplingStatus_Name(enum_t_value);
  }
  static inline bool ClientSideSamplingStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ClientSideSamplingStatus* value) {
    return SystemProfileProto_ClientSideSamplingStatus_Parse(name, value);
  }

  typedef SystemProfileProto_MetricsFilteringStatus MetricsFilteringStatus;
  static constexpr MetricsFilteringStatus METRICS_UNKNOWN =
    SystemProfileProto_MetricsFilteringStatus_METRICS_UNKNOWN;
  static constexpr MetricsFilteringStatus METRICS_ALL =
    SystemProfileProto_MetricsFilteringStatus_METRICS_ALL;
  static constexpr MetricsFilteringStatus METRICS_ONLY_CRITICAL =
    SystemProfileProto_MetricsFilteringStatus_METRICS_ONLY_CRITICAL;
  static inline bool MetricsFilteringStatus_IsValid(int value) {
    return SystemProfileProto_MetricsFilteringStatus_IsValid(value);
  }
  static constexpr MetricsFilteringStatus MetricsFilteringStatus_MIN =
    SystemProfileProto_MetricsFilteringStatus_MetricsFilteringStatus_MIN;
  static constexpr MetricsFilteringStatus MetricsFilteringStatus_MAX =
    SystemProfileProto_MetricsFilteringStatus_MetricsFilteringStatus_MAX;
  static constexpr int MetricsFilteringStatus_ARRAYSIZE =
    SystemProfileProto_MetricsFilteringStatus_MetricsFilteringStatus_ARRAYSIZE;
  template<typename T>
  static inline const std::string& MetricsFilteringStatus_Name(T enum_t_value) {
    static_assert(::std::is_same<T, MetricsFilteringStatus>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function MetricsFilteringStatus_Name.");
    return SystemProfileProto_MetricsFilteringStatus_Name(enum_t_value);
  }
  static inline bool MetricsFilteringStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      MetricsFilteringStatus* value) {
    return SystemProfileProto_MetricsFilteringStatus_Parse(name, value);
  }

  typedef SystemProfileProto_InstallerPackage InstallerPackage;
  static constexpr InstallerPackage INSTALLER_PACKAGE_UNKNOWN =
    SystemProfileProto_InstallerPackage_INSTALLER_PACKAGE_UNKNOWN;
  static constexpr InstallerPackage INSTALLER_PACKAGE_NONE =
    SystemProfileProto_InstallerPackage_INSTALLER_PACKAGE_NONE;
  static constexpr InstallerPackage INSTALLER_PACKAGE_GOOGLE_PLAY_STORE =
    SystemProfileProto_InstallerPackage_INSTALLER_PACKAGE_GOOGLE_PLAY_STORE;
  static constexpr InstallerPackage INSTALLER_PACKAGE_OTHER =
    SystemProfileProto_InstallerPackage_INSTALLER_PACKAGE_OTHER;
  static inline bool InstallerPackage_IsValid(int value) {
    return SystemProfileProto_InstallerPackage_IsValid(value);
  }
  static constexpr InstallerPackage InstallerPackage_MIN =
    SystemProfileProto_InstallerPackage_InstallerPackage_MIN;
  static constexpr InstallerPackage InstallerPackage_MAX =
    SystemProfileProto_InstallerPackage_InstallerPackage_MAX;
  static constexpr int InstallerPackage_ARRAYSIZE =
    SystemProfileProto_InstallerPackage_InstallerPackage_ARRAYSIZE;
  template<typename T>
  static inline const std::string& InstallerPackage_Name(T enum_t_value) {
    static_assert(::std::is_same<T, InstallerPackage>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function InstallerPackage_Name.");
    return SystemProfileProto_InstallerPackage_Name(enum_t_value);
  }
  static inline bool InstallerPackage_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      InstallerPackage* value) {
    return SystemProfileProto_InstallerPackage_Parse(name, value);
  }

  typedef SystemProfileProto_LTSChannel LTSChannel;
  static constexpr LTSChannel LTS_CHANNEL_UNKNOWN =
    SystemProfileProto_LTSChannel_LTS_CHANNEL_UNKNOWN;
  static constexpr LTSChannel LTS_CHANNEL_STABLE =
    SystemProfileProto_LTSChannel_LTS_CHANNEL_STABLE;
  static constexpr LTSChannel LTS_CHANNEL_LTC =
    SystemProfileProto_LTSChannel_LTS_CHANNEL_LTC;
  static constexpr LTSChannel LTS_CHANNEL_LTS =
    SystemProfileProto_LTSChannel_LTS_CHANNEL_LTS;
  static inline bool LTSChannel_IsValid(int value) {
    return SystemProfileProto_LTSChannel_IsValid(value);
  }
  static constexpr LTSChannel LTSChannel_MIN =
    SystemProfileProto_LTSChannel_LTSChannel_MIN;
  static constexpr LTSChannel LTSChannel_MAX =
    SystemProfileProto_LTSChannel_LTSChannel_MAX;
  static constexpr int LTSChannel_ARRAYSIZE =
    SystemProfileProto_LTSChannel_LTSChannel_ARRAYSIZE;
  template<typename T>
  static inline const std::string& LTSChannel_Name(T enum_t_value) {
    static_assert(::std::is_same<T, LTSChannel>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function LTSChannel_Name.");
    return SystemProfileProto_LTSChannel_Name(enum_t_value);
  }
  static inline bool LTSChannel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      LTSChannel* value) {
    return SystemProfileProto_LTSChannel_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kFieldTrialFieldNumber = 9,
    kExternalAudioVideoDeviceFieldNumber = 14,
    kOccupiedExtensionBucketFieldNumber = 18,
    kAntivirusProductFieldNumber = 23,
    kChromeComponentFieldNumber = 24,
    kExtensionInstallFieldNumber = 25,
    kCommandLineKeyHashFieldNumber = 38,
    kAppVersionFieldNumber = 2,
    kApplicationLocaleFieldNumber = 4,
    kBrandCodeFieldNumber = 12,
    kAppPackageNameFieldNumber = 26,
    kVariationsSeedVersionFieldNumber = 28,
    kClientUuidFieldNumber = 34,
    kLogWrittenByAppVersionFieldNumber = 40,
    kOsFieldNumber = 5,
    kHardwareFieldNumber = 6,
    kStabilityFieldNumber = 8,
    kGoogleUpdateFieldNumber = 11,
    kNetworkFieldNumber = 13,
    kExternalAccessPointFieldNumber = 15,
    kLinkedAndroidPhoneDataFieldNumber = 29,
    kClonedInstallInfoFieldNumber = 39,
    kDemoModeDimensionsFieldNumber = 41,
    kBuildTimestampFieldNumber = 1,
    kUmaEnabledDateFieldNumber = 3,
    kChannelFieldNumber = 10,
    kMultiProfileUserCountFieldNumber = 17,
    kInstallDateFieldNumber = 16,
    kOffstoreExtensionsStateFieldNumber = 19,
    kUmaDefaultStateFieldNumber = 22,
    kIsExtendedStableChannelFieldNumber = 36,
    kIsInstrumentedBuildFieldNumber = 20,
    kClientIdWasUsedForTrialAssignmentFieldNumber = 33,
    kLowEntropySourceFieldNumber = 31,
    kOldLowEntropySourceFieldNumber = 32,
    kInstallerPackageFieldNumber = 35,
    kPseudoLowEntropySourceFieldNumber = 37,
    kAppPackageNameAllowlistFilterFieldNumber = 42,
    kClientSideSamplingStatusFieldNumber = 43,
    kMetricsFilteringStatusFieldNumber = 44,
    kSessionHashFieldNumber = 46,
    kLtsChannelFieldNumber = 45,
  };
  // repeated .metrics.SystemProfileProto.FieldTrial field_trial = 9;
  int field_trial_size() const;
  private:
  int _internal_field_trial_size() const;
  public:
  void clear_field_trial();
  ::metrics::SystemProfileProto_FieldTrial* mutable_field_trial(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_FieldTrial >*
      mutable_field_trial();
  private:
  const ::metrics::SystemProfileProto_FieldTrial& _internal_field_trial(int index) const;
  ::metrics::SystemProfileProto_FieldTrial* _internal_add_field_trial();
  public:
  const ::metrics::SystemProfileProto_FieldTrial& field_trial(int index) const;
  ::metrics::SystemProfileProto_FieldTrial* add_field_trial();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_FieldTrial >&
      field_trial() const;

  // repeated .metrics.SystemProfileProto.ExternalAudioVideoDevice external_audio_video_device = 14;
  int external_audio_video_device_size() const;
  private:
  int _internal_external_audio_video_device_size() const;
  public:
  void clear_external_audio_video_device();
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice* mutable_external_audio_video_device(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice >*
      mutable_external_audio_video_device();
  private:
  const ::metrics::SystemProfileProto_ExternalAudioVideoDevice& _internal_external_audio_video_device(int index) const;
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice* _internal_add_external_audio_video_device();
  public:
  const ::metrics::SystemProfileProto_ExternalAudioVideoDevice& external_audio_video_device(int index) const;
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice* add_external_audio_video_device();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice >&
      external_audio_video_device() const;

  // repeated int32 occupied_extension_bucket = 18;
  int occupied_extension_bucket_size() const;
  private:
  int _internal_occupied_extension_bucket_size() const;
  public:
  void clear_occupied_extension_bucket();
  private:
  int32_t _internal_occupied_extension_bucket(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_occupied_extension_bucket() const;
  void _internal_add_occupied_extension_bucket(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_occupied_extension_bucket();
  public:
  int32_t occupied_extension_bucket(int index) const;
  void set_occupied_extension_bucket(int index, int32_t value);
  void add_occupied_extension_bucket(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      occupied_extension_bucket() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_occupied_extension_bucket();

  // repeated .metrics.SystemProfileProto.AntiVirusProduct antivirus_product = 23;
  int antivirus_product_size() const;
  private:
  int _internal_antivirus_product_size() const;
  public:
  void clear_antivirus_product();
  ::metrics::SystemProfileProto_AntiVirusProduct* mutable_antivirus_product(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_AntiVirusProduct >*
      mutable_antivirus_product();
  private:
  const ::metrics::SystemProfileProto_AntiVirusProduct& _internal_antivirus_product(int index) const;
  ::metrics::SystemProfileProto_AntiVirusProduct* _internal_add_antivirus_product();
  public:
  const ::metrics::SystemProfileProto_AntiVirusProduct& antivirus_product(int index) const;
  ::metrics::SystemProfileProto_AntiVirusProduct* add_antivirus_product();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_AntiVirusProduct >&
      antivirus_product() const;

  // repeated .metrics.SystemProfileProto.ChromeComponent chrome_component = 24;
  int chrome_component_size() const;
  private:
  int _internal_chrome_component_size() const;
  public:
  void clear_chrome_component();
  ::metrics::SystemProfileProto_ChromeComponent* mutable_chrome_component(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ChromeComponent >*
      mutable_chrome_component();
  private:
  const ::metrics::SystemProfileProto_ChromeComponent& _internal_chrome_component(int index) const;
  ::metrics::SystemProfileProto_ChromeComponent* _internal_add_chrome_component();
  public:
  const ::metrics::SystemProfileProto_ChromeComponent& chrome_component(int index) const;
  ::metrics::SystemProfileProto_ChromeComponent* add_chrome_component();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ChromeComponent >&
      chrome_component() const;

  // repeated .metrics.ExtensionInstallProto extension_install = 25;
  int extension_install_size() const;
  private:
  int _internal_extension_install_size() const;
  public:
  void clear_extension_install();
  ::metrics::ExtensionInstallProto* mutable_extension_install(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::ExtensionInstallProto >*
      mutable_extension_install();
  private:
  const ::metrics::ExtensionInstallProto& _internal_extension_install(int index) const;
  ::metrics::ExtensionInstallProto* _internal_add_extension_install();
  public:
  const ::metrics::ExtensionInstallProto& extension_install(int index) const;
  ::metrics::ExtensionInstallProto* add_extension_install();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::ExtensionInstallProto >&
      extension_install() const;

  // repeated fixed32 command_line_key_hash = 38 [packed = true];
  int command_line_key_hash_size() const;
  private:
  int _internal_command_line_key_hash_size() const;
  public:
  void clear_command_line_key_hash();
  private:
  uint32_t _internal_command_line_key_hash(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_command_line_key_hash() const;
  void _internal_add_command_line_key_hash(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_command_line_key_hash();
  public:
  uint32_t command_line_key_hash(int index) const;
  void set_command_line_key_hash(int index, uint32_t value);
  void add_command_line_key_hash(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      command_line_key_hash() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_command_line_key_hash();

  // optional string app_version = 2;
  bool has_app_version() const;
  private:
  bool _internal_has_app_version() const;
  public:
  void clear_app_version();
  const std::string& app_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_app_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_app_version();
  PROTOBUF_NODISCARD std::string* release_app_version();
  void set_allocated_app_version(std::string* app_version);
  private:
  const std::string& _internal_app_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_app_version(const std::string& value);
  std::string* _internal_mutable_app_version();
  public:

  // optional string application_locale = 4;
  bool has_application_locale() const;
  private:
  bool _internal_has_application_locale() const;
  public:
  void clear_application_locale();
  const std::string& application_locale() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_application_locale(ArgT0&& arg0, ArgT... args);
  std::string* mutable_application_locale();
  PROTOBUF_NODISCARD std::string* release_application_locale();
  void set_allocated_application_locale(std::string* application_locale);
  private:
  const std::string& _internal_application_locale() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_application_locale(const std::string& value);
  std::string* _internal_mutable_application_locale();
  public:

  // optional string brand_code = 12;
  bool has_brand_code() const;
  private:
  bool _internal_has_brand_code() const;
  public:
  void clear_brand_code();
  const std::string& brand_code() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_brand_code(ArgT0&& arg0, ArgT... args);
  std::string* mutable_brand_code();
  PROTOBUF_NODISCARD std::string* release_brand_code();
  void set_allocated_brand_code(std::string* brand_code);
  private:
  const std::string& _internal_brand_code() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_brand_code(const std::string& value);
  std::string* _internal_mutable_brand_code();
  public:

  // optional string app_package_name = 26;
  bool has_app_package_name() const;
  private:
  bool _internal_has_app_package_name() const;
  public:
  void clear_app_package_name();
  const std::string& app_package_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_app_package_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_app_package_name();
  PROTOBUF_NODISCARD std::string* release_app_package_name();
  void set_allocated_app_package_name(std::string* app_package_name);
  private:
  const std::string& _internal_app_package_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_app_package_name(const std::string& value);
  std::string* _internal_mutable_app_package_name();
  public:

  // optional string variations_seed_version = 28;
  bool has_variations_seed_version() const;
  private:
  bool _internal_has_variations_seed_version() const;
  public:
  void clear_variations_seed_version();
  const std::string& variations_seed_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_variations_seed_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_variations_seed_version();
  PROTOBUF_NODISCARD std::string* release_variations_seed_version();
  void set_allocated_variations_seed_version(std::string* variations_seed_version);
  private:
  const std::string& _internal_variations_seed_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_variations_seed_version(const std::string& value);
  std::string* _internal_mutable_variations_seed_version();
  public:

  // optional string client_uuid = 34;
  bool has_client_uuid() const;
  private:
  bool _internal_has_client_uuid() const;
  public:
  void clear_client_uuid();
  const std::string& client_uuid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_client_uuid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_client_uuid();
  PROTOBUF_NODISCARD std::string* release_client_uuid();
  void set_allocated_client_uuid(std::string* client_uuid);
  private:
  const std::string& _internal_client_uuid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_uuid(const std::string& value);
  std::string* _internal_mutable_client_uuid();
  public:

  // optional string log_written_by_app_version = 40;
  bool has_log_written_by_app_version() const;
  private:
  bool _internal_has_log_written_by_app_version() const;
  public:
  void clear_log_written_by_app_version();
  const std::string& log_written_by_app_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_log_written_by_app_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_log_written_by_app_version();
  PROTOBUF_NODISCARD std::string* release_log_written_by_app_version();
  void set_allocated_log_written_by_app_version(std::string* log_written_by_app_version);
  private:
  const std::string& _internal_log_written_by_app_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_log_written_by_app_version(const std::string& value);
  std::string* _internal_mutable_log_written_by_app_version();
  public:

  // optional .metrics.SystemProfileProto.OS os = 5;
  bool has_os() const;
  private:
  bool _internal_has_os() const;
  public:
  void clear_os();
  const ::metrics::SystemProfileProto_OS& os() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_OS* release_os();
  ::metrics::SystemProfileProto_OS* mutable_os();
  void set_allocated_os(::metrics::SystemProfileProto_OS* os);
  private:
  const ::metrics::SystemProfileProto_OS& _internal_os() const;
  ::metrics::SystemProfileProto_OS* _internal_mutable_os();
  public:
  void unsafe_arena_set_allocated_os(
      ::metrics::SystemProfileProto_OS* os);
  ::metrics::SystemProfileProto_OS* unsafe_arena_release_os();

  // optional .metrics.SystemProfileProto.Hardware hardware = 6;
  bool has_hardware() const;
  private:
  bool _internal_has_hardware() const;
  public:
  void clear_hardware();
  const ::metrics::SystemProfileProto_Hardware& hardware() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_Hardware* release_hardware();
  ::metrics::SystemProfileProto_Hardware* mutable_hardware();
  void set_allocated_hardware(::metrics::SystemProfileProto_Hardware* hardware);
  private:
  const ::metrics::SystemProfileProto_Hardware& _internal_hardware() const;
  ::metrics::SystemProfileProto_Hardware* _internal_mutable_hardware();
  public:
  void unsafe_arena_set_allocated_hardware(
      ::metrics::SystemProfileProto_Hardware* hardware);
  ::metrics::SystemProfileProto_Hardware* unsafe_arena_release_hardware();

  // optional .metrics.SystemProfileProto.Stability stability = 8;
  bool has_stability() const;
  private:
  bool _internal_has_stability() const;
  public:
  void clear_stability();
  const ::metrics::SystemProfileProto_Stability& stability() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_Stability* release_stability();
  ::metrics::SystemProfileProto_Stability* mutable_stability();
  void set_allocated_stability(::metrics::SystemProfileProto_Stability* stability);
  private:
  const ::metrics::SystemProfileProto_Stability& _internal_stability() const;
  ::metrics::SystemProfileProto_Stability* _internal_mutable_stability();
  public:
  void unsafe_arena_set_allocated_stability(
      ::metrics::SystemProfileProto_Stability* stability);
  ::metrics::SystemProfileProto_Stability* unsafe_arena_release_stability();

  // optional .metrics.SystemProfileProto.GoogleUpdate google_update = 11;
  bool has_google_update() const;
  private:
  bool _internal_has_google_update() const;
  public:
  void clear_google_update();
  const ::metrics::SystemProfileProto_GoogleUpdate& google_update() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_GoogleUpdate* release_google_update();
  ::metrics::SystemProfileProto_GoogleUpdate* mutable_google_update();
  void set_allocated_google_update(::metrics::SystemProfileProto_GoogleUpdate* google_update);
  private:
  const ::metrics::SystemProfileProto_GoogleUpdate& _internal_google_update() const;
  ::metrics::SystemProfileProto_GoogleUpdate* _internal_mutable_google_update();
  public:
  void unsafe_arena_set_allocated_google_update(
      ::metrics::SystemProfileProto_GoogleUpdate* google_update);
  ::metrics::SystemProfileProto_GoogleUpdate* unsafe_arena_release_google_update();

  // optional .metrics.SystemProfileProto.Network network = 13;
  bool has_network() const;
  private:
  bool _internal_has_network() const;
  public:
  void clear_network();
  const ::metrics::SystemProfileProto_Network& network() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_Network* release_network();
  ::metrics::SystemProfileProto_Network* mutable_network();
  void set_allocated_network(::metrics::SystemProfileProto_Network* network);
  private:
  const ::metrics::SystemProfileProto_Network& _internal_network() const;
  ::metrics::SystemProfileProto_Network* _internal_mutable_network();
  public:
  void unsafe_arena_set_allocated_network(
      ::metrics::SystemProfileProto_Network* network);
  ::metrics::SystemProfileProto_Network* unsafe_arena_release_network();

  // optional .metrics.SystemProfileProto.ExternalAccessPoint external_access_point = 15;
  bool has_external_access_point() const;
  private:
  bool _internal_has_external_access_point() const;
  public:
  void clear_external_access_point();
  const ::metrics::SystemProfileProto_ExternalAccessPoint& external_access_point() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_ExternalAccessPoint* release_external_access_point();
  ::metrics::SystemProfileProto_ExternalAccessPoint* mutable_external_access_point();
  void set_allocated_external_access_point(::metrics::SystemProfileProto_ExternalAccessPoint* external_access_point);
  private:
  const ::metrics::SystemProfileProto_ExternalAccessPoint& _internal_external_access_point() const;
  ::metrics::SystemProfileProto_ExternalAccessPoint* _internal_mutable_external_access_point();
  public:
  void unsafe_arena_set_allocated_external_access_point(
      ::metrics::SystemProfileProto_ExternalAccessPoint* external_access_point);
  ::metrics::SystemProfileProto_ExternalAccessPoint* unsafe_arena_release_external_access_point();

  // optional .metrics.SystemProfileProto.LinkedAndroidPhoneData linked_android_phone_data = 29;
  bool has_linked_android_phone_data() const;
  private:
  bool _internal_has_linked_android_phone_data() const;
  public:
  void clear_linked_android_phone_data();
  const ::metrics::SystemProfileProto_LinkedAndroidPhoneData& linked_android_phone_data() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_LinkedAndroidPhoneData* release_linked_android_phone_data();
  ::metrics::SystemProfileProto_LinkedAndroidPhoneData* mutable_linked_android_phone_data();
  void set_allocated_linked_android_phone_data(::metrics::SystemProfileProto_LinkedAndroidPhoneData* linked_android_phone_data);
  private:
  const ::metrics::SystemProfileProto_LinkedAndroidPhoneData& _internal_linked_android_phone_data() const;
  ::metrics::SystemProfileProto_LinkedAndroidPhoneData* _internal_mutable_linked_android_phone_data();
  public:
  void unsafe_arena_set_allocated_linked_android_phone_data(
      ::metrics::SystemProfileProto_LinkedAndroidPhoneData* linked_android_phone_data);
  ::metrics::SystemProfileProto_LinkedAndroidPhoneData* unsafe_arena_release_linked_android_phone_data();

  // optional .metrics.SystemProfileProto.ClonedInstallInfo cloned_install_info = 39;
  bool has_cloned_install_info() const;
  private:
  bool _internal_has_cloned_install_info() const;
  public:
  void clear_cloned_install_info();
  const ::metrics::SystemProfileProto_ClonedInstallInfo& cloned_install_info() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_ClonedInstallInfo* release_cloned_install_info();
  ::metrics::SystemProfileProto_ClonedInstallInfo* mutable_cloned_install_info();
  void set_allocated_cloned_install_info(::metrics::SystemProfileProto_ClonedInstallInfo* cloned_install_info);
  private:
  const ::metrics::SystemProfileProto_ClonedInstallInfo& _internal_cloned_install_info() const;
  ::metrics::SystemProfileProto_ClonedInstallInfo* _internal_mutable_cloned_install_info();
  public:
  void unsafe_arena_set_allocated_cloned_install_info(
      ::metrics::SystemProfileProto_ClonedInstallInfo* cloned_install_info);
  ::metrics::SystemProfileProto_ClonedInstallInfo* unsafe_arena_release_cloned_install_info();

  // optional .metrics.SystemProfileProto.DemoModeDimensions demo_mode_dimensions = 41;
  bool has_demo_mode_dimensions() const;
  private:
  bool _internal_has_demo_mode_dimensions() const;
  public:
  void clear_demo_mode_dimensions();
  const ::metrics::SystemProfileProto_DemoModeDimensions& demo_mode_dimensions() const;
  PROTOBUF_NODISCARD ::metrics::SystemProfileProto_DemoModeDimensions* release_demo_mode_dimensions();
  ::metrics::SystemProfileProto_DemoModeDimensions* mutable_demo_mode_dimensions();
  void set_allocated_demo_mode_dimensions(::metrics::SystemProfileProto_DemoModeDimensions* demo_mode_dimensions);
  private:
  const ::metrics::SystemProfileProto_DemoModeDimensions& _internal_demo_mode_dimensions() const;
  ::metrics::SystemProfileProto_DemoModeDimensions* _internal_mutable_demo_mode_dimensions();
  public:
  void unsafe_arena_set_allocated_demo_mode_dimensions(
      ::metrics::SystemProfileProto_DemoModeDimensions* demo_mode_dimensions);
  ::metrics::SystemProfileProto_DemoModeDimensions* unsafe_arena_release_demo_mode_dimensions();

  // optional int64 build_timestamp = 1;
  bool has_build_timestamp() const;
  private:
  bool _internal_has_build_timestamp() const;
  public:
  void clear_build_timestamp();
  int64_t build_timestamp() const;
  void set_build_timestamp(int64_t value);
  private:
  int64_t _internal_build_timestamp() const;
  void _internal_set_build_timestamp(int64_t value);
  public:

  // optional int64 uma_enabled_date = 3;
  bool has_uma_enabled_date() const;
  private:
  bool _internal_has_uma_enabled_date() const;
  public:
  void clear_uma_enabled_date();
  int64_t uma_enabled_date() const;
  void set_uma_enabled_date(int64_t value);
  private:
  int64_t _internal_uma_enabled_date() const;
  void _internal_set_uma_enabled_date(int64_t value);
  public:

  // optional .metrics.SystemProfileProto.Channel channel = 10;
  bool has_channel() const;
  private:
  bool _internal_has_channel() const;
  public:
  void clear_channel();
  ::metrics::SystemProfileProto_Channel channel() const;
  void set_channel(::metrics::SystemProfileProto_Channel value);
  private:
  ::metrics::SystemProfileProto_Channel _internal_channel() const;
  void _internal_set_channel(::metrics::SystemProfileProto_Channel value);
  public:

  // optional uint32 multi_profile_user_count = 17;
  bool has_multi_profile_user_count() const;
  private:
  bool _internal_has_multi_profile_user_count() const;
  public:
  void clear_multi_profile_user_count();
  uint32_t multi_profile_user_count() const;
  void set_multi_profile_user_count(uint32_t value);
  private:
  uint32_t _internal_multi_profile_user_count() const;
  void _internal_set_multi_profile_user_count(uint32_t value);
  public:

  // optional int64 install_date = 16;
  bool has_install_date() const;
  private:
  bool _internal_has_install_date() const;
  public:
  void clear_install_date();
  int64_t install_date() const;
  void set_install_date(int64_t value);
  private:
  int64_t _internal_install_date() const;
  void _internal_set_install_date(int64_t value);
  public:

  // optional .metrics.SystemProfileProto.ExtensionsState offstore_extensions_state = 19;
  bool has_offstore_extensions_state() const;
  private:
  bool _internal_has_offstore_extensions_state() const;
  public:
  void clear_offstore_extensions_state();
  ::metrics::SystemProfileProto_ExtensionsState offstore_extensions_state() const;
  void set_offstore_extensions_state(::metrics::SystemProfileProto_ExtensionsState value);
  private:
  ::metrics::SystemProfileProto_ExtensionsState _internal_offstore_extensions_state() const;
  void _internal_set_offstore_extensions_state(::metrics::SystemProfileProto_ExtensionsState value);
  public:

  // optional .metrics.SystemProfileProto.UmaDefaultState uma_default_state = 22;
  bool has_uma_default_state() const;
  private:
  bool _internal_has_uma_default_state() const;
  public:
  void clear_uma_default_state();
  ::metrics::SystemProfileProto_UmaDefaultState uma_default_state() const;
  void set_uma_default_state(::metrics::SystemProfileProto_UmaDefaultState value);
  private:
  ::metrics::SystemProfileProto_UmaDefaultState _internal_uma_default_state() const;
  void _internal_set_uma_default_state(::metrics::SystemProfileProto_UmaDefaultState value);
  public:

  // optional bool is_extended_stable_channel = 36 [default = false];
  bool has_is_extended_stable_channel() const;
  private:
  bool _internal_has_is_extended_stable_channel() const;
  public:
  void clear_is_extended_stable_channel();
  bool is_extended_stable_channel() const;
  void set_is_extended_stable_channel(bool value);
  private:
  bool _internal_is_extended_stable_channel() const;
  void _internal_set_is_extended_stable_channel(bool value);
  public:

  // optional bool is_instrumented_build = 20 [default = false];
  bool has_is_instrumented_build() const;
  private:
  bool _internal_has_is_instrumented_build() const;
  public:
  void clear_is_instrumented_build();
  bool is_instrumented_build() const;
  void set_is_instrumented_build(bool value);
  private:
  bool _internal_is_instrumented_build() const;
  void _internal_set_is_instrumented_build(bool value);
  public:

  // optional bool client_id_was_used_for_trial_assignment = 33;
  bool has_client_id_was_used_for_trial_assignment() const;
  private:
  bool _internal_has_client_id_was_used_for_trial_assignment() const;
  public:
  void clear_client_id_was_used_for_trial_assignment();
  bool client_id_was_used_for_trial_assignment() const;
  void set_client_id_was_used_for_trial_assignment(bool value);
  private:
  bool _internal_client_id_was_used_for_trial_assignment() const;
  void _internal_set_client_id_was_used_for_trial_assignment(bool value);
  public:

  // optional int32 low_entropy_source = 31;
  bool has_low_entropy_source() const;
  private:
  bool _internal_has_low_entropy_source() const;
  public:
  void clear_low_entropy_source();
  int32_t low_entropy_source() const;
  void set_low_entropy_source(int32_t value);
  private:
  int32_t _internal_low_entropy_source() const;
  void _internal_set_low_entropy_source(int32_t value);
  public:

  // optional int32 old_low_entropy_source = 32;
  bool has_old_low_entropy_source() const;
  private:
  bool _internal_has_old_low_entropy_source() const;
  public:
  void clear_old_low_entropy_source();
  int32_t old_low_entropy_source() const;
  void set_old_low_entropy_source(int32_t value);
  private:
  int32_t _internal_old_low_entropy_source() const;
  void _internal_set_old_low_entropy_source(int32_t value);
  public:

  // optional .metrics.SystemProfileProto.InstallerPackage installer_package = 35;
  bool has_installer_package() const;
  private:
  bool _internal_has_installer_package() const;
  public:
  void clear_installer_package();
  ::metrics::SystemProfileProto_InstallerPackage installer_package() const;
  void set_installer_package(::metrics::SystemProfileProto_InstallerPackage value);
  private:
  ::metrics::SystemProfileProto_InstallerPackage _internal_installer_package() const;
  void _internal_set_installer_package(::metrics::SystemProfileProto_InstallerPackage value);
  public:

  // optional int32 pseudo_low_entropy_source = 37;
  bool has_pseudo_low_entropy_source() const;
  private:
  bool _internal_has_pseudo_low_entropy_source() const;
  public:
  void clear_pseudo_low_entropy_source();
  int32_t pseudo_low_entropy_source() const;
  void set_pseudo_low_entropy_source(int32_t value);
  private:
  int32_t _internal_pseudo_low_entropy_source() const;
  void _internal_set_pseudo_low_entropy_source(int32_t value);
  public:

  // optional .metrics.SystemProfileProto.AppPackageNameAllowlistFilter app_package_name_allowlist_filter = 42;
  bool has_app_package_name_allowlist_filter() const;
  private:
  bool _internal_has_app_package_name_allowlist_filter() const;
  public:
  void clear_app_package_name_allowlist_filter();
  ::metrics::SystemProfileProto_AppPackageNameAllowlistFilter app_package_name_allowlist_filter() const;
  void set_app_package_name_allowlist_filter(::metrics::SystemProfileProto_AppPackageNameAllowlistFilter value);
  private:
  ::metrics::SystemProfileProto_AppPackageNameAllowlistFilter _internal_app_package_name_allowlist_filter() const;
  void _internal_set_app_package_name_allowlist_filter(::metrics::SystemProfileProto_AppPackageNameAllowlistFilter value);
  public:

  // optional .metrics.SystemProfileProto.ClientSideSamplingStatus client_side_sampling_status = 43;
  bool has_client_side_sampling_status() const;
  private:
  bool _internal_has_client_side_sampling_status() const;
  public:
  void clear_client_side_sampling_status();
  ::metrics::SystemProfileProto_ClientSideSamplingStatus client_side_sampling_status() const;
  void set_client_side_sampling_status(::metrics::SystemProfileProto_ClientSideSamplingStatus value);
  private:
  ::metrics::SystemProfileProto_ClientSideSamplingStatus _internal_client_side_sampling_status() const;
  void _internal_set_client_side_sampling_status(::metrics::SystemProfileProto_ClientSideSamplingStatus value);
  public:

  // optional .metrics.SystemProfileProto.MetricsFilteringStatus metrics_filtering_status = 44;
  bool has_metrics_filtering_status() const;
  private:
  bool _internal_has_metrics_filtering_status() const;
  public:
  void clear_metrics_filtering_status();
  ::metrics::SystemProfileProto_MetricsFilteringStatus metrics_filtering_status() const;
  void set_metrics_filtering_status(::metrics::SystemProfileProto_MetricsFilteringStatus value);
  private:
  ::metrics::SystemProfileProto_MetricsFilteringStatus _internal_metrics_filtering_status() const;
  void _internal_set_metrics_filtering_status(::metrics::SystemProfileProto_MetricsFilteringStatus value);
  public:

  // optional fixed64 session_hash = 46;
  bool has_session_hash() const;
  private:
  bool _internal_has_session_hash() const;
  public:
  void clear_session_hash();
  uint64_t session_hash() const;
  void set_session_hash(uint64_t value);
  private:
  uint64_t _internal_session_hash() const;
  void _internal_set_session_hash(uint64_t value);
  public:

  // optional .metrics.SystemProfileProto.LTSChannel lts_channel = 45;
  bool has_lts_channel() const;
  private:
  bool _internal_has_lts_channel() const;
  public:
  void clear_lts_channel();
  ::metrics::SystemProfileProto_LTSChannel lts_channel() const;
  void set_lts_channel(::metrics::SystemProfileProto_LTSChannel value);
  private:
  ::metrics::SystemProfileProto_LTSChannel _internal_lts_channel() const;
  void _internal_set_lts_channel(::metrics::SystemProfileProto_LTSChannel value);
  public:

  // @@protoc_insertion_point(class_scope:metrics.SystemProfileProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_FieldTrial > field_trial_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice > external_audio_video_device_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > occupied_extension_bucket_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_AntiVirusProduct > antivirus_product_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ChromeComponent > chrome_component_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::ExtensionInstallProto > extension_install_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > command_line_key_hash_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr app_version_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr application_locale_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr brand_code_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr app_package_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr variations_seed_version_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_uuid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr log_written_by_app_version_;
    ::metrics::SystemProfileProto_OS* os_;
    ::metrics::SystemProfileProto_Hardware* hardware_;
    ::metrics::SystemProfileProto_Stability* stability_;
    ::metrics::SystemProfileProto_GoogleUpdate* google_update_;
    ::metrics::SystemProfileProto_Network* network_;
    ::metrics::SystemProfileProto_ExternalAccessPoint* external_access_point_;
    ::metrics::SystemProfileProto_LinkedAndroidPhoneData* linked_android_phone_data_;
    ::metrics::SystemProfileProto_ClonedInstallInfo* cloned_install_info_;
    ::metrics::SystemProfileProto_DemoModeDimensions* demo_mode_dimensions_;
    int64_t build_timestamp_;
    int64_t uma_enabled_date_;
    int channel_;
    uint32_t multi_profile_user_count_;
    int64_t install_date_;
    int offstore_extensions_state_;
    int uma_default_state_;
    bool is_extended_stable_channel_;
    bool is_instrumented_build_;
    bool client_id_was_used_for_trial_assignment_;
    int32_t low_entropy_source_;
    int32_t old_low_entropy_source_;
    int installer_package_;
    int32_t pseudo_low_entropy_source_;
    int app_package_name_allowlist_filter_;
    int client_side_sampling_status_;
    int metrics_filtering_status_;
    uint64_t session_hash_;
    int lts_channel_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_system_5fprofile_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// SystemProfileProto_ClonedInstallInfo

// optional int64 last_timestamp = 1;
inline bool SystemProfileProto_ClonedInstallInfo::_internal_has_last_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_ClonedInstallInfo::has_last_timestamp() const {
  return _internal_has_last_timestamp();
}
inline void SystemProfileProto_ClonedInstallInfo::clear_last_timestamp() {
  _impl_.last_timestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int64_t SystemProfileProto_ClonedInstallInfo::_internal_last_timestamp() const {
  return _impl_.last_timestamp_;
}
inline int64_t SystemProfileProto_ClonedInstallInfo::last_timestamp() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ClonedInstallInfo.last_timestamp)
  return _internal_last_timestamp();
}
inline void SystemProfileProto_ClonedInstallInfo::_internal_set_last_timestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.last_timestamp_ = value;
}
inline void SystemProfileProto_ClonedInstallInfo::set_last_timestamp(int64_t value) {
  _internal_set_last_timestamp(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ClonedInstallInfo.last_timestamp)
}

// optional fixed64 cloned_from_client_id = 2;
inline bool SystemProfileProto_ClonedInstallInfo::_internal_has_cloned_from_client_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_ClonedInstallInfo::has_cloned_from_client_id() const {
  return _internal_has_cloned_from_client_id();
}
inline void SystemProfileProto_ClonedInstallInfo::clear_cloned_from_client_id() {
  _impl_.cloned_from_client_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t SystemProfileProto_ClonedInstallInfo::_internal_cloned_from_client_id() const {
  return _impl_.cloned_from_client_id_;
}
inline uint64_t SystemProfileProto_ClonedInstallInfo::cloned_from_client_id() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ClonedInstallInfo.cloned_from_client_id)
  return _internal_cloned_from_client_id();
}
inline void SystemProfileProto_ClonedInstallInfo::_internal_set_cloned_from_client_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.cloned_from_client_id_ = value;
}
inline void SystemProfileProto_ClonedInstallInfo::set_cloned_from_client_id(uint64_t value) {
  _internal_set_cloned_from_client_id(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ClonedInstallInfo.cloned_from_client_id)
}

// optional int64 first_timestamp = 3;
inline bool SystemProfileProto_ClonedInstallInfo::_internal_has_first_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_ClonedInstallInfo::has_first_timestamp() const {
  return _internal_has_first_timestamp();
}
inline void SystemProfileProto_ClonedInstallInfo::clear_first_timestamp() {
  _impl_.first_timestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int64_t SystemProfileProto_ClonedInstallInfo::_internal_first_timestamp() const {
  return _impl_.first_timestamp_;
}
inline int64_t SystemProfileProto_ClonedInstallInfo::first_timestamp() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ClonedInstallInfo.first_timestamp)
  return _internal_first_timestamp();
}
inline void SystemProfileProto_ClonedInstallInfo::_internal_set_first_timestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.first_timestamp_ = value;
}
inline void SystemProfileProto_ClonedInstallInfo::set_first_timestamp(int64_t value) {
  _internal_set_first_timestamp(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ClonedInstallInfo.first_timestamp)
}

// optional int32 count = 4;
inline bool SystemProfileProto_ClonedInstallInfo::_internal_has_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_ClonedInstallInfo::has_count() const {
  return _internal_has_count();
}
inline void SystemProfileProto_ClonedInstallInfo::clear_count() {
  _impl_.count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t SystemProfileProto_ClonedInstallInfo::_internal_count() const {
  return _impl_.count_;
}
inline int32_t SystemProfileProto_ClonedInstallInfo::count() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ClonedInstallInfo.count)
  return _internal_count();
}
inline void SystemProfileProto_ClonedInstallInfo::_internal_set_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.count_ = value;
}
inline void SystemProfileProto_ClonedInstallInfo::set_count(int32_t value) {
  _internal_set_count(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ClonedInstallInfo.count)
}

// -------------------------------------------------------------------

// SystemProfileProto_OS_Arc

// optional string release = 1;
inline bool SystemProfileProto_OS_Arc::_internal_has_release() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_OS_Arc::has_release() const {
  return _internal_has_release();
}
inline void SystemProfileProto_OS_Arc::clear_release() {
  _impl_.release_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SystemProfileProto_OS_Arc::release() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.OS.Arc.release)
  return _internal_release();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_OS_Arc::set_release(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.release_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.OS.Arc.release)
}
inline std::string* SystemProfileProto_OS_Arc::mutable_release() {
  std::string* _s = _internal_mutable_release();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.OS.Arc.release)
  return _s;
}
inline const std::string& SystemProfileProto_OS_Arc::_internal_release() const {
  return _impl_.release_.Get();
}
inline void SystemProfileProto_OS_Arc::_internal_set_release(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.release_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_OS_Arc::_internal_mutable_release() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.release_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_OS_Arc::release_release() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.OS.Arc.release)
  if (!_internal_has_release()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.release_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.release_.IsDefault()) {
    _impl_.release_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_OS_Arc::set_allocated_release(std::string* release) {
  if (release != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.release_.SetAllocated(release, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.release_.IsDefault()) {
    _impl_.release_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.OS.Arc.release)
}

// -------------------------------------------------------------------

// SystemProfileProto_OS

// optional string name = 1;
inline bool SystemProfileProto_OS::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_OS::has_name() const {
  return _internal_has_name();
}
inline void SystemProfileProto_OS::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SystemProfileProto_OS::name() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.OS.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_OS::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.OS.name)
}
inline std::string* SystemProfileProto_OS::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.OS.name)
  return _s;
}
inline const std::string& SystemProfileProto_OS::_internal_name() const {
  return _impl_.name_.Get();
}
inline void SystemProfileProto_OS::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_OS::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_OS::release_name() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.OS.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_OS::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.OS.name)
}

// optional string version = 2;
inline bool SystemProfileProto_OS::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_OS::has_version() const {
  return _internal_has_version();
}
inline void SystemProfileProto_OS::clear_version() {
  _impl_.version_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SystemProfileProto_OS::version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.OS.version)
  return _internal_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_OS::set_version(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.OS.version)
}
inline std::string* SystemProfileProto_OS::mutable_version() {
  std::string* _s = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.OS.version)
  return _s;
}
inline const std::string& SystemProfileProto_OS::_internal_version() const {
  return _impl_.version_.Get();
}
inline void SystemProfileProto_OS::_internal_set_version(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.version_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_OS::_internal_mutable_version() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.version_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_OS::release_version() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.OS.version)
  if (!_internal_has_version()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.version_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.version_.IsDefault()) {
    _impl_.version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_OS::set_allocated_version(std::string* version) {
  if (version != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.version_.IsDefault()) {
    _impl_.version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.OS.version)
}

// optional string build_fingerprint = 3;
inline bool SystemProfileProto_OS::_internal_has_build_fingerprint() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_OS::has_build_fingerprint() const {
  return _internal_has_build_fingerprint();
}
inline void SystemProfileProto_OS::clear_build_fingerprint() {
  _impl_.build_fingerprint_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SystemProfileProto_OS::build_fingerprint() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.OS.build_fingerprint)
  return _internal_build_fingerprint();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_OS::set_build_fingerprint(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.build_fingerprint_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.OS.build_fingerprint)
}
inline std::string* SystemProfileProto_OS::mutable_build_fingerprint() {
  std::string* _s = _internal_mutable_build_fingerprint();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.OS.build_fingerprint)
  return _s;
}
inline const std::string& SystemProfileProto_OS::_internal_build_fingerprint() const {
  return _impl_.build_fingerprint_.Get();
}
inline void SystemProfileProto_OS::_internal_set_build_fingerprint(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.build_fingerprint_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_OS::_internal_mutable_build_fingerprint() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.build_fingerprint_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_OS::release_build_fingerprint() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.OS.build_fingerprint)
  if (!_internal_has_build_fingerprint()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.build_fingerprint_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.build_fingerprint_.IsDefault()) {
    _impl_.build_fingerprint_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_OS::set_allocated_build_fingerprint(std::string* build_fingerprint) {
  if (build_fingerprint != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.build_fingerprint_.SetAllocated(build_fingerprint, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.build_fingerprint_.IsDefault()) {
    _impl_.build_fingerprint_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.OS.build_fingerprint)
}

// optional bool DEPRECATED_is_jailbroken = 4 [deprecated = true];
inline bool SystemProfileProto_OS::_internal_has_deprecated_is_jailbroken() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool SystemProfileProto_OS::has_deprecated_is_jailbroken() const {
  return _internal_has_deprecated_is_jailbroken();
}
inline void SystemProfileProto_OS::clear_deprecated_is_jailbroken() {
  _impl_.deprecated_is_jailbroken_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool SystemProfileProto_OS::_internal_deprecated_is_jailbroken() const {
  return _impl_.deprecated_is_jailbroken_;
}
inline bool SystemProfileProto_OS::deprecated_is_jailbroken() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.OS.DEPRECATED_is_jailbroken)
  return _internal_deprecated_is_jailbroken();
}
inline void SystemProfileProto_OS::_internal_set_deprecated_is_jailbroken(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.deprecated_is_jailbroken_ = value;
}
inline void SystemProfileProto_OS::set_deprecated_is_jailbroken(bool value) {
  _internal_set_deprecated_is_jailbroken(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.OS.DEPRECATED_is_jailbroken)
}

// optional string build_number = 5;
inline bool SystemProfileProto_OS::_internal_has_build_number() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_OS::has_build_number() const {
  return _internal_has_build_number();
}
inline void SystemProfileProto_OS::clear_build_number() {
  _impl_.build_number_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& SystemProfileProto_OS::build_number() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.OS.build_number)
  return _internal_build_number();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_OS::set_build_number(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.build_number_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.OS.build_number)
}
inline std::string* SystemProfileProto_OS::mutable_build_number() {
  std::string* _s = _internal_mutable_build_number();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.OS.build_number)
  return _s;
}
inline const std::string& SystemProfileProto_OS::_internal_build_number() const {
  return _impl_.build_number_.Get();
}
inline void SystemProfileProto_OS::_internal_set_build_number(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.build_number_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_OS::_internal_mutable_build_number() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.build_number_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_OS::release_build_number() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.OS.build_number)
  if (!_internal_has_build_number()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.build_number_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.build_number_.IsDefault()) {
    _impl_.build_number_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_OS::set_allocated_build_number(std::string* build_number) {
  if (build_number != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.build_number_.SetAllocated(build_number, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.build_number_.IsDefault()) {
    _impl_.build_number_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.OS.build_number)
}

// optional string kernel_version = 6;
inline bool SystemProfileProto_OS::_internal_has_kernel_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SystemProfileProto_OS::has_kernel_version() const {
  return _internal_has_kernel_version();
}
inline void SystemProfileProto_OS::clear_kernel_version() {
  _impl_.kernel_version_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& SystemProfileProto_OS::kernel_version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.OS.kernel_version)
  return _internal_kernel_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_OS::set_kernel_version(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.kernel_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.OS.kernel_version)
}
inline std::string* SystemProfileProto_OS::mutable_kernel_version() {
  std::string* _s = _internal_mutable_kernel_version();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.OS.kernel_version)
  return _s;
}
inline const std::string& SystemProfileProto_OS::_internal_kernel_version() const {
  return _impl_.kernel_version_.Get();
}
inline void SystemProfileProto_OS::_internal_set_kernel_version(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.kernel_version_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_OS::_internal_mutable_kernel_version() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.kernel_version_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_OS::release_kernel_version() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.OS.kernel_version)
  if (!_internal_has_kernel_version()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.kernel_version_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.kernel_version_.IsDefault()) {
    _impl_.kernel_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_OS::set_allocated_kernel_version(std::string* kernel_version) {
  if (kernel_version != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.kernel_version_.SetAllocated(kernel_version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.kernel_version_.IsDefault()) {
    _impl_.kernel_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.OS.kernel_version)
}

// optional .metrics.SystemProfileProto.OS.Arc arc = 7;
inline bool SystemProfileProto_OS::_internal_has_arc() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.arc_ != nullptr);
  return value;
}
inline bool SystemProfileProto_OS::has_arc() const {
  return _internal_has_arc();
}
inline void SystemProfileProto_OS::clear_arc() {
  if (_impl_.arc_ != nullptr) _impl_.arc_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::metrics::SystemProfileProto_OS_Arc& SystemProfileProto_OS::_internal_arc() const {
  const ::metrics::SystemProfileProto_OS_Arc* p = _impl_.arc_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_OS_Arc&>(
      ::metrics::_SystemProfileProto_OS_Arc_default_instance_);
}
inline const ::metrics::SystemProfileProto_OS_Arc& SystemProfileProto_OS::arc() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.OS.arc)
  return _internal_arc();
}
inline void SystemProfileProto_OS::unsafe_arena_set_allocated_arc(
    ::metrics::SystemProfileProto_OS_Arc* arc) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arc_);
  }
  _impl_.arc_ = arc;
  if (arc) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.OS.arc)
}
inline ::metrics::SystemProfileProto_OS_Arc* SystemProfileProto_OS::release_arc() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::metrics::SystemProfileProto_OS_Arc* temp = _impl_.arc_;
  _impl_.arc_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_OS_Arc* SystemProfileProto_OS::unsafe_arena_release_arc() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.OS.arc)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::metrics::SystemProfileProto_OS_Arc* temp = _impl_.arc_;
  _impl_.arc_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_OS_Arc* SystemProfileProto_OS::_internal_mutable_arc() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.arc_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_OS_Arc>(GetArenaForAllocation());
    _impl_.arc_ = p;
  }
  return _impl_.arc_;
}
inline ::metrics::SystemProfileProto_OS_Arc* SystemProfileProto_OS::mutable_arc() {
  ::metrics::SystemProfileProto_OS_Arc* _msg = _internal_mutable_arc();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.OS.arc)
  return _msg;
}
inline void SystemProfileProto_OS::set_allocated_arc(::metrics::SystemProfileProto_OS_Arc* arc) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.arc_;
  }
  if (arc) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arc);
    if (message_arena != submessage_arena) {
      arc = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arc, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.arc_ = arc;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.OS.arc)
}

// optional .metrics.SystemProfileProto.OS.DarkModeState dark_mode_state = 8 [default = UNKNOWN];
inline bool SystemProfileProto_OS::_internal_has_dark_mode_state() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool SystemProfileProto_OS::has_dark_mode_state() const {
  return _internal_has_dark_mode_state();
}
inline void SystemProfileProto_OS::clear_dark_mode_state() {
  _impl_.dark_mode_state_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline ::metrics::SystemProfileProto_OS_DarkModeState SystemProfileProto_OS::_internal_dark_mode_state() const {
  return static_cast< ::metrics::SystemProfileProto_OS_DarkModeState >(_impl_.dark_mode_state_);
}
inline ::metrics::SystemProfileProto_OS_DarkModeState SystemProfileProto_OS::dark_mode_state() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.OS.dark_mode_state)
  return _internal_dark_mode_state();
}
inline void SystemProfileProto_OS::_internal_set_dark_mode_state(::metrics::SystemProfileProto_OS_DarkModeState value) {
  assert(::metrics::SystemProfileProto_OS_DarkModeState_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.dark_mode_state_ = value;
}
inline void SystemProfileProto_OS::set_dark_mode_state(::metrics::SystemProfileProto_OS_DarkModeState value) {
  _internal_set_dark_mode_state(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.OS.dark_mode_state)
}

// optional .metrics.SystemProfileProto.OS.XdgSessionType xdg_session_type = 9;
inline bool SystemProfileProto_OS::_internal_has_xdg_session_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool SystemProfileProto_OS::has_xdg_session_type() const {
  return _internal_has_xdg_session_type();
}
inline void SystemProfileProto_OS::clear_xdg_session_type() {
  _impl_.xdg_session_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline ::metrics::SystemProfileProto_OS_XdgSessionType SystemProfileProto_OS::_internal_xdg_session_type() const {
  return static_cast< ::metrics::SystemProfileProto_OS_XdgSessionType >(_impl_.xdg_session_type_);
}
inline ::metrics::SystemProfileProto_OS_XdgSessionType SystemProfileProto_OS::xdg_session_type() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.OS.xdg_session_type)
  return _internal_xdg_session_type();
}
inline void SystemProfileProto_OS::_internal_set_xdg_session_type(::metrics::SystemProfileProto_OS_XdgSessionType value) {
  assert(::metrics::SystemProfileProto_OS_XdgSessionType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.xdg_session_type_ = value;
}
inline void SystemProfileProto_OS::set_xdg_session_type(::metrics::SystemProfileProto_OS_XdgSessionType value) {
  _internal_set_xdg_session_type(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.OS.xdg_session_type)
}

// optional .metrics.SystemProfileProto.OS.XdgCurrentDesktop xdg_current_desktop = 10;
inline bool SystemProfileProto_OS::_internal_has_xdg_current_desktop() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool SystemProfileProto_OS::has_xdg_current_desktop() const {
  return _internal_has_xdg_current_desktop();
}
inline void SystemProfileProto_OS::clear_xdg_current_desktop() {
  _impl_.xdg_current_desktop_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline ::metrics::SystemProfileProto_OS_XdgCurrentDesktop SystemProfileProto_OS::_internal_xdg_current_desktop() const {
  return static_cast< ::metrics::SystemProfileProto_OS_XdgCurrentDesktop >(_impl_.xdg_current_desktop_);
}
inline ::metrics::SystemProfileProto_OS_XdgCurrentDesktop SystemProfileProto_OS::xdg_current_desktop() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.OS.xdg_current_desktop)
  return _internal_xdg_current_desktop();
}
inline void SystemProfileProto_OS::_internal_set_xdg_current_desktop(::metrics::SystemProfileProto_OS_XdgCurrentDesktop value) {
  assert(::metrics::SystemProfileProto_OS_XdgCurrentDesktop_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.xdg_current_desktop_ = value;
}
inline void SystemProfileProto_OS::set_xdg_current_desktop(::metrics::SystemProfileProto_OS_XdgCurrentDesktop value) {
  _internal_set_xdg_current_desktop(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.OS.xdg_current_desktop)
}

// -------------------------------------------------------------------

// SystemProfileProto_Hardware_CPU

// optional string vendor_name = 1;
inline bool SystemProfileProto_Hardware_CPU::_internal_has_vendor_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_CPU::has_vendor_name() const {
  return _internal_has_vendor_name();
}
inline void SystemProfileProto_Hardware_CPU::clear_vendor_name() {
  _impl_.vendor_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SystemProfileProto_Hardware_CPU::vendor_name() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.CPU.vendor_name)
  return _internal_vendor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_CPU::set_vendor_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.vendor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.CPU.vendor_name)
}
inline std::string* SystemProfileProto_Hardware_CPU::mutable_vendor_name() {
  std::string* _s = _internal_mutable_vendor_name();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.CPU.vendor_name)
  return _s;
}
inline const std::string& SystemProfileProto_Hardware_CPU::_internal_vendor_name() const {
  return _impl_.vendor_name_.Get();
}
inline void SystemProfileProto_Hardware_CPU::_internal_set_vendor_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.vendor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_CPU::_internal_mutable_vendor_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.vendor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_CPU::release_vendor_name() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.CPU.vendor_name)
  if (!_internal_has_vendor_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.vendor_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.vendor_name_.IsDefault()) {
    _impl_.vendor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_Hardware_CPU::set_allocated_vendor_name(std::string* vendor_name) {
  if (vendor_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.vendor_name_.SetAllocated(vendor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.vendor_name_.IsDefault()) {
    _impl_.vendor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.CPU.vendor_name)
}

// optional uint32 signature = 2;
inline bool SystemProfileProto_Hardware_CPU::_internal_has_signature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_CPU::has_signature() const {
  return _internal_has_signature();
}
inline void SystemProfileProto_Hardware_CPU::clear_signature() {
  _impl_.signature_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t SystemProfileProto_Hardware_CPU::_internal_signature() const {
  return _impl_.signature_;
}
inline uint32_t SystemProfileProto_Hardware_CPU::signature() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.CPU.signature)
  return _internal_signature();
}
inline void SystemProfileProto_Hardware_CPU::_internal_set_signature(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.signature_ = value;
}
inline void SystemProfileProto_Hardware_CPU::set_signature(uint32_t value) {
  _internal_set_signature(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.CPU.signature)
}

// optional uint32 num_cores = 3;
inline bool SystemProfileProto_Hardware_CPU::_internal_has_num_cores() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_CPU::has_num_cores() const {
  return _internal_has_num_cores();
}
inline void SystemProfileProto_Hardware_CPU::clear_num_cores() {
  _impl_.num_cores_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t SystemProfileProto_Hardware_CPU::_internal_num_cores() const {
  return _impl_.num_cores_;
}
inline uint32_t SystemProfileProto_Hardware_CPU::num_cores() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.CPU.num_cores)
  return _internal_num_cores();
}
inline void SystemProfileProto_Hardware_CPU::_internal_set_num_cores(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.num_cores_ = value;
}
inline void SystemProfileProto_Hardware_CPU::set_num_cores(uint32_t value) {
  _internal_set_num_cores(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.CPU.num_cores)
}

// optional bool is_hypervisor = 4;
inline bool SystemProfileProto_Hardware_CPU::_internal_has_is_hypervisor() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_CPU::has_is_hypervisor() const {
  return _internal_has_is_hypervisor();
}
inline void SystemProfileProto_Hardware_CPU::clear_is_hypervisor() {
  _impl_.is_hypervisor_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool SystemProfileProto_Hardware_CPU::_internal_is_hypervisor() const {
  return _impl_.is_hypervisor_;
}
inline bool SystemProfileProto_Hardware_CPU::is_hypervisor() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.CPU.is_hypervisor)
  return _internal_is_hypervisor();
}
inline void SystemProfileProto_Hardware_CPU::_internal_set_is_hypervisor(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.is_hypervisor_ = value;
}
inline void SystemProfileProto_Hardware_CPU::set_is_hypervisor(bool value) {
  _internal_set_is_hypervisor(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.CPU.is_hypervisor)
}

// -------------------------------------------------------------------

// SystemProfileProto_Hardware_Motherboard

// optional string manufacturer = 1;
inline bool SystemProfileProto_Hardware_Motherboard::_internal_has_manufacturer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_Motherboard::has_manufacturer() const {
  return _internal_has_manufacturer();
}
inline void SystemProfileProto_Hardware_Motherboard::clear_manufacturer() {
  _impl_.manufacturer_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SystemProfileProto_Hardware_Motherboard::manufacturer() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.Motherboard.manufacturer)
  return _internal_manufacturer();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_Motherboard::set_manufacturer(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.manufacturer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.Motherboard.manufacturer)
}
inline std::string* SystemProfileProto_Hardware_Motherboard::mutable_manufacturer() {
  std::string* _s = _internal_mutable_manufacturer();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.Motherboard.manufacturer)
  return _s;
}
inline const std::string& SystemProfileProto_Hardware_Motherboard::_internal_manufacturer() const {
  return _impl_.manufacturer_.Get();
}
inline void SystemProfileProto_Hardware_Motherboard::_internal_set_manufacturer(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.manufacturer_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_Motherboard::_internal_mutable_manufacturer() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.manufacturer_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_Motherboard::release_manufacturer() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.Motherboard.manufacturer)
  if (!_internal_has_manufacturer()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.manufacturer_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.manufacturer_.IsDefault()) {
    _impl_.manufacturer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_Hardware_Motherboard::set_allocated_manufacturer(std::string* manufacturer) {
  if (manufacturer != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.manufacturer_.SetAllocated(manufacturer, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.manufacturer_.IsDefault()) {
    _impl_.manufacturer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.Motherboard.manufacturer)
}

// optional string model = 2;
inline bool SystemProfileProto_Hardware_Motherboard::_internal_has_model() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_Motherboard::has_model() const {
  return _internal_has_model();
}
inline void SystemProfileProto_Hardware_Motherboard::clear_model() {
  _impl_.model_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SystemProfileProto_Hardware_Motherboard::model() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.Motherboard.model)
  return _internal_model();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_Motherboard::set_model(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.model_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.Motherboard.model)
}
inline std::string* SystemProfileProto_Hardware_Motherboard::mutable_model() {
  std::string* _s = _internal_mutable_model();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.Motherboard.model)
  return _s;
}
inline const std::string& SystemProfileProto_Hardware_Motherboard::_internal_model() const {
  return _impl_.model_.Get();
}
inline void SystemProfileProto_Hardware_Motherboard::_internal_set_model(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.model_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_Motherboard::_internal_mutable_model() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.model_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_Motherboard::release_model() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.Motherboard.model)
  if (!_internal_has_model()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.model_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.model_.IsDefault()) {
    _impl_.model_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_Hardware_Motherboard::set_allocated_model(std::string* model) {
  if (model != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.model_.SetAllocated(model, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.model_.IsDefault()) {
    _impl_.model_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.Motherboard.model)
}

// optional string bios_manufacturer = 3;
inline bool SystemProfileProto_Hardware_Motherboard::_internal_has_bios_manufacturer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_Motherboard::has_bios_manufacturer() const {
  return _internal_has_bios_manufacturer();
}
inline void SystemProfileProto_Hardware_Motherboard::clear_bios_manufacturer() {
  _impl_.bios_manufacturer_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SystemProfileProto_Hardware_Motherboard::bios_manufacturer() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.Motherboard.bios_manufacturer)
  return _internal_bios_manufacturer();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_Motherboard::set_bios_manufacturer(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.bios_manufacturer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.Motherboard.bios_manufacturer)
}
inline std::string* SystemProfileProto_Hardware_Motherboard::mutable_bios_manufacturer() {
  std::string* _s = _internal_mutable_bios_manufacturer();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.Motherboard.bios_manufacturer)
  return _s;
}
inline const std::string& SystemProfileProto_Hardware_Motherboard::_internal_bios_manufacturer() const {
  return _impl_.bios_manufacturer_.Get();
}
inline void SystemProfileProto_Hardware_Motherboard::_internal_set_bios_manufacturer(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.bios_manufacturer_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_Motherboard::_internal_mutable_bios_manufacturer() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.bios_manufacturer_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_Motherboard::release_bios_manufacturer() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.Motherboard.bios_manufacturer)
  if (!_internal_has_bios_manufacturer()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.bios_manufacturer_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.bios_manufacturer_.IsDefault()) {
    _impl_.bios_manufacturer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_Hardware_Motherboard::set_allocated_bios_manufacturer(std::string* bios_manufacturer) {
  if (bios_manufacturer != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.bios_manufacturer_.SetAllocated(bios_manufacturer, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.bios_manufacturer_.IsDefault()) {
    _impl_.bios_manufacturer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.Motherboard.bios_manufacturer)
}

// optional string bios_version = 4;
inline bool SystemProfileProto_Hardware_Motherboard::_internal_has_bios_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_Motherboard::has_bios_version() const {
  return _internal_has_bios_version();
}
inline void SystemProfileProto_Hardware_Motherboard::clear_bios_version() {
  _impl_.bios_version_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& SystemProfileProto_Hardware_Motherboard::bios_version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.Motherboard.bios_version)
  return _internal_bios_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_Motherboard::set_bios_version(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.bios_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.Motherboard.bios_version)
}
inline std::string* SystemProfileProto_Hardware_Motherboard::mutable_bios_version() {
  std::string* _s = _internal_mutable_bios_version();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.Motherboard.bios_version)
  return _s;
}
inline const std::string& SystemProfileProto_Hardware_Motherboard::_internal_bios_version() const {
  return _impl_.bios_version_.Get();
}
inline void SystemProfileProto_Hardware_Motherboard::_internal_set_bios_version(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.bios_version_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_Motherboard::_internal_mutable_bios_version() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.bios_version_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_Motherboard::release_bios_version() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.Motherboard.bios_version)
  if (!_internal_has_bios_version()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.bios_version_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.bios_version_.IsDefault()) {
    _impl_.bios_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_Hardware_Motherboard::set_allocated_bios_version(std::string* bios_version) {
  if (bios_version != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.bios_version_.SetAllocated(bios_version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.bios_version_.IsDefault()) {
    _impl_.bios_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.Motherboard.bios_version)
}

// optional .metrics.SystemProfileProto.Hardware.BiosType bios_type = 5;
inline bool SystemProfileProto_Hardware_Motherboard::_internal_has_bios_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_Motherboard::has_bios_type() const {
  return _internal_has_bios_type();
}
inline void SystemProfileProto_Hardware_Motherboard::clear_bios_type() {
  _impl_.bios_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline ::metrics::SystemProfileProto_Hardware_BiosType SystemProfileProto_Hardware_Motherboard::_internal_bios_type() const {
  return static_cast< ::metrics::SystemProfileProto_Hardware_BiosType >(_impl_.bios_type_);
}
inline ::metrics::SystemProfileProto_Hardware_BiosType SystemProfileProto_Hardware_Motherboard::bios_type() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.Motherboard.bios_type)
  return _internal_bios_type();
}
inline void SystemProfileProto_Hardware_Motherboard::_internal_set_bios_type(::metrics::SystemProfileProto_Hardware_BiosType value) {
  assert(::metrics::SystemProfileProto_Hardware_BiosType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.bios_type_ = value;
}
inline void SystemProfileProto_Hardware_Motherboard::set_bios_type(::metrics::SystemProfileProto_Hardware_BiosType value) {
  _internal_set_bios_type(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.Motherboard.bios_type)
}

// -------------------------------------------------------------------

// SystemProfileProto_Hardware_Graphics

// optional uint32 vendor_id = 1;
inline bool SystemProfileProto_Hardware_Graphics::_internal_has_vendor_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_Graphics::has_vendor_id() const {
  return _internal_has_vendor_id();
}
inline void SystemProfileProto_Hardware_Graphics::clear_vendor_id() {
  _impl_.vendor_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t SystemProfileProto_Hardware_Graphics::_internal_vendor_id() const {
  return _impl_.vendor_id_;
}
inline uint32_t SystemProfileProto_Hardware_Graphics::vendor_id() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.Graphics.vendor_id)
  return _internal_vendor_id();
}
inline void SystemProfileProto_Hardware_Graphics::_internal_set_vendor_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.vendor_id_ = value;
}
inline void SystemProfileProto_Hardware_Graphics::set_vendor_id(uint32_t value) {
  _internal_set_vendor_id(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.Graphics.vendor_id)
}

// optional uint32 device_id = 2;
inline bool SystemProfileProto_Hardware_Graphics::_internal_has_device_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_Graphics::has_device_id() const {
  return _internal_has_device_id();
}
inline void SystemProfileProto_Hardware_Graphics::clear_device_id() {
  _impl_.device_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t SystemProfileProto_Hardware_Graphics::_internal_device_id() const {
  return _impl_.device_id_;
}
inline uint32_t SystemProfileProto_Hardware_Graphics::device_id() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.Graphics.device_id)
  return _internal_device_id();
}
inline void SystemProfileProto_Hardware_Graphics::_internal_set_device_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.device_id_ = value;
}
inline void SystemProfileProto_Hardware_Graphics::set_device_id(uint32_t value) {
  _internal_set_device_id(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.Graphics.device_id)
}

// optional string driver_version = 3;
inline bool SystemProfileProto_Hardware_Graphics::_internal_has_driver_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_Graphics::has_driver_version() const {
  return _internal_has_driver_version();
}
inline void SystemProfileProto_Hardware_Graphics::clear_driver_version() {
  _impl_.driver_version_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SystemProfileProto_Hardware_Graphics::driver_version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.Graphics.driver_version)
  return _internal_driver_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_Graphics::set_driver_version(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.driver_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.Graphics.driver_version)
}
inline std::string* SystemProfileProto_Hardware_Graphics::mutable_driver_version() {
  std::string* _s = _internal_mutable_driver_version();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.Graphics.driver_version)
  return _s;
}
inline const std::string& SystemProfileProto_Hardware_Graphics::_internal_driver_version() const {
  return _impl_.driver_version_.Get();
}
inline void SystemProfileProto_Hardware_Graphics::_internal_set_driver_version(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.driver_version_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_Graphics::_internal_mutable_driver_version() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.driver_version_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_Graphics::release_driver_version() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.Graphics.driver_version)
  if (!_internal_has_driver_version()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.driver_version_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.driver_version_.IsDefault()) {
    _impl_.driver_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_Hardware_Graphics::set_allocated_driver_version(std::string* driver_version) {
  if (driver_version != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.driver_version_.SetAllocated(driver_version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.driver_version_.IsDefault()) {
    _impl_.driver_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.Graphics.driver_version)
}

// optional string gl_vendor = 6;
inline bool SystemProfileProto_Hardware_Graphics::_internal_has_gl_vendor() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_Graphics::has_gl_vendor() const {
  return _internal_has_gl_vendor();
}
inline void SystemProfileProto_Hardware_Graphics::clear_gl_vendor() {
  _impl_.gl_vendor_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SystemProfileProto_Hardware_Graphics::gl_vendor() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.Graphics.gl_vendor)
  return _internal_gl_vendor();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_Graphics::set_gl_vendor(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.gl_vendor_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.Graphics.gl_vendor)
}
inline std::string* SystemProfileProto_Hardware_Graphics::mutable_gl_vendor() {
  std::string* _s = _internal_mutable_gl_vendor();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.Graphics.gl_vendor)
  return _s;
}
inline const std::string& SystemProfileProto_Hardware_Graphics::_internal_gl_vendor() const {
  return _impl_.gl_vendor_.Get();
}
inline void SystemProfileProto_Hardware_Graphics::_internal_set_gl_vendor(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.gl_vendor_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_Graphics::_internal_mutable_gl_vendor() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.gl_vendor_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_Graphics::release_gl_vendor() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.Graphics.gl_vendor)
  if (!_internal_has_gl_vendor()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.gl_vendor_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.gl_vendor_.IsDefault()) {
    _impl_.gl_vendor_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_Hardware_Graphics::set_allocated_gl_vendor(std::string* gl_vendor) {
  if (gl_vendor != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.gl_vendor_.SetAllocated(gl_vendor, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.gl_vendor_.IsDefault()) {
    _impl_.gl_vendor_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.Graphics.gl_vendor)
}

// optional string gl_renderer = 7;
inline bool SystemProfileProto_Hardware_Graphics::_internal_has_gl_renderer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_Graphics::has_gl_renderer() const {
  return _internal_has_gl_renderer();
}
inline void SystemProfileProto_Hardware_Graphics::clear_gl_renderer() {
  _impl_.gl_renderer_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SystemProfileProto_Hardware_Graphics::gl_renderer() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.Graphics.gl_renderer)
  return _internal_gl_renderer();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_Graphics::set_gl_renderer(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.gl_renderer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.Graphics.gl_renderer)
}
inline std::string* SystemProfileProto_Hardware_Graphics::mutable_gl_renderer() {
  std::string* _s = _internal_mutable_gl_renderer();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.Graphics.gl_renderer)
  return _s;
}
inline const std::string& SystemProfileProto_Hardware_Graphics::_internal_gl_renderer() const {
  return _impl_.gl_renderer_.Get();
}
inline void SystemProfileProto_Hardware_Graphics::_internal_set_gl_renderer(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.gl_renderer_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_Graphics::_internal_mutable_gl_renderer() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.gl_renderer_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_Graphics::release_gl_renderer() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.Graphics.gl_renderer)
  if (!_internal_has_gl_renderer()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.gl_renderer_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.gl_renderer_.IsDefault()) {
    _impl_.gl_renderer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_Hardware_Graphics::set_allocated_gl_renderer(std::string* gl_renderer) {
  if (gl_renderer != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.gl_renderer_.SetAllocated(gl_renderer, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.gl_renderer_.IsDefault()) {
    _impl_.gl_renderer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.Graphics.gl_renderer)
}

// -------------------------------------------------------------------

// SystemProfileProto_Hardware_InternalStorageDevice

// optional uint32 vendor_id = 1;
inline bool SystemProfileProto_Hardware_InternalStorageDevice::_internal_has_vendor_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_InternalStorageDevice::has_vendor_id() const {
  return _internal_has_vendor_id();
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::clear_vendor_id() {
  _impl_.vendor_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t SystemProfileProto_Hardware_InternalStorageDevice::_internal_vendor_id() const {
  return _impl_.vendor_id_;
}
inline uint32_t SystemProfileProto_Hardware_InternalStorageDevice::vendor_id() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.InternalStorageDevice.vendor_id)
  return _internal_vendor_id();
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::_internal_set_vendor_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.vendor_id_ = value;
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::set_vendor_id(uint32_t value) {
  _internal_set_vendor_id(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.InternalStorageDevice.vendor_id)
}

// optional uint64 product_id = 2;
inline bool SystemProfileProto_Hardware_InternalStorageDevice::_internal_has_product_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_InternalStorageDevice::has_product_id() const {
  return _internal_has_product_id();
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::clear_product_id() {
  _impl_.product_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t SystemProfileProto_Hardware_InternalStorageDevice::_internal_product_id() const {
  return _impl_.product_id_;
}
inline uint64_t SystemProfileProto_Hardware_InternalStorageDevice::product_id() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.InternalStorageDevice.product_id)
  return _internal_product_id();
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::_internal_set_product_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.product_id_ = value;
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::set_product_id(uint64_t value) {
  _internal_set_product_id(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.InternalStorageDevice.product_id)
}

// optional uint32 revision = 3;
inline bool SystemProfileProto_Hardware_InternalStorageDevice::_internal_has_revision() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_InternalStorageDevice::has_revision() const {
  return _internal_has_revision();
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::clear_revision() {
  _impl_.revision_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t SystemProfileProto_Hardware_InternalStorageDevice::_internal_revision() const {
  return _impl_.revision_;
}
inline uint32_t SystemProfileProto_Hardware_InternalStorageDevice::revision() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.InternalStorageDevice.revision)
  return _internal_revision();
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::_internal_set_revision(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.revision_ = value;
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::set_revision(uint32_t value) {
  _internal_set_revision(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.InternalStorageDevice.revision)
}

// optional string model = 4;
inline bool SystemProfileProto_Hardware_InternalStorageDevice::_internal_has_model() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_InternalStorageDevice::has_model() const {
  return _internal_has_model();
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::clear_model() {
  _impl_.model_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SystemProfileProto_Hardware_InternalStorageDevice::model() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.InternalStorageDevice.model)
  return _internal_model();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware_InternalStorageDevice::set_model(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.model_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.InternalStorageDevice.model)
}
inline std::string* SystemProfileProto_Hardware_InternalStorageDevice::mutable_model() {
  std::string* _s = _internal_mutable_model();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.InternalStorageDevice.model)
  return _s;
}
inline const std::string& SystemProfileProto_Hardware_InternalStorageDevice::_internal_model() const {
  return _impl_.model_.Get();
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::_internal_set_model(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.model_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_InternalStorageDevice::_internal_mutable_model() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.model_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware_InternalStorageDevice::release_model() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.InternalStorageDevice.model)
  if (!_internal_has_model()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.model_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.model_.IsDefault()) {
    _impl_.model_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::set_allocated_model(std::string* model) {
  if (model != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.model_.SetAllocated(model, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.model_.IsDefault()) {
    _impl_.model_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.InternalStorageDevice.model)
}

// optional uint32 size_mb = 5;
inline bool SystemProfileProto_Hardware_InternalStorageDevice::_internal_has_size_mb() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_InternalStorageDevice::has_size_mb() const {
  return _internal_has_size_mb();
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::clear_size_mb() {
  _impl_.size_mb_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t SystemProfileProto_Hardware_InternalStorageDevice::_internal_size_mb() const {
  return _impl_.size_mb_;
}
inline uint32_t SystemProfileProto_Hardware_InternalStorageDevice::size_mb() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.InternalStorageDevice.size_mb)
  return _internal_size_mb();
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::_internal_set_size_mb(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.size_mb_ = value;
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::set_size_mb(uint32_t value) {
  _internal_set_size_mb(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.InternalStorageDevice.size_mb)
}

// optional uint64 firmware_version = 6;
inline bool SystemProfileProto_Hardware_InternalStorageDevice::_internal_has_firmware_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_InternalStorageDevice::has_firmware_version() const {
  return _internal_has_firmware_version();
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::clear_firmware_version() {
  _impl_.firmware_version_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint64_t SystemProfileProto_Hardware_InternalStorageDevice::_internal_firmware_version() const {
  return _impl_.firmware_version_;
}
inline uint64_t SystemProfileProto_Hardware_InternalStorageDevice::firmware_version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.InternalStorageDevice.firmware_version)
  return _internal_firmware_version();
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::_internal_set_firmware_version(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.firmware_version_ = value;
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::set_firmware_version(uint64_t value) {
  _internal_set_firmware_version(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.InternalStorageDevice.firmware_version)
}

// optional .metrics.SystemProfileProto.Hardware.InternalStorageDevice.Type type = 7;
inline bool SystemProfileProto_Hardware_InternalStorageDevice::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_InternalStorageDevice::has_type() const {
  return _internal_has_type();
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Type SystemProfileProto_Hardware_InternalStorageDevice::_internal_type() const {
  return static_cast< ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Type >(_impl_.type_);
}
inline ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Type SystemProfileProto_Hardware_InternalStorageDevice::type() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.InternalStorageDevice.type)
  return _internal_type();
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::_internal_set_type(::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Type value) {
  assert(::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Type_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.type_ = value;
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::set_type(::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.InternalStorageDevice.type)
}

// optional .metrics.SystemProfileProto.Hardware.InternalStorageDevice.Purpose purpose = 8;
inline bool SystemProfileProto_Hardware_InternalStorageDevice::_internal_has_purpose() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_InternalStorageDevice::has_purpose() const {
  return _internal_has_purpose();
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::clear_purpose() {
  _impl_.purpose_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Purpose SystemProfileProto_Hardware_InternalStorageDevice::_internal_purpose() const {
  return static_cast< ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Purpose >(_impl_.purpose_);
}
inline ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Purpose SystemProfileProto_Hardware_InternalStorageDevice::purpose() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.InternalStorageDevice.purpose)
  return _internal_purpose();
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::_internal_set_purpose(::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Purpose value) {
  assert(::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Purpose_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.purpose_ = value;
}
inline void SystemProfileProto_Hardware_InternalStorageDevice::set_purpose(::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Purpose value) {
  _internal_set_purpose(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.InternalStorageDevice.purpose)
}

// -------------------------------------------------------------------

// SystemProfileProto_Hardware_Drive

// optional bool has_seek_penalty = 1;
inline bool SystemProfileProto_Hardware_Drive::_internal_has_has_seek_penalty() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware_Drive::has_has_seek_penalty() const {
  return _internal_has_has_seek_penalty();
}
inline void SystemProfileProto_Hardware_Drive::clear_has_seek_penalty() {
  _impl_.has_seek_penalty_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool SystemProfileProto_Hardware_Drive::_internal_has_seek_penalty() const {
  return _impl_.has_seek_penalty_;
}
inline bool SystemProfileProto_Hardware_Drive::has_seek_penalty() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.Drive.has_seek_penalty)
  return _internal_has_seek_penalty();
}
inline void SystemProfileProto_Hardware_Drive::_internal_set_has_seek_penalty(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.has_seek_penalty_ = value;
}
inline void SystemProfileProto_Hardware_Drive::set_has_seek_penalty(bool value) {
  _internal_set_has_seek_penalty(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.Drive.has_seek_penalty)
}

// -------------------------------------------------------------------

// SystemProfileProto_Hardware

// optional string cpu_architecture = 1;
inline bool SystemProfileProto_Hardware::_internal_has_cpu_architecture() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_cpu_architecture() const {
  return _internal_has_cpu_architecture();
}
inline void SystemProfileProto_Hardware::clear_cpu_architecture() {
  _impl_.cpu_architecture_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SystemProfileProto_Hardware::cpu_architecture() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.cpu_architecture)
  return _internal_cpu_architecture();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware::set_cpu_architecture(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.cpu_architecture_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.cpu_architecture)
}
inline std::string* SystemProfileProto_Hardware::mutable_cpu_architecture() {
  std::string* _s = _internal_mutable_cpu_architecture();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.cpu_architecture)
  return _s;
}
inline const std::string& SystemProfileProto_Hardware::_internal_cpu_architecture() const {
  return _impl_.cpu_architecture_.Get();
}
inline void SystemProfileProto_Hardware::_internal_set_cpu_architecture(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.cpu_architecture_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware::_internal_mutable_cpu_architecture() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.cpu_architecture_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware::release_cpu_architecture() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.cpu_architecture)
  if (!_internal_has_cpu_architecture()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.cpu_architecture_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.cpu_architecture_.IsDefault()) {
    _impl_.cpu_architecture_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_Hardware::set_allocated_cpu_architecture(std::string* cpu_architecture) {
  if (cpu_architecture != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.cpu_architecture_.SetAllocated(cpu_architecture, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.cpu_architecture_.IsDefault()) {
    _impl_.cpu_architecture_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.cpu_architecture)
}

// optional string app_cpu_architecture = 21;
inline bool SystemProfileProto_Hardware::_internal_has_app_cpu_architecture() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_app_cpu_architecture() const {
  return _internal_has_app_cpu_architecture();
}
inline void SystemProfileProto_Hardware::clear_app_cpu_architecture() {
  _impl_.app_cpu_architecture_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& SystemProfileProto_Hardware::app_cpu_architecture() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.app_cpu_architecture)
  return _internal_app_cpu_architecture();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware::set_app_cpu_architecture(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.app_cpu_architecture_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.app_cpu_architecture)
}
inline std::string* SystemProfileProto_Hardware::mutable_app_cpu_architecture() {
  std::string* _s = _internal_mutable_app_cpu_architecture();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.app_cpu_architecture)
  return _s;
}
inline const std::string& SystemProfileProto_Hardware::_internal_app_cpu_architecture() const {
  return _impl_.app_cpu_architecture_.Get();
}
inline void SystemProfileProto_Hardware::_internal_set_app_cpu_architecture(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.app_cpu_architecture_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware::_internal_mutable_app_cpu_architecture() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.app_cpu_architecture_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware::release_app_cpu_architecture() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.app_cpu_architecture)
  if (!_internal_has_app_cpu_architecture()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.app_cpu_architecture_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.app_cpu_architecture_.IsDefault()) {
    _impl_.app_cpu_architecture_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_Hardware::set_allocated_app_cpu_architecture(std::string* app_cpu_architecture) {
  if (app_cpu_architecture != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.app_cpu_architecture_.SetAllocated(app_cpu_architecture, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.app_cpu_architecture_.IsDefault()) {
    _impl_.app_cpu_architecture_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.app_cpu_architecture)
}

// optional int64 system_ram_mb = 2;
inline bool SystemProfileProto_Hardware::_internal_has_system_ram_mb() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_system_ram_mb() const {
  return _internal_has_system_ram_mb();
}
inline void SystemProfileProto_Hardware::clear_system_ram_mb() {
  _impl_.system_ram_mb_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline int64_t SystemProfileProto_Hardware::_internal_system_ram_mb() const {
  return _impl_.system_ram_mb_;
}
inline int64_t SystemProfileProto_Hardware::system_ram_mb() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.system_ram_mb)
  return _internal_system_ram_mb();
}
inline void SystemProfileProto_Hardware::_internal_set_system_ram_mb(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.system_ram_mb_ = value;
}
inline void SystemProfileProto_Hardware::set_system_ram_mb(int64_t value) {
  _internal_set_system_ram_mb(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.system_ram_mb)
}

// optional int64 dll_base = 3;
inline bool SystemProfileProto_Hardware::_internal_has_dll_base() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_dll_base() const {
  return _internal_has_dll_base();
}
inline void SystemProfileProto_Hardware::clear_dll_base() {
  _impl_.dll_base_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline int64_t SystemProfileProto_Hardware::_internal_dll_base() const {
  return _impl_.dll_base_;
}
inline int64_t SystemProfileProto_Hardware::dll_base() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.dll_base)
  return _internal_dll_base();
}
inline void SystemProfileProto_Hardware::_internal_set_dll_base(int64_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.dll_base_ = value;
}
inline void SystemProfileProto_Hardware::set_dll_base(int64_t value) {
  _internal_set_dll_base(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.dll_base)
}

// optional string hardware_class = 4;
inline bool SystemProfileProto_Hardware::_internal_has_hardware_class() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_hardware_class() const {
  return _internal_has_hardware_class();
}
inline void SystemProfileProto_Hardware::clear_hardware_class() {
  _impl_.hardware_class_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SystemProfileProto_Hardware::hardware_class() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.hardware_class)
  return _internal_hardware_class();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware::set_hardware_class(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.hardware_class_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.hardware_class)
}
inline std::string* SystemProfileProto_Hardware::mutable_hardware_class() {
  std::string* _s = _internal_mutable_hardware_class();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.hardware_class)
  return _s;
}
inline const std::string& SystemProfileProto_Hardware::_internal_hardware_class() const {
  return _impl_.hardware_class_.Get();
}
inline void SystemProfileProto_Hardware::_internal_set_hardware_class(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.hardware_class_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware::_internal_mutable_hardware_class() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.hardware_class_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware::release_hardware_class() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.hardware_class)
  if (!_internal_has_hardware_class()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.hardware_class_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.hardware_class_.IsDefault()) {
    _impl_.hardware_class_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_Hardware::set_allocated_hardware_class(std::string* hardware_class) {
  if (hardware_class != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.hardware_class_.SetAllocated(hardware_class, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.hardware_class_.IsDefault()) {
    _impl_.hardware_class_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.hardware_class)
}

// optional string full_hardware_class = 18;
inline bool SystemProfileProto_Hardware::_internal_has_full_hardware_class() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_full_hardware_class() const {
  return _internal_has_full_hardware_class();
}
inline void SystemProfileProto_Hardware::clear_full_hardware_class() {
  _impl_.full_hardware_class_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SystemProfileProto_Hardware::full_hardware_class() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.full_hardware_class)
  return _internal_full_hardware_class();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware::set_full_hardware_class(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.full_hardware_class_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.full_hardware_class)
}
inline std::string* SystemProfileProto_Hardware::mutable_full_hardware_class() {
  std::string* _s = _internal_mutable_full_hardware_class();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.full_hardware_class)
  return _s;
}
inline const std::string& SystemProfileProto_Hardware::_internal_full_hardware_class() const {
  return _impl_.full_hardware_class_.Get();
}
inline void SystemProfileProto_Hardware::_internal_set_full_hardware_class(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.full_hardware_class_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware::_internal_mutable_full_hardware_class() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.full_hardware_class_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware::release_full_hardware_class() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.full_hardware_class)
  if (!_internal_has_full_hardware_class()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.full_hardware_class_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.full_hardware_class_.IsDefault()) {
    _impl_.full_hardware_class_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_Hardware::set_allocated_full_hardware_class(std::string* full_hardware_class) {
  if (full_hardware_class != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.full_hardware_class_.SetAllocated(full_hardware_class, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.full_hardware_class_.IsDefault()) {
    _impl_.full_hardware_class_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.full_hardware_class)
}

// optional string cellular_device_variant = 24;
inline bool SystemProfileProto_Hardware::_internal_has_cellular_device_variant() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_cellular_device_variant() const {
  return _internal_has_cellular_device_variant();
}
inline void SystemProfileProto_Hardware::clear_cellular_device_variant() {
  _impl_.cellular_device_variant_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& SystemProfileProto_Hardware::cellular_device_variant() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.cellular_device_variant)
  return _internal_cellular_device_variant();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware::set_cellular_device_variant(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.cellular_device_variant_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.cellular_device_variant)
}
inline std::string* SystemProfileProto_Hardware::mutable_cellular_device_variant() {
  std::string* _s = _internal_mutable_cellular_device_variant();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.cellular_device_variant)
  return _s;
}
inline const std::string& SystemProfileProto_Hardware::_internal_cellular_device_variant() const {
  return _impl_.cellular_device_variant_.Get();
}
inline void SystemProfileProto_Hardware::_internal_set_cellular_device_variant(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.cellular_device_variant_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware::_internal_mutable_cellular_device_variant() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.cellular_device_variant_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware::release_cellular_device_variant() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.cellular_device_variant)
  if (!_internal_has_cellular_device_variant()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.cellular_device_variant_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.cellular_device_variant_.IsDefault()) {
    _impl_.cellular_device_variant_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_Hardware::set_allocated_cellular_device_variant(std::string* cellular_device_variant) {
  if (cellular_device_variant != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.cellular_device_variant_.SetAllocated(cellular_device_variant, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.cellular_device_variant_.IsDefault()) {
    _impl_.cellular_device_variant_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.cellular_device_variant)
}

// optional int32 screen_count = 5;
inline bool SystemProfileProto_Hardware::_internal_has_screen_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_screen_count() const {
  return _internal_has_screen_count();
}
inline void SystemProfileProto_Hardware::clear_screen_count() {
  _impl_.screen_count_ = 0;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline int32_t SystemProfileProto_Hardware::_internal_screen_count() const {
  return _impl_.screen_count_;
}
inline int32_t SystemProfileProto_Hardware::screen_count() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.screen_count)
  return _internal_screen_count();
}
inline void SystemProfileProto_Hardware::_internal_set_screen_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.screen_count_ = value;
}
inline void SystemProfileProto_Hardware::set_screen_count(int32_t value) {
  _internal_set_screen_count(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.screen_count)
}

// optional int32 primary_screen_width = 6;
inline bool SystemProfileProto_Hardware::_internal_has_primary_screen_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_primary_screen_width() const {
  return _internal_has_primary_screen_width();
}
inline void SystemProfileProto_Hardware::clear_primary_screen_width() {
  _impl_.primary_screen_width_ = 0;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline int32_t SystemProfileProto_Hardware::_internal_primary_screen_width() const {
  return _impl_.primary_screen_width_;
}
inline int32_t SystemProfileProto_Hardware::primary_screen_width() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.primary_screen_width)
  return _internal_primary_screen_width();
}
inline void SystemProfileProto_Hardware::_internal_set_primary_screen_width(int32_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.primary_screen_width_ = value;
}
inline void SystemProfileProto_Hardware::set_primary_screen_width(int32_t value) {
  _internal_set_primary_screen_width(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.primary_screen_width)
}

// optional int32 primary_screen_height = 7;
inline bool SystemProfileProto_Hardware::_internal_has_primary_screen_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_primary_screen_height() const {
  return _internal_has_primary_screen_height();
}
inline void SystemProfileProto_Hardware::clear_primary_screen_height() {
  _impl_.primary_screen_height_ = 0;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline int32_t SystemProfileProto_Hardware::_internal_primary_screen_height() const {
  return _impl_.primary_screen_height_;
}
inline int32_t SystemProfileProto_Hardware::primary_screen_height() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.primary_screen_height)
  return _internal_primary_screen_height();
}
inline void SystemProfileProto_Hardware::_internal_set_primary_screen_height(int32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.primary_screen_height_ = value;
}
inline void SystemProfileProto_Hardware::set_primary_screen_height(int32_t value) {
  _internal_set_primary_screen_height(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.primary_screen_height)
}

// optional float primary_screen_scale_factor = 12;
inline bool SystemProfileProto_Hardware::_internal_has_primary_screen_scale_factor() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_primary_screen_scale_factor() const {
  return _internal_has_primary_screen_scale_factor();
}
inline void SystemProfileProto_Hardware::clear_primary_screen_scale_factor() {
  _impl_.primary_screen_scale_factor_ = 0;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline float SystemProfileProto_Hardware::_internal_primary_screen_scale_factor() const {
  return _impl_.primary_screen_scale_factor_;
}
inline float SystemProfileProto_Hardware::primary_screen_scale_factor() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.primary_screen_scale_factor)
  return _internal_primary_screen_scale_factor();
}
inline void SystemProfileProto_Hardware::_internal_set_primary_screen_scale_factor(float value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.primary_screen_scale_factor_ = value;
}
inline void SystemProfileProto_Hardware::set_primary_screen_scale_factor(float value) {
  _internal_set_primary_screen_scale_factor(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.primary_screen_scale_factor)
}

// optional float max_dpi_x = 9;
inline bool SystemProfileProto_Hardware::_internal_has_max_dpi_x() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_max_dpi_x() const {
  return _internal_has_max_dpi_x();
}
inline void SystemProfileProto_Hardware::clear_max_dpi_x() {
  _impl_.max_dpi_x_ = 0;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline float SystemProfileProto_Hardware::_internal_max_dpi_x() const {
  return _impl_.max_dpi_x_;
}
inline float SystemProfileProto_Hardware::max_dpi_x() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.max_dpi_x)
  return _internal_max_dpi_x();
}
inline void SystemProfileProto_Hardware::_internal_set_max_dpi_x(float value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.max_dpi_x_ = value;
}
inline void SystemProfileProto_Hardware::set_max_dpi_x(float value) {
  _internal_set_max_dpi_x(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.max_dpi_x)
}

// optional float max_dpi_y = 10;
inline bool SystemProfileProto_Hardware::_internal_has_max_dpi_y() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_max_dpi_y() const {
  return _internal_has_max_dpi_y();
}
inline void SystemProfileProto_Hardware::clear_max_dpi_y() {
  _impl_.max_dpi_y_ = 0;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline float SystemProfileProto_Hardware::_internal_max_dpi_y() const {
  return _impl_.max_dpi_y_;
}
inline float SystemProfileProto_Hardware::max_dpi_y() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.max_dpi_y)
  return _internal_max_dpi_y();
}
inline void SystemProfileProto_Hardware::_internal_set_max_dpi_y(float value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.max_dpi_y_ = value;
}
inline void SystemProfileProto_Hardware::set_max_dpi_y(float value) {
  _internal_set_max_dpi_y(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.max_dpi_y)
}

// optional .metrics.SystemProfileProto.Hardware.FormFactor form_factor = 22;
inline bool SystemProfileProto_Hardware::_internal_has_form_factor() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_form_factor() const {
  return _internal_has_form_factor();
}
inline void SystemProfileProto_Hardware::clear_form_factor() {
  _impl_.form_factor_ = 0;
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline ::metrics::SystemProfileProto_Hardware_FormFactor SystemProfileProto_Hardware::_internal_form_factor() const {
  return static_cast< ::metrics::SystemProfileProto_Hardware_FormFactor >(_impl_.form_factor_);
}
inline ::metrics::SystemProfileProto_Hardware_FormFactor SystemProfileProto_Hardware::form_factor() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.form_factor)
  return _internal_form_factor();
}
inline void SystemProfileProto_Hardware::_internal_set_form_factor(::metrics::SystemProfileProto_Hardware_FormFactor value) {
  assert(::metrics::SystemProfileProto_Hardware_FormFactor_IsValid(value));
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.form_factor_ = value;
}
inline void SystemProfileProto_Hardware::set_form_factor(::metrics::SystemProfileProto_Hardware_FormFactor value) {
  _internal_set_form_factor(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.form_factor)
}

// optional .metrics.SystemProfileProto.Hardware.CPU cpu = 13;
inline bool SystemProfileProto_Hardware::_internal_has_cpu() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.cpu_ != nullptr);
  return value;
}
inline bool SystemProfileProto_Hardware::has_cpu() const {
  return _internal_has_cpu();
}
inline void SystemProfileProto_Hardware::clear_cpu() {
  if (_impl_.cpu_ != nullptr) _impl_.cpu_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::metrics::SystemProfileProto_Hardware_CPU& SystemProfileProto_Hardware::_internal_cpu() const {
  const ::metrics::SystemProfileProto_Hardware_CPU* p = _impl_.cpu_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_Hardware_CPU&>(
      ::metrics::_SystemProfileProto_Hardware_CPU_default_instance_);
}
inline const ::metrics::SystemProfileProto_Hardware_CPU& SystemProfileProto_Hardware::cpu() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.cpu)
  return _internal_cpu();
}
inline void SystemProfileProto_Hardware::unsafe_arena_set_allocated_cpu(
    ::metrics::SystemProfileProto_Hardware_CPU* cpu) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cpu_);
  }
  _impl_.cpu_ = cpu;
  if (cpu) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.Hardware.cpu)
}
inline ::metrics::SystemProfileProto_Hardware_CPU* SystemProfileProto_Hardware::release_cpu() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::metrics::SystemProfileProto_Hardware_CPU* temp = _impl_.cpu_;
  _impl_.cpu_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_Hardware_CPU* SystemProfileProto_Hardware::unsafe_arena_release_cpu() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.cpu)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::metrics::SystemProfileProto_Hardware_CPU* temp = _impl_.cpu_;
  _impl_.cpu_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_Hardware_CPU* SystemProfileProto_Hardware::_internal_mutable_cpu() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.cpu_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_Hardware_CPU>(GetArenaForAllocation());
    _impl_.cpu_ = p;
  }
  return _impl_.cpu_;
}
inline ::metrics::SystemProfileProto_Hardware_CPU* SystemProfileProto_Hardware::mutable_cpu() {
  ::metrics::SystemProfileProto_Hardware_CPU* _msg = _internal_mutable_cpu();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.cpu)
  return _msg;
}
inline void SystemProfileProto_Hardware::set_allocated_cpu(::metrics::SystemProfileProto_Hardware_CPU* cpu) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.cpu_;
  }
  if (cpu) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cpu);
    if (message_arena != submessage_arena) {
      cpu = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cpu, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.cpu_ = cpu;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.cpu)
}

// optional .metrics.SystemProfileProto.Hardware.Motherboard motherboard = 25;
inline bool SystemProfileProto_Hardware::_internal_has_motherboard() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.motherboard_ != nullptr);
  return value;
}
inline bool SystemProfileProto_Hardware::has_motherboard() const {
  return _internal_has_motherboard();
}
inline void SystemProfileProto_Hardware::clear_motherboard() {
  if (_impl_.motherboard_ != nullptr) _impl_.motherboard_->Clear();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const ::metrics::SystemProfileProto_Hardware_Motherboard& SystemProfileProto_Hardware::_internal_motherboard() const {
  const ::metrics::SystemProfileProto_Hardware_Motherboard* p = _impl_.motherboard_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_Hardware_Motherboard&>(
      ::metrics::_SystemProfileProto_Hardware_Motherboard_default_instance_);
}
inline const ::metrics::SystemProfileProto_Hardware_Motherboard& SystemProfileProto_Hardware::motherboard() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.motherboard)
  return _internal_motherboard();
}
inline void SystemProfileProto_Hardware::unsafe_arena_set_allocated_motherboard(
    ::metrics::SystemProfileProto_Hardware_Motherboard* motherboard) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.motherboard_);
  }
  _impl_.motherboard_ = motherboard;
  if (motherboard) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.Hardware.motherboard)
}
inline ::metrics::SystemProfileProto_Hardware_Motherboard* SystemProfileProto_Hardware::release_motherboard() {
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::metrics::SystemProfileProto_Hardware_Motherboard* temp = _impl_.motherboard_;
  _impl_.motherboard_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_Hardware_Motherboard* SystemProfileProto_Hardware::unsafe_arena_release_motherboard() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.motherboard)
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::metrics::SystemProfileProto_Hardware_Motherboard* temp = _impl_.motherboard_;
  _impl_.motherboard_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_Hardware_Motherboard* SystemProfileProto_Hardware::_internal_mutable_motherboard() {
  _impl_._has_bits_[0] |= 0x00000400u;
  if (_impl_.motherboard_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_Hardware_Motherboard>(GetArenaForAllocation());
    _impl_.motherboard_ = p;
  }
  return _impl_.motherboard_;
}
inline ::metrics::SystemProfileProto_Hardware_Motherboard* SystemProfileProto_Hardware::mutable_motherboard() {
  ::metrics::SystemProfileProto_Hardware_Motherboard* _msg = _internal_mutable_motherboard();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.motherboard)
  return _msg;
}
inline void SystemProfileProto_Hardware::set_allocated_motherboard(::metrics::SystemProfileProto_Hardware_Motherboard* motherboard) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.motherboard_;
  }
  if (motherboard) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(motherboard);
    if (message_arena != submessage_arena) {
      motherboard = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, motherboard, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.motherboard_ = motherboard;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.motherboard)
}

// optional .metrics.SystemProfileProto.Hardware.Graphics gpu = 8;
inline bool SystemProfileProto_Hardware::_internal_has_gpu() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.gpu_ != nullptr);
  return value;
}
inline bool SystemProfileProto_Hardware::has_gpu() const {
  return _internal_has_gpu();
}
inline void SystemProfileProto_Hardware::clear_gpu() {
  if (_impl_.gpu_ != nullptr) _impl_.gpu_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::metrics::SystemProfileProto_Hardware_Graphics& SystemProfileProto_Hardware::_internal_gpu() const {
  const ::metrics::SystemProfileProto_Hardware_Graphics* p = _impl_.gpu_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_Hardware_Graphics&>(
      ::metrics::_SystemProfileProto_Hardware_Graphics_default_instance_);
}
inline const ::metrics::SystemProfileProto_Hardware_Graphics& SystemProfileProto_Hardware::gpu() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.gpu)
  return _internal_gpu();
}
inline void SystemProfileProto_Hardware::unsafe_arena_set_allocated_gpu(
    ::metrics::SystemProfileProto_Hardware_Graphics* gpu) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.gpu_);
  }
  _impl_.gpu_ = gpu;
  if (gpu) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.Hardware.gpu)
}
inline ::metrics::SystemProfileProto_Hardware_Graphics* SystemProfileProto_Hardware::release_gpu() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::metrics::SystemProfileProto_Hardware_Graphics* temp = _impl_.gpu_;
  _impl_.gpu_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_Hardware_Graphics* SystemProfileProto_Hardware::unsafe_arena_release_gpu() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.gpu)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::metrics::SystemProfileProto_Hardware_Graphics* temp = _impl_.gpu_;
  _impl_.gpu_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_Hardware_Graphics* SystemProfileProto_Hardware::_internal_mutable_gpu() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.gpu_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_Hardware_Graphics>(GetArenaForAllocation());
    _impl_.gpu_ = p;
  }
  return _impl_.gpu_;
}
inline ::metrics::SystemProfileProto_Hardware_Graphics* SystemProfileProto_Hardware::mutable_gpu() {
  ::metrics::SystemProfileProto_Hardware_Graphics* _msg = _internal_mutable_gpu();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.gpu)
  return _msg;
}
inline void SystemProfileProto_Hardware::set_allocated_gpu(::metrics::SystemProfileProto_Hardware_Graphics* gpu) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.gpu_;
  }
  if (gpu) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(gpu);
    if (message_arena != submessage_arena) {
      gpu = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, gpu, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.gpu_ = gpu;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.gpu)
}

// optional bool internal_display_supports_touch = 14;
inline bool SystemProfileProto_Hardware::_internal_has_internal_display_supports_touch() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_internal_display_supports_touch() const {
  return _internal_has_internal_display_supports_touch();
}
inline void SystemProfileProto_Hardware::clear_internal_display_supports_touch() {
  _impl_.internal_display_supports_touch_ = false;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline bool SystemProfileProto_Hardware::_internal_internal_display_supports_touch() const {
  return _impl_.internal_display_supports_touch_;
}
inline bool SystemProfileProto_Hardware::internal_display_supports_touch() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.internal_display_supports_touch)
  return _internal_internal_display_supports_touch();
}
inline void SystemProfileProto_Hardware::_internal_set_internal_display_supports_touch(bool value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.internal_display_supports_touch_ = value;
}
inline void SystemProfileProto_Hardware::set_internal_display_supports_touch(bool value) {
  _internal_set_internal_display_supports_touch(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.internal_display_supports_touch)
}

// repeated .metrics.SystemProfileProto.Hardware.InternalStorageDevice internal_storage_devices = 20;
inline int SystemProfileProto_Hardware::_internal_internal_storage_devices_size() const {
  return _impl_.internal_storage_devices_.size();
}
inline int SystemProfileProto_Hardware::internal_storage_devices_size() const {
  return _internal_internal_storage_devices_size();
}
inline void SystemProfileProto_Hardware::clear_internal_storage_devices() {
  _impl_.internal_storage_devices_.Clear();
}
inline ::metrics::SystemProfileProto_Hardware_InternalStorageDevice* SystemProfileProto_Hardware::mutable_internal_storage_devices(int index) {
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.internal_storage_devices)
  return _impl_.internal_storage_devices_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_Hardware_InternalStorageDevice >*
SystemProfileProto_Hardware::mutable_internal_storage_devices() {
  // @@protoc_insertion_point(field_mutable_list:metrics.SystemProfileProto.Hardware.internal_storage_devices)
  return &_impl_.internal_storage_devices_;
}
inline const ::metrics::SystemProfileProto_Hardware_InternalStorageDevice& SystemProfileProto_Hardware::_internal_internal_storage_devices(int index) const {
  return _impl_.internal_storage_devices_.Get(index);
}
inline const ::metrics::SystemProfileProto_Hardware_InternalStorageDevice& SystemProfileProto_Hardware::internal_storage_devices(int index) const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.internal_storage_devices)
  return _internal_internal_storage_devices(index);
}
inline ::metrics::SystemProfileProto_Hardware_InternalStorageDevice* SystemProfileProto_Hardware::_internal_add_internal_storage_devices() {
  return _impl_.internal_storage_devices_.Add();
}
inline ::metrics::SystemProfileProto_Hardware_InternalStorageDevice* SystemProfileProto_Hardware::add_internal_storage_devices() {
  ::metrics::SystemProfileProto_Hardware_InternalStorageDevice* _add = _internal_add_internal_storage_devices();
  // @@protoc_insertion_point(field_add:metrics.SystemProfileProto.Hardware.internal_storage_devices)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_Hardware_InternalStorageDevice >&
SystemProfileProto_Hardware::internal_storage_devices() const {
  // @@protoc_insertion_point(field_list:metrics.SystemProfileProto.Hardware.internal_storage_devices)
  return _impl_.internal_storage_devices_;
}

// optional .metrics.SystemProfileProto.Hardware.Drive app_drive = 16;
inline bool SystemProfileProto_Hardware::_internal_has_app_drive() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.app_drive_ != nullptr);
  return value;
}
inline bool SystemProfileProto_Hardware::has_app_drive() const {
  return _internal_has_app_drive();
}
inline void SystemProfileProto_Hardware::clear_app_drive() {
  if (_impl_.app_drive_ != nullptr) _impl_.app_drive_->Clear();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const ::metrics::SystemProfileProto_Hardware_Drive& SystemProfileProto_Hardware::_internal_app_drive() const {
  const ::metrics::SystemProfileProto_Hardware_Drive* p = _impl_.app_drive_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_Hardware_Drive&>(
      ::metrics::_SystemProfileProto_Hardware_Drive_default_instance_);
}
inline const ::metrics::SystemProfileProto_Hardware_Drive& SystemProfileProto_Hardware::app_drive() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.app_drive)
  return _internal_app_drive();
}
inline void SystemProfileProto_Hardware::unsafe_arena_set_allocated_app_drive(
    ::metrics::SystemProfileProto_Hardware_Drive* app_drive) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.app_drive_);
  }
  _impl_.app_drive_ = app_drive;
  if (app_drive) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.Hardware.app_drive)
}
inline ::metrics::SystemProfileProto_Hardware_Drive* SystemProfileProto_Hardware::release_app_drive() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::metrics::SystemProfileProto_Hardware_Drive* temp = _impl_.app_drive_;
  _impl_.app_drive_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_Hardware_Drive* SystemProfileProto_Hardware::unsafe_arena_release_app_drive() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.app_drive)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::metrics::SystemProfileProto_Hardware_Drive* temp = _impl_.app_drive_;
  _impl_.app_drive_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_Hardware_Drive* SystemProfileProto_Hardware::_internal_mutable_app_drive() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.app_drive_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_Hardware_Drive>(GetArenaForAllocation());
    _impl_.app_drive_ = p;
  }
  return _impl_.app_drive_;
}
inline ::metrics::SystemProfileProto_Hardware_Drive* SystemProfileProto_Hardware::mutable_app_drive() {
  ::metrics::SystemProfileProto_Hardware_Drive* _msg = _internal_mutable_app_drive();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.app_drive)
  return _msg;
}
inline void SystemProfileProto_Hardware::set_allocated_app_drive(::metrics::SystemProfileProto_Hardware_Drive* app_drive) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.app_drive_;
  }
  if (app_drive) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(app_drive);
    if (message_arena != submessage_arena) {
      app_drive = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, app_drive, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.app_drive_ = app_drive;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.app_drive)
}

// optional .metrics.SystemProfileProto.Hardware.Drive user_data_drive = 17;
inline bool SystemProfileProto_Hardware::_internal_has_user_data_drive() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.user_data_drive_ != nullptr);
  return value;
}
inline bool SystemProfileProto_Hardware::has_user_data_drive() const {
  return _internal_has_user_data_drive();
}
inline void SystemProfileProto_Hardware::clear_user_data_drive() {
  if (_impl_.user_data_drive_ != nullptr) _impl_.user_data_drive_->Clear();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const ::metrics::SystemProfileProto_Hardware_Drive& SystemProfileProto_Hardware::_internal_user_data_drive() const {
  const ::metrics::SystemProfileProto_Hardware_Drive* p = _impl_.user_data_drive_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_Hardware_Drive&>(
      ::metrics::_SystemProfileProto_Hardware_Drive_default_instance_);
}
inline const ::metrics::SystemProfileProto_Hardware_Drive& SystemProfileProto_Hardware::user_data_drive() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.user_data_drive)
  return _internal_user_data_drive();
}
inline void SystemProfileProto_Hardware::unsafe_arena_set_allocated_user_data_drive(
    ::metrics::SystemProfileProto_Hardware_Drive* user_data_drive) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.user_data_drive_);
  }
  _impl_.user_data_drive_ = user_data_drive;
  if (user_data_drive) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.Hardware.user_data_drive)
}
inline ::metrics::SystemProfileProto_Hardware_Drive* SystemProfileProto_Hardware::release_user_data_drive() {
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::metrics::SystemProfileProto_Hardware_Drive* temp = _impl_.user_data_drive_;
  _impl_.user_data_drive_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_Hardware_Drive* SystemProfileProto_Hardware::unsafe_arena_release_user_data_drive() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.user_data_drive)
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::metrics::SystemProfileProto_Hardware_Drive* temp = _impl_.user_data_drive_;
  _impl_.user_data_drive_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_Hardware_Drive* SystemProfileProto_Hardware::_internal_mutable_user_data_drive() {
  _impl_._has_bits_[0] |= 0x00000200u;
  if (_impl_.user_data_drive_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_Hardware_Drive>(GetArenaForAllocation());
    _impl_.user_data_drive_ = p;
  }
  return _impl_.user_data_drive_;
}
inline ::metrics::SystemProfileProto_Hardware_Drive* SystemProfileProto_Hardware::mutable_user_data_drive() {
  ::metrics::SystemProfileProto_Hardware_Drive* _msg = _internal_mutable_user_data_drive();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.user_data_drive)
  return _msg;
}
inline void SystemProfileProto_Hardware::set_allocated_user_data_drive(::metrics::SystemProfileProto_Hardware_Drive* user_data_drive) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.user_data_drive_;
  }
  if (user_data_drive) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(user_data_drive);
    if (message_arena != submessage_arena) {
      user_data_drive = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, user_data_drive, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.user_data_drive_ = user_data_drive;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.user_data_drive)
}

// optional .metrics.SystemProfileProto.Hardware.TpmType tpm_type = 23;
inline bool SystemProfileProto_Hardware::_internal_has_tpm_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_tpm_type() const {
  return _internal_has_tpm_type();
}
inline void SystemProfileProto_Hardware::clear_tpm_type() {
  _impl_.tpm_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline ::metrics::SystemProfileProto_Hardware_TpmType SystemProfileProto_Hardware::_internal_tpm_type() const {
  return static_cast< ::metrics::SystemProfileProto_Hardware_TpmType >(_impl_.tpm_type_);
}
inline ::metrics::SystemProfileProto_Hardware_TpmType SystemProfileProto_Hardware::tpm_type() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.tpm_type)
  return _internal_tpm_type();
}
inline void SystemProfileProto_Hardware::_internal_set_tpm_type(::metrics::SystemProfileProto_Hardware_TpmType value) {
  assert(::metrics::SystemProfileProto_Hardware_TpmType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00400000u;
  _impl_.tpm_type_ = value;
}
inline void SystemProfileProto_Hardware::set_tpm_type(::metrics::SystemProfileProto_Hardware_TpmType value) {
  _internal_set_tpm_type(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.tpm_type)
}

// optional uint64 tpm_firmware_version = 26;
inline bool SystemProfileProto_Hardware::_internal_has_tpm_firmware_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_tpm_firmware_version() const {
  return _internal_has_tpm_firmware_version();
}
inline void SystemProfileProto_Hardware::clear_tpm_firmware_version() {
  _impl_.tpm_firmware_version_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline uint64_t SystemProfileProto_Hardware::_internal_tpm_firmware_version() const {
  return _impl_.tpm_firmware_version_;
}
inline uint64_t SystemProfileProto_Hardware::tpm_firmware_version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.tpm_firmware_version)
  return _internal_tpm_firmware_version();
}
inline void SystemProfileProto_Hardware::_internal_set_tpm_firmware_version(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.tpm_firmware_version_ = value;
}
inline void SystemProfileProto_Hardware::set_tpm_firmware_version(uint64_t value) {
  _internal_set_tpm_firmware_version(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.tpm_firmware_version)
}

// optional string tpm_rw_firmware_version = 27;
inline bool SystemProfileProto_Hardware::_internal_has_tpm_rw_firmware_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SystemProfileProto_Hardware::has_tpm_rw_firmware_version() const {
  return _internal_has_tpm_rw_firmware_version();
}
inline void SystemProfileProto_Hardware::clear_tpm_rw_firmware_version() {
  _impl_.tpm_rw_firmware_version_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& SystemProfileProto_Hardware::tpm_rw_firmware_version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Hardware.tpm_rw_firmware_version)
  return _internal_tpm_rw_firmware_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_Hardware::set_tpm_rw_firmware_version(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.tpm_rw_firmware_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Hardware.tpm_rw_firmware_version)
}
inline std::string* SystemProfileProto_Hardware::mutable_tpm_rw_firmware_version() {
  std::string* _s = _internal_mutable_tpm_rw_firmware_version();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.Hardware.tpm_rw_firmware_version)
  return _s;
}
inline const std::string& SystemProfileProto_Hardware::_internal_tpm_rw_firmware_version() const {
  return _impl_.tpm_rw_firmware_version_.Get();
}
inline void SystemProfileProto_Hardware::_internal_set_tpm_rw_firmware_version(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.tpm_rw_firmware_version_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware::_internal_mutable_tpm_rw_firmware_version() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.tpm_rw_firmware_version_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_Hardware::release_tpm_rw_firmware_version() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.Hardware.tpm_rw_firmware_version)
  if (!_internal_has_tpm_rw_firmware_version()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.tpm_rw_firmware_version_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.tpm_rw_firmware_version_.IsDefault()) {
    _impl_.tpm_rw_firmware_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_Hardware::set_allocated_tpm_rw_firmware_version(std::string* tpm_rw_firmware_version) {
  if (tpm_rw_firmware_version != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.tpm_rw_firmware_version_.SetAllocated(tpm_rw_firmware_version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.tpm_rw_firmware_version_.IsDefault()) {
    _impl_.tpm_rw_firmware_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.Hardware.tpm_rw_firmware_version)
}

// -------------------------------------------------------------------

// SystemProfileProto_Network

// optional bool connection_type_is_ambiguous = 1;
inline bool SystemProfileProto_Network::_internal_has_connection_type_is_ambiguous() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_Network::has_connection_type_is_ambiguous() const {
  return _internal_has_connection_type_is_ambiguous();
}
inline void SystemProfileProto_Network::clear_connection_type_is_ambiguous() {
  _impl_.connection_type_is_ambiguous_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool SystemProfileProto_Network::_internal_connection_type_is_ambiguous() const {
  return _impl_.connection_type_is_ambiguous_;
}
inline bool SystemProfileProto_Network::connection_type_is_ambiguous() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Network.connection_type_is_ambiguous)
  return _internal_connection_type_is_ambiguous();
}
inline void SystemProfileProto_Network::_internal_set_connection_type_is_ambiguous(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.connection_type_is_ambiguous_ = value;
}
inline void SystemProfileProto_Network::set_connection_type_is_ambiguous(bool value) {
  _internal_set_connection_type_is_ambiguous(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Network.connection_type_is_ambiguous)
}

// optional .metrics.SystemProfileProto.Network.ConnectionType connection_type = 2;
inline bool SystemProfileProto_Network::_internal_has_connection_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_Network::has_connection_type() const {
  return _internal_has_connection_type();
}
inline void SystemProfileProto_Network::clear_connection_type() {
  _impl_.connection_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::metrics::SystemProfileProto_Network_ConnectionType SystemProfileProto_Network::_internal_connection_type() const {
  return static_cast< ::metrics::SystemProfileProto_Network_ConnectionType >(_impl_.connection_type_);
}
inline ::metrics::SystemProfileProto_Network_ConnectionType SystemProfileProto_Network::connection_type() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Network.connection_type)
  return _internal_connection_type();
}
inline void SystemProfileProto_Network::_internal_set_connection_type(::metrics::SystemProfileProto_Network_ConnectionType value) {
  assert(::metrics::SystemProfileProto_Network_ConnectionType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.connection_type_ = value;
}
inline void SystemProfileProto_Network::set_connection_type(::metrics::SystemProfileProto_Network_ConnectionType value) {
  _internal_set_connection_type(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Network.connection_type)
}

// optional bool wifi_phy_layer_protocol_is_ambiguous = 3;
inline bool SystemProfileProto_Network::_internal_has_wifi_phy_layer_protocol_is_ambiguous() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_Network::has_wifi_phy_layer_protocol_is_ambiguous() const {
  return _internal_has_wifi_phy_layer_protocol_is_ambiguous();
}
inline void SystemProfileProto_Network::clear_wifi_phy_layer_protocol_is_ambiguous() {
  _impl_.wifi_phy_layer_protocol_is_ambiguous_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool SystemProfileProto_Network::_internal_wifi_phy_layer_protocol_is_ambiguous() const {
  return _impl_.wifi_phy_layer_protocol_is_ambiguous_;
}
inline bool SystemProfileProto_Network::wifi_phy_layer_protocol_is_ambiguous() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Network.wifi_phy_layer_protocol_is_ambiguous)
  return _internal_wifi_phy_layer_protocol_is_ambiguous();
}
inline void SystemProfileProto_Network::_internal_set_wifi_phy_layer_protocol_is_ambiguous(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.wifi_phy_layer_protocol_is_ambiguous_ = value;
}
inline void SystemProfileProto_Network::set_wifi_phy_layer_protocol_is_ambiguous(bool value) {
  _internal_set_wifi_phy_layer_protocol_is_ambiguous(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Network.wifi_phy_layer_protocol_is_ambiguous)
}

// optional .metrics.SystemProfileProto.Network.WifiPHYLayerProtocol wifi_phy_layer_protocol = 4;
inline bool SystemProfileProto_Network::_internal_has_wifi_phy_layer_protocol() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_Network::has_wifi_phy_layer_protocol() const {
  return _internal_has_wifi_phy_layer_protocol();
}
inline void SystemProfileProto_Network::clear_wifi_phy_layer_protocol() {
  _impl_.wifi_phy_layer_protocol_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::metrics::SystemProfileProto_Network_WifiPHYLayerProtocol SystemProfileProto_Network::_internal_wifi_phy_layer_protocol() const {
  return static_cast< ::metrics::SystemProfileProto_Network_WifiPHYLayerProtocol >(_impl_.wifi_phy_layer_protocol_);
}
inline ::metrics::SystemProfileProto_Network_WifiPHYLayerProtocol SystemProfileProto_Network::wifi_phy_layer_protocol() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Network.wifi_phy_layer_protocol)
  return _internal_wifi_phy_layer_protocol();
}
inline void SystemProfileProto_Network::_internal_set_wifi_phy_layer_protocol(::metrics::SystemProfileProto_Network_WifiPHYLayerProtocol value) {
  assert(::metrics::SystemProfileProto_Network_WifiPHYLayerProtocol_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.wifi_phy_layer_protocol_ = value;
}
inline void SystemProfileProto_Network::set_wifi_phy_layer_protocol(::metrics::SystemProfileProto_Network_WifiPHYLayerProtocol value) {
  _internal_set_wifi_phy_layer_protocol(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Network.wifi_phy_layer_protocol)
}

// optional .metrics.SystemProfileProto.Network.EffectiveConnectionType min_effective_connection_type = 7;
inline bool SystemProfileProto_Network::_internal_has_min_effective_connection_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SystemProfileProto_Network::has_min_effective_connection_type() const {
  return _internal_has_min_effective_connection_type();
}
inline void SystemProfileProto_Network::clear_min_effective_connection_type() {
  _impl_.min_effective_connection_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline ::metrics::SystemProfileProto_Network_EffectiveConnectionType SystemProfileProto_Network::_internal_min_effective_connection_type() const {
  return static_cast< ::metrics::SystemProfileProto_Network_EffectiveConnectionType >(_impl_.min_effective_connection_type_);
}
inline ::metrics::SystemProfileProto_Network_EffectiveConnectionType SystemProfileProto_Network::min_effective_connection_type() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Network.min_effective_connection_type)
  return _internal_min_effective_connection_type();
}
inline void SystemProfileProto_Network::_internal_set_min_effective_connection_type(::metrics::SystemProfileProto_Network_EffectiveConnectionType value) {
  assert(::metrics::SystemProfileProto_Network_EffectiveConnectionType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.min_effective_connection_type_ = value;
}
inline void SystemProfileProto_Network::set_min_effective_connection_type(::metrics::SystemProfileProto_Network_EffectiveConnectionType value) {
  _internal_set_min_effective_connection_type(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Network.min_effective_connection_type)
}

// optional .metrics.SystemProfileProto.Network.EffectiveConnectionType max_effective_connection_type = 8;
inline bool SystemProfileProto_Network::_internal_has_max_effective_connection_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SystemProfileProto_Network::has_max_effective_connection_type() const {
  return _internal_has_max_effective_connection_type();
}
inline void SystemProfileProto_Network::clear_max_effective_connection_type() {
  _impl_.max_effective_connection_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline ::metrics::SystemProfileProto_Network_EffectiveConnectionType SystemProfileProto_Network::_internal_max_effective_connection_type() const {
  return static_cast< ::metrics::SystemProfileProto_Network_EffectiveConnectionType >(_impl_.max_effective_connection_type_);
}
inline ::metrics::SystemProfileProto_Network_EffectiveConnectionType SystemProfileProto_Network::max_effective_connection_type() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Network.max_effective_connection_type)
  return _internal_max_effective_connection_type();
}
inline void SystemProfileProto_Network::_internal_set_max_effective_connection_type(::metrics::SystemProfileProto_Network_EffectiveConnectionType value) {
  assert(::metrics::SystemProfileProto_Network_EffectiveConnectionType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.max_effective_connection_type_ = value;
}
inline void SystemProfileProto_Network::set_max_effective_connection_type(::metrics::SystemProfileProto_Network_EffectiveConnectionType value) {
  _internal_set_max_effective_connection_type(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Network.max_effective_connection_type)
}

// -------------------------------------------------------------------

// SystemProfileProto_GoogleUpdate_ProductInfo

// optional string version = 1;
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::has_version() const {
  return _internal_has_version();
}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::clear_version() {
  _impl_.version_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SystemProfileProto_GoogleUpdate_ProductInfo::version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.GoogleUpdate.ProductInfo.version)
  return _internal_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_GoogleUpdate_ProductInfo::set_version(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.GoogleUpdate.ProductInfo.version)
}
inline std::string* SystemProfileProto_GoogleUpdate_ProductInfo::mutable_version() {
  std::string* _s = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.GoogleUpdate.ProductInfo.version)
  return _s;
}
inline const std::string& SystemProfileProto_GoogleUpdate_ProductInfo::_internal_version() const {
  return _impl_.version_.Get();
}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::_internal_set_version(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.version_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_GoogleUpdate_ProductInfo::_internal_mutable_version() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.version_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_GoogleUpdate_ProductInfo::release_version() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.GoogleUpdate.ProductInfo.version)
  if (!_internal_has_version()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.version_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.version_.IsDefault()) {
    _impl_.version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::set_allocated_version(std::string* version) {
  if (version != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.version_.IsDefault()) {
    _impl_.version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.GoogleUpdate.ProductInfo.version)
}

// optional int64 last_update_success_timestamp = 2;
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::_internal_has_last_update_success_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::has_last_update_success_timestamp() const {
  return _internal_has_last_update_success_timestamp();
}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::clear_last_update_success_timestamp() {
  _impl_.last_update_success_timestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int64_t SystemProfileProto_GoogleUpdate_ProductInfo::_internal_last_update_success_timestamp() const {
  return _impl_.last_update_success_timestamp_;
}
inline int64_t SystemProfileProto_GoogleUpdate_ProductInfo::last_update_success_timestamp() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.GoogleUpdate.ProductInfo.last_update_success_timestamp)
  return _internal_last_update_success_timestamp();
}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::_internal_set_last_update_success_timestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.last_update_success_timestamp_ = value;
}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::set_last_update_success_timestamp(int64_t value) {
  _internal_set_last_update_success_timestamp(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.GoogleUpdate.ProductInfo.last_update_success_timestamp)
}

// optional .metrics.SystemProfileProto.GoogleUpdate.ProductInfo.InstallResult last_result = 3;
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::_internal_has_last_result() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::has_last_result() const {
  return _internal_has_last_result();
}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::clear_last_result() {
  _impl_.last_result_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult SystemProfileProto_GoogleUpdate_ProductInfo::_internal_last_result() const {
  return static_cast< ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult >(_impl_.last_result_);
}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult SystemProfileProto_GoogleUpdate_ProductInfo::last_result() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.GoogleUpdate.ProductInfo.last_result)
  return _internal_last_result();
}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::_internal_set_last_result(::metrics::SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult value) {
  assert(::metrics::SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.last_result_ = value;
}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::set_last_result(::metrics::SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult value) {
  _internal_set_last_result(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.GoogleUpdate.ProductInfo.last_result)
}

// optional int32 last_error = 4;
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::_internal_has_last_error() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::has_last_error() const {
  return _internal_has_last_error();
}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::clear_last_error() {
  _impl_.last_error_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t SystemProfileProto_GoogleUpdate_ProductInfo::_internal_last_error() const {
  return _impl_.last_error_;
}
inline int32_t SystemProfileProto_GoogleUpdate_ProductInfo::last_error() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.GoogleUpdate.ProductInfo.last_error)
  return _internal_last_error();
}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::_internal_set_last_error(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.last_error_ = value;
}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::set_last_error(int32_t value) {
  _internal_set_last_error(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.GoogleUpdate.ProductInfo.last_error)
}

// optional int32 last_extra_error = 5;
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::_internal_has_last_extra_error() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SystemProfileProto_GoogleUpdate_ProductInfo::has_last_extra_error() const {
  return _internal_has_last_extra_error();
}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::clear_last_extra_error() {
  _impl_.last_extra_error_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t SystemProfileProto_GoogleUpdate_ProductInfo::_internal_last_extra_error() const {
  return _impl_.last_extra_error_;
}
inline int32_t SystemProfileProto_GoogleUpdate_ProductInfo::last_extra_error() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.GoogleUpdate.ProductInfo.last_extra_error)
  return _internal_last_extra_error();
}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::_internal_set_last_extra_error(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.last_extra_error_ = value;
}
inline void SystemProfileProto_GoogleUpdate_ProductInfo::set_last_extra_error(int32_t value) {
  _internal_set_last_extra_error(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.GoogleUpdate.ProductInfo.last_extra_error)
}

// -------------------------------------------------------------------

// SystemProfileProto_GoogleUpdate

// optional bool is_system_install = 1;
inline bool SystemProfileProto_GoogleUpdate::_internal_has_is_system_install() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SystemProfileProto_GoogleUpdate::has_is_system_install() const {
  return _internal_has_is_system_install();
}
inline void SystemProfileProto_GoogleUpdate::clear_is_system_install() {
  _impl_.is_system_install_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool SystemProfileProto_GoogleUpdate::_internal_is_system_install() const {
  return _impl_.is_system_install_;
}
inline bool SystemProfileProto_GoogleUpdate::is_system_install() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.GoogleUpdate.is_system_install)
  return _internal_is_system_install();
}
inline void SystemProfileProto_GoogleUpdate::_internal_set_is_system_install(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.is_system_install_ = value;
}
inline void SystemProfileProto_GoogleUpdate::set_is_system_install(bool value) {
  _internal_set_is_system_install(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.GoogleUpdate.is_system_install)
}

// optional int64 last_automatic_start_timestamp = 2;
inline bool SystemProfileProto_GoogleUpdate::_internal_has_last_automatic_start_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_GoogleUpdate::has_last_automatic_start_timestamp() const {
  return _internal_has_last_automatic_start_timestamp();
}
inline void SystemProfileProto_GoogleUpdate::clear_last_automatic_start_timestamp() {
  _impl_.last_automatic_start_timestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int64_t SystemProfileProto_GoogleUpdate::_internal_last_automatic_start_timestamp() const {
  return _impl_.last_automatic_start_timestamp_;
}
inline int64_t SystemProfileProto_GoogleUpdate::last_automatic_start_timestamp() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.GoogleUpdate.last_automatic_start_timestamp)
  return _internal_last_automatic_start_timestamp();
}
inline void SystemProfileProto_GoogleUpdate::_internal_set_last_automatic_start_timestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.last_automatic_start_timestamp_ = value;
}
inline void SystemProfileProto_GoogleUpdate::set_last_automatic_start_timestamp(int64_t value) {
  _internal_set_last_automatic_start_timestamp(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.GoogleUpdate.last_automatic_start_timestamp)
}

// optional int64 last_update_check_timestamp = 3;
inline bool SystemProfileProto_GoogleUpdate::_internal_has_last_update_check_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_GoogleUpdate::has_last_update_check_timestamp() const {
  return _internal_has_last_update_check_timestamp();
}
inline void SystemProfileProto_GoogleUpdate::clear_last_update_check_timestamp() {
  _impl_.last_update_check_timestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int64_t SystemProfileProto_GoogleUpdate::_internal_last_update_check_timestamp() const {
  return _impl_.last_update_check_timestamp_;
}
inline int64_t SystemProfileProto_GoogleUpdate::last_update_check_timestamp() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.GoogleUpdate.last_update_check_timestamp)
  return _internal_last_update_check_timestamp();
}
inline void SystemProfileProto_GoogleUpdate::_internal_set_last_update_check_timestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.last_update_check_timestamp_ = value;
}
inline void SystemProfileProto_GoogleUpdate::set_last_update_check_timestamp(int64_t value) {
  _internal_set_last_update_check_timestamp(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.GoogleUpdate.last_update_check_timestamp)
}

// optional .metrics.SystemProfileProto.GoogleUpdate.ProductInfo google_update_status = 4;
inline bool SystemProfileProto_GoogleUpdate::_internal_has_google_update_status() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.google_update_status_ != nullptr);
  return value;
}
inline bool SystemProfileProto_GoogleUpdate::has_google_update_status() const {
  return _internal_has_google_update_status();
}
inline void SystemProfileProto_GoogleUpdate::clear_google_update_status() {
  if (_impl_.google_update_status_ != nullptr) _impl_.google_update_status_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo& SystemProfileProto_GoogleUpdate::_internal_google_update_status() const {
  const ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* p = _impl_.google_update_status_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo&>(
      ::metrics::_SystemProfileProto_GoogleUpdate_ProductInfo_default_instance_);
}
inline const ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo& SystemProfileProto_GoogleUpdate::google_update_status() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.GoogleUpdate.google_update_status)
  return _internal_google_update_status();
}
inline void SystemProfileProto_GoogleUpdate::unsafe_arena_set_allocated_google_update_status(
    ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* google_update_status) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.google_update_status_);
  }
  _impl_.google_update_status_ = google_update_status;
  if (google_update_status) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.GoogleUpdate.google_update_status)
}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* SystemProfileProto_GoogleUpdate::release_google_update_status() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* temp = _impl_.google_update_status_;
  _impl_.google_update_status_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* SystemProfileProto_GoogleUpdate::unsafe_arena_release_google_update_status() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.GoogleUpdate.google_update_status)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* temp = _impl_.google_update_status_;
  _impl_.google_update_status_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* SystemProfileProto_GoogleUpdate::_internal_mutable_google_update_status() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.google_update_status_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_GoogleUpdate_ProductInfo>(GetArenaForAllocation());
    _impl_.google_update_status_ = p;
  }
  return _impl_.google_update_status_;
}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* SystemProfileProto_GoogleUpdate::mutable_google_update_status() {
  ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* _msg = _internal_mutable_google_update_status();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.GoogleUpdate.google_update_status)
  return _msg;
}
inline void SystemProfileProto_GoogleUpdate::set_allocated_google_update_status(::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* google_update_status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.google_update_status_;
  }
  if (google_update_status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(google_update_status);
    if (message_arena != submessage_arena) {
      google_update_status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, google_update_status, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.google_update_status_ = google_update_status;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.GoogleUpdate.google_update_status)
}

// optional .metrics.SystemProfileProto.GoogleUpdate.ProductInfo client_status = 5;
inline bool SystemProfileProto_GoogleUpdate::_internal_has_client_status() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.client_status_ != nullptr);
  return value;
}
inline bool SystemProfileProto_GoogleUpdate::has_client_status() const {
  return _internal_has_client_status();
}
inline void SystemProfileProto_GoogleUpdate::clear_client_status() {
  if (_impl_.client_status_ != nullptr) _impl_.client_status_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo& SystemProfileProto_GoogleUpdate::_internal_client_status() const {
  const ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* p = _impl_.client_status_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo&>(
      ::metrics::_SystemProfileProto_GoogleUpdate_ProductInfo_default_instance_);
}
inline const ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo& SystemProfileProto_GoogleUpdate::client_status() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.GoogleUpdate.client_status)
  return _internal_client_status();
}
inline void SystemProfileProto_GoogleUpdate::unsafe_arena_set_allocated_client_status(
    ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* client_status) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_status_);
  }
  _impl_.client_status_ = client_status;
  if (client_status) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.GoogleUpdate.client_status)
}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* SystemProfileProto_GoogleUpdate::release_client_status() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* temp = _impl_.client_status_;
  _impl_.client_status_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* SystemProfileProto_GoogleUpdate::unsafe_arena_release_client_status() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.GoogleUpdate.client_status)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* temp = _impl_.client_status_;
  _impl_.client_status_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* SystemProfileProto_GoogleUpdate::_internal_mutable_client_status() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.client_status_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_GoogleUpdate_ProductInfo>(GetArenaForAllocation());
    _impl_.client_status_ = p;
  }
  return _impl_.client_status_;
}
inline ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* SystemProfileProto_GoogleUpdate::mutable_client_status() {
  ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* _msg = _internal_mutable_client_status();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.GoogleUpdate.client_status)
  return _msg;
}
inline void SystemProfileProto_GoogleUpdate::set_allocated_client_status(::metrics::SystemProfileProto_GoogleUpdate_ProductInfo* client_status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.client_status_;
  }
  if (client_status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(client_status);
    if (message_arena != submessage_arena) {
      client_status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, client_status, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.client_status_ = client_status;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.GoogleUpdate.client_status)
}

// -------------------------------------------------------------------

// SystemProfileProto_Stability

// optional int64 incremental_uptime_sec = 1;
inline bool SystemProfileProto_Stability::_internal_has_incremental_uptime_sec() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_Stability::has_incremental_uptime_sec() const {
  return _internal_has_incremental_uptime_sec();
}
inline void SystemProfileProto_Stability::clear_incremental_uptime_sec() {
  _impl_.incremental_uptime_sec_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int64_t SystemProfileProto_Stability::_internal_incremental_uptime_sec() const {
  return _impl_.incremental_uptime_sec_;
}
inline int64_t SystemProfileProto_Stability::incremental_uptime_sec() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Stability.incremental_uptime_sec)
  return _internal_incremental_uptime_sec();
}
inline void SystemProfileProto_Stability::_internal_set_incremental_uptime_sec(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.incremental_uptime_sec_ = value;
}
inline void SystemProfileProto_Stability::set_incremental_uptime_sec(int64_t value) {
  _internal_set_incremental_uptime_sec(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Stability.incremental_uptime_sec)
}

// optional int64 uptime_sec = 23;
inline bool SystemProfileProto_Stability::_internal_has_uptime_sec() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool SystemProfileProto_Stability::has_uptime_sec() const {
  return _internal_has_uptime_sec();
}
inline void SystemProfileProto_Stability::clear_uptime_sec() {
  _impl_.uptime_sec_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int64_t SystemProfileProto_Stability::_internal_uptime_sec() const {
  return _impl_.uptime_sec_;
}
inline int64_t SystemProfileProto_Stability::uptime_sec() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Stability.uptime_sec)
  return _internal_uptime_sec();
}
inline void SystemProfileProto_Stability::_internal_set_uptime_sec(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.uptime_sec_ = value;
}
inline void SystemProfileProto_Stability::set_uptime_sec(int64_t value) {
  _internal_set_uptime_sec(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Stability.uptime_sec)
}

// optional int32 page_load_count = 2;
inline bool SystemProfileProto_Stability::_internal_has_page_load_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_Stability::has_page_load_count() const {
  return _internal_has_page_load_count();
}
inline void SystemProfileProto_Stability::clear_page_load_count() {
  _impl_.page_load_count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t SystemProfileProto_Stability::_internal_page_load_count() const {
  return _impl_.page_load_count_;
}
inline int32_t SystemProfileProto_Stability::page_load_count() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Stability.page_load_count)
  return _internal_page_load_count();
}
inline void SystemProfileProto_Stability::_internal_set_page_load_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.page_load_count_ = value;
}
inline void SystemProfileProto_Stability::set_page_load_count(int32_t value) {
  _internal_set_page_load_count(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Stability.page_load_count)
}

// optional int32 renderer_launch_count = 26;
inline bool SystemProfileProto_Stability::_internal_has_renderer_launch_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool SystemProfileProto_Stability::has_renderer_launch_count() const {
  return _internal_has_renderer_launch_count();
}
inline void SystemProfileProto_Stability::clear_renderer_launch_count() {
  _impl_.renderer_launch_count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t SystemProfileProto_Stability::_internal_renderer_launch_count() const {
  return _impl_.renderer_launch_count_;
}
inline int32_t SystemProfileProto_Stability::renderer_launch_count() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Stability.renderer_launch_count)
  return _internal_renderer_launch_count();
}
inline void SystemProfileProto_Stability::_internal_set_renderer_launch_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.renderer_launch_count_ = value;
}
inline void SystemProfileProto_Stability::set_renderer_launch_count(int32_t value) {
  _internal_set_renderer_launch_count(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Stability.renderer_launch_count)
}

// optional int32 other_user_crash_count = 7;
inline bool SystemProfileProto_Stability::_internal_has_other_user_crash_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_Stability::has_other_user_crash_count() const {
  return _internal_has_other_user_crash_count();
}
inline void SystemProfileProto_Stability::clear_other_user_crash_count() {
  _impl_.other_user_crash_count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t SystemProfileProto_Stability::_internal_other_user_crash_count() const {
  return _impl_.other_user_crash_count_;
}
inline int32_t SystemProfileProto_Stability::other_user_crash_count() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Stability.other_user_crash_count)
  return _internal_other_user_crash_count();
}
inline void SystemProfileProto_Stability::_internal_set_other_user_crash_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.other_user_crash_count_ = value;
}
inline void SystemProfileProto_Stability::set_other_user_crash_count(int32_t value) {
  _internal_set_other_user_crash_count(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Stability.other_user_crash_count)
}

// optional int32 kernel_crash_count = 8;
inline bool SystemProfileProto_Stability::_internal_has_kernel_crash_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_Stability::has_kernel_crash_count() const {
  return _internal_has_kernel_crash_count();
}
inline void SystemProfileProto_Stability::clear_kernel_crash_count() {
  _impl_.kernel_crash_count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t SystemProfileProto_Stability::_internal_kernel_crash_count() const {
  return _impl_.kernel_crash_count_;
}
inline int32_t SystemProfileProto_Stability::kernel_crash_count() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Stability.kernel_crash_count)
  return _internal_kernel_crash_count();
}
inline void SystemProfileProto_Stability::_internal_set_kernel_crash_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.kernel_crash_count_ = value;
}
inline void SystemProfileProto_Stability::set_kernel_crash_count(int32_t value) {
  _internal_set_kernel_crash_count(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Stability.kernel_crash_count)
}

// optional int32 unclean_system_shutdown_count = 9;
inline bool SystemProfileProto_Stability::_internal_has_unclean_system_shutdown_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SystemProfileProto_Stability::has_unclean_system_shutdown_count() const {
  return _internal_has_unclean_system_shutdown_count();
}
inline void SystemProfileProto_Stability::clear_unclean_system_shutdown_count() {
  _impl_.unclean_system_shutdown_count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t SystemProfileProto_Stability::_internal_unclean_system_shutdown_count() const {
  return _impl_.unclean_system_shutdown_count_;
}
inline int32_t SystemProfileProto_Stability::unclean_system_shutdown_count() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Stability.unclean_system_shutdown_count)
  return _internal_unclean_system_shutdown_count();
}
inline void SystemProfileProto_Stability::_internal_set_unclean_system_shutdown_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.unclean_system_shutdown_count_ = value;
}
inline void SystemProfileProto_Stability::set_unclean_system_shutdown_count(int32_t value) {
  _internal_set_unclean_system_shutdown_count(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Stability.unclean_system_shutdown_count)
}

// optional int32 launch_count = 15;
inline bool SystemProfileProto_Stability::_internal_has_launch_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SystemProfileProto_Stability::has_launch_count() const {
  return _internal_has_launch_count();
}
inline void SystemProfileProto_Stability::clear_launch_count() {
  _impl_.launch_count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t SystemProfileProto_Stability::_internal_launch_count() const {
  return _impl_.launch_count_;
}
inline int32_t SystemProfileProto_Stability::launch_count() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Stability.launch_count)
  return _internal_launch_count();
}
inline void SystemProfileProto_Stability::_internal_set_launch_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.launch_count_ = value;
}
inline void SystemProfileProto_Stability::set_launch_count(int32_t value) {
  _internal_set_launch_count(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Stability.launch_count)
}

// optional int32 crash_count_due_to_gms_core_update = 30;
inline bool SystemProfileProto_Stability::_internal_has_crash_count_due_to_gms_core_update() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool SystemProfileProto_Stability::has_crash_count_due_to_gms_core_update() const {
  return _internal_has_crash_count_due_to_gms_core_update();
}
inline void SystemProfileProto_Stability::clear_crash_count_due_to_gms_core_update() {
  _impl_.crash_count_due_to_gms_core_update_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t SystemProfileProto_Stability::_internal_crash_count_due_to_gms_core_update() const {
  return _impl_.crash_count_due_to_gms_core_update_;
}
inline int32_t SystemProfileProto_Stability::crash_count_due_to_gms_core_update() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Stability.crash_count_due_to_gms_core_update)
  return _internal_crash_count_due_to_gms_core_update();
}
inline void SystemProfileProto_Stability::_internal_set_crash_count_due_to_gms_core_update(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.crash_count_due_to_gms_core_update_ = value;
}
inline void SystemProfileProto_Stability::set_crash_count_due_to_gms_core_update(int32_t value) {
  _internal_set_crash_count_due_to_gms_core_update(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Stability.crash_count_due_to_gms_core_update)
}

// optional bool from_previous_run = 29;
inline bool SystemProfileProto_Stability::_internal_has_from_previous_run() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool SystemProfileProto_Stability::has_from_previous_run() const {
  return _internal_has_from_previous_run();
}
inline void SystemProfileProto_Stability::clear_from_previous_run() {
  _impl_.from_previous_run_ = false;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline bool SystemProfileProto_Stability::_internal_from_previous_run() const {
  return _impl_.from_previous_run_;
}
inline bool SystemProfileProto_Stability::from_previous_run() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.Stability.from_previous_run)
  return _internal_from_previous_run();
}
inline void SystemProfileProto_Stability::_internal_set_from_previous_run(bool value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.from_previous_run_ = value;
}
inline void SystemProfileProto_Stability::set_from_previous_run(bool value) {
  _internal_set_from_previous_run(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.Stability.from_previous_run)
}

// -------------------------------------------------------------------

// SystemProfileProto_FieldTrial

// optional fixed32 name_id = 1;
inline bool SystemProfileProto_FieldTrial::_internal_has_name_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_FieldTrial::has_name_id() const {
  return _internal_has_name_id();
}
inline void SystemProfileProto_FieldTrial::clear_name_id() {
  _impl_.name_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t SystemProfileProto_FieldTrial::_internal_name_id() const {
  return _impl_.name_id_;
}
inline uint32_t SystemProfileProto_FieldTrial::name_id() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.FieldTrial.name_id)
  return _internal_name_id();
}
inline void SystemProfileProto_FieldTrial::_internal_set_name_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_id_ = value;
}
inline void SystemProfileProto_FieldTrial::set_name_id(uint32_t value) {
  _internal_set_name_id(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.FieldTrial.name_id)
}

// optional fixed32 group_id = 2;
inline bool SystemProfileProto_FieldTrial::_internal_has_group_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_FieldTrial::has_group_id() const {
  return _internal_has_group_id();
}
inline void SystemProfileProto_FieldTrial::clear_group_id() {
  _impl_.group_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t SystemProfileProto_FieldTrial::_internal_group_id() const {
  return _impl_.group_id_;
}
inline uint32_t SystemProfileProto_FieldTrial::group_id() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.FieldTrial.group_id)
  return _internal_group_id();
}
inline void SystemProfileProto_FieldTrial::_internal_set_group_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.group_id_ = value;
}
inline void SystemProfileProto_FieldTrial::set_group_id(uint32_t value) {
  _internal_set_group_id(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.FieldTrial.group_id)
}

// -------------------------------------------------------------------

// SystemProfileProto_ExternalAudioVideoDevice_AudioDescription

// optional .metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.AudioFormat audio_format = 1;
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_has_audio_format() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::has_audio_format() const {
  return _internal_has_audio_format();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::clear_audio_format() {
  _impl_.audio_format_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_audio_format() const {
  return static_cast< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat >(_impl_.audio_format_);
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::audio_format() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.audio_format)
  return _internal_audio_format();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_set_audio_format(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat value) {
  assert(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.audio_format_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::set_audio_format(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat value) {
  _internal_set_audio_format(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.audio_format)
}

// optional int32 num_channels = 2;
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_has_num_channels() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::has_num_channels() const {
  return _internal_has_num_channels();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::clear_num_channels() {
  _impl_.num_channels_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_num_channels() const {
  return _impl_.num_channels_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::num_channels() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.num_channels)
  return _internal_num_channels();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_set_num_channels(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.num_channels_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::set_num_channels(int32_t value) {
  _internal_set_num_channels(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.num_channels)
}

// repeated int32 sample_frequency_hz = 3;
inline int SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_sample_frequency_hz_size() const {
  return _impl_.sample_frequency_hz_.size();
}
inline int SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::sample_frequency_hz_size() const {
  return _internal_sample_frequency_hz_size();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::clear_sample_frequency_hz() {
  _impl_.sample_frequency_hz_.Clear();
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_sample_frequency_hz(int index) const {
  return _impl_.sample_frequency_hz_.Get(index);
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::sample_frequency_hz(int index) const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.sample_frequency_hz)
  return _internal_sample_frequency_hz(index);
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::set_sample_frequency_hz(int index, int32_t value) {
  _impl_.sample_frequency_hz_.Set(index, value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.sample_frequency_hz)
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_add_sample_frequency_hz(int32_t value) {
  _impl_.sample_frequency_hz_.Add(value);
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::add_sample_frequency_hz(int32_t value) {
  _internal_add_sample_frequency_hz(value);
  // @@protoc_insertion_point(field_add:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.sample_frequency_hz)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_sample_frequency_hz() const {
  return _impl_.sample_frequency_hz_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::sample_frequency_hz() const {
  // @@protoc_insertion_point(field_list:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.sample_frequency_hz)
  return _internal_sample_frequency_hz();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_mutable_sample_frequency_hz() {
  return &_impl_.sample_frequency_hz_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::mutable_sample_frequency_hz() {
  // @@protoc_insertion_point(field_mutable_list:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.sample_frequency_hz)
  return _internal_mutable_sample_frequency_hz();
}

// optional int32 max_bit_rate_per_second = 4;
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_has_max_bit_rate_per_second() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::has_max_bit_rate_per_second() const {
  return _internal_has_max_bit_rate_per_second();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::clear_max_bit_rate_per_second() {
  _impl_.max_bit_rate_per_second_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_max_bit_rate_per_second() const {
  return _impl_.max_bit_rate_per_second_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::max_bit_rate_per_second() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.max_bit_rate_per_second)
  return _internal_max_bit_rate_per_second();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_set_max_bit_rate_per_second(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.max_bit_rate_per_second_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::set_max_bit_rate_per_second(int32_t value) {
  _internal_set_max_bit_rate_per_second(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.max_bit_rate_per_second)
}

// optional int32 bit_depth = 5;
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_has_bit_depth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::has_bit_depth() const {
  return _internal_has_bit_depth();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::clear_bit_depth() {
  _impl_.bit_depth_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_bit_depth() const {
  return _impl_.bit_depth_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::bit_depth() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.bit_depth)
  return _internal_bit_depth();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_set_bit_depth(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.bit_depth_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::set_bit_depth(int32_t value) {
  _internal_set_bit_depth(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.bit_depth)
}

// optional .metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.OutputMode output_mode = 6;
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_has_output_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::has_output_mode() const {
  return _internal_has_output_mode();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::clear_output_mode() {
  _impl_.output_mode_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_output_mode() const {
  return static_cast< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode >(_impl_.output_mode_);
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::output_mode() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.output_mode)
  return _internal_output_mode();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::_internal_set_output_mode(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode value) {
  assert(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.output_mode_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice_AudioDescription::set_output_mode(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode value) {
  _internal_set_output_mode(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription.output_mode)
}

// -------------------------------------------------------------------

// SystemProfileProto_ExternalAudioVideoDevice_CECCommand

// optional int32 opcode = 1;
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_has_opcode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::has_opcode() const {
  return _internal_has_opcode();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::clear_opcode() {
  _impl_.opcode_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_opcode() const {
  return _impl_.opcode_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::opcode() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand.opcode)
  return _internal_opcode();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_set_opcode(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.opcode_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::set_opcode(int32_t value) {
  _internal_set_opcode(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand.opcode)
}

// optional int32 num_received_direct = 2;
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_has_num_received_direct() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::has_num_received_direct() const {
  return _internal_has_num_received_direct();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::clear_num_received_direct() {
  _impl_.num_received_direct_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_num_received_direct() const {
  return _impl_.num_received_direct_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::num_received_direct() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand.num_received_direct)
  return _internal_num_received_direct();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_set_num_received_direct(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.num_received_direct_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::set_num_received_direct(int32_t value) {
  _internal_set_num_received_direct(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand.num_received_direct)
}

// optional int32 num_received_broadcast = 3;
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_has_num_received_broadcast() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::has_num_received_broadcast() const {
  return _internal_has_num_received_broadcast();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::clear_num_received_broadcast() {
  _impl_.num_received_broadcast_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_num_received_broadcast() const {
  return _impl_.num_received_broadcast_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::num_received_broadcast() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand.num_received_broadcast)
  return _internal_num_received_broadcast();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_set_num_received_broadcast(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.num_received_broadcast_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::set_num_received_broadcast(int32_t value) {
  _internal_set_num_received_broadcast(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand.num_received_broadcast)
}

// optional int32 num_sent_direct = 4;
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_has_num_sent_direct() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::has_num_sent_direct() const {
  return _internal_has_num_sent_direct();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::clear_num_sent_direct() {
  _impl_.num_sent_direct_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_num_sent_direct() const {
  return _impl_.num_sent_direct_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::num_sent_direct() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand.num_sent_direct)
  return _internal_num_sent_direct();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_set_num_sent_direct(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.num_sent_direct_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::set_num_sent_direct(int32_t value) {
  _internal_set_num_sent_direct(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand.num_sent_direct)
}

// optional int32 num_sent_broadcast = 5;
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_has_num_sent_broadcast() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::has_num_sent_broadcast() const {
  return _internal_has_num_sent_broadcast();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::clear_num_sent_broadcast() {
  _impl_.num_sent_broadcast_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_num_sent_broadcast() const {
  return _impl_.num_sent_broadcast_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::num_sent_broadcast() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand.num_sent_broadcast)
  return _internal_num_sent_broadcast();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_set_num_sent_broadcast(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.num_sent_broadcast_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::set_num_sent_broadcast(int32_t value) {
  _internal_set_num_sent_broadcast(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand.num_sent_broadcast)
}

// optional int32 num_aborted_unknown_reason = 6;
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_has_num_aborted_unknown_reason() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::has_num_aborted_unknown_reason() const {
  return _internal_has_num_aborted_unknown_reason();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::clear_num_aborted_unknown_reason() {
  _impl_.num_aborted_unknown_reason_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_num_aborted_unknown_reason() const {
  return _impl_.num_aborted_unknown_reason_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::num_aborted_unknown_reason() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand.num_aborted_unknown_reason)
  return _internal_num_aborted_unknown_reason();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_set_num_aborted_unknown_reason(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.num_aborted_unknown_reason_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::set_num_aborted_unknown_reason(int32_t value) {
  _internal_set_num_aborted_unknown_reason(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand.num_aborted_unknown_reason)
}

// optional int32 num_aborted_unrecognized = 7;
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_has_num_aborted_unrecognized() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice_CECCommand::has_num_aborted_unrecognized() const {
  return _internal_has_num_aborted_unrecognized();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::clear_num_aborted_unrecognized() {
  _impl_.num_aborted_unrecognized_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_num_aborted_unrecognized() const {
  return _impl_.num_aborted_unrecognized_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice_CECCommand::num_aborted_unrecognized() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand.num_aborted_unrecognized)
  return _internal_num_aborted_unrecognized();
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::_internal_set_num_aborted_unrecognized(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.num_aborted_unrecognized_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice_CECCommand::set_num_aborted_unrecognized(int32_t value) {
  _internal_set_num_aborted_unrecognized(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand.num_aborted_unrecognized)
}

// -------------------------------------------------------------------

// SystemProfileProto_ExternalAudioVideoDevice

// optional string manufacturer_name = 1;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_manufacturer_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_manufacturer_name() const {
  return _internal_has_manufacturer_name();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_manufacturer_name() {
  _impl_.manufacturer_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice::manufacturer_name() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.manufacturer_name)
  return _internal_manufacturer_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_ExternalAudioVideoDevice::set_manufacturer_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.manufacturer_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.manufacturer_name)
}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::mutable_manufacturer_name() {
  std::string* _s = _internal_mutable_manufacturer_name();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.ExternalAudioVideoDevice.manufacturer_name)
  return _s;
}
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice::_internal_manufacturer_name() const {
  return _impl_.manufacturer_name_.Get();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_manufacturer_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.manufacturer_name_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::_internal_mutable_manufacturer_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.manufacturer_name_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::release_manufacturer_name() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.ExternalAudioVideoDevice.manufacturer_name)
  if (!_internal_has_manufacturer_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.manufacturer_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.manufacturer_name_.IsDefault()) {
    _impl_.manufacturer_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_allocated_manufacturer_name(std::string* manufacturer_name) {
  if (manufacturer_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.manufacturer_name_.SetAllocated(manufacturer_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.manufacturer_name_.IsDefault()) {
    _impl_.manufacturer_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.ExternalAudioVideoDevice.manufacturer_name)
}

// optional string model_name = 2;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_model_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_model_name() const {
  return _internal_has_model_name();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_model_name() {
  _impl_.model_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice::model_name() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.model_name)
  return _internal_model_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_ExternalAudioVideoDevice::set_model_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.model_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.model_name)
}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::mutable_model_name() {
  std::string* _s = _internal_mutable_model_name();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.ExternalAudioVideoDevice.model_name)
  return _s;
}
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice::_internal_model_name() const {
  return _impl_.model_name_.Get();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_model_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.model_name_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::_internal_mutable_model_name() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.model_name_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::release_model_name() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.ExternalAudioVideoDevice.model_name)
  if (!_internal_has_model_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.model_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.model_name_.IsDefault()) {
    _impl_.model_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_allocated_model_name(std::string* model_name) {
  if (model_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.model_name_.SetAllocated(model_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.model_name_.IsDefault()) {
    _impl_.model_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.ExternalAudioVideoDevice.model_name)
}

// optional string product_code = 3;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_product_code() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_product_code() const {
  return _internal_has_product_code();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_product_code() {
  _impl_.product_code_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice::product_code() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.product_code)
  return _internal_product_code();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_ExternalAudioVideoDevice::set_product_code(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.product_code_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.product_code)
}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::mutable_product_code() {
  std::string* _s = _internal_mutable_product_code();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.ExternalAudioVideoDevice.product_code)
  return _s;
}
inline const std::string& SystemProfileProto_ExternalAudioVideoDevice::_internal_product_code() const {
  return _impl_.product_code_.Get();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_product_code(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.product_code_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::_internal_mutable_product_code() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.product_code_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_ExternalAudioVideoDevice::release_product_code() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.ExternalAudioVideoDevice.product_code)
  if (!_internal_has_product_code()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.product_code_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.product_code_.IsDefault()) {
    _impl_.product_code_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_allocated_product_code(std::string* product_code) {
  if (product_code != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.product_code_.SetAllocated(product_code, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.product_code_.IsDefault()) {
    _impl_.product_code_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.ExternalAudioVideoDevice.product_code)
}

// repeated .metrics.SystemProfileProto.ExternalAudioVideoDevice.AVDeviceType av_device_type = 4;
inline int SystemProfileProto_ExternalAudioVideoDevice::_internal_av_device_type_size() const {
  return _impl_.av_device_type_.size();
}
inline int SystemProfileProto_ExternalAudioVideoDevice::av_device_type_size() const {
  return _internal_av_device_type_size();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_av_device_type() {
  _impl_.av_device_type_.Clear();
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType SystemProfileProto_ExternalAudioVideoDevice::_internal_av_device_type(int index) const {
  return static_cast< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType >(_impl_.av_device_type_.Get(index));
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType SystemProfileProto_ExternalAudioVideoDevice::av_device_type(int index) const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.av_device_type)
  return _internal_av_device_type(index);
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_av_device_type(int index, ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType value) {
  assert(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_IsValid(value));
  _impl_.av_device_type_.Set(index, value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.av_device_type)
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_add_av_device_type(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType value) {
  assert(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType_IsValid(value));
  _impl_.av_device_type_.Add(value);
}
inline void SystemProfileProto_ExternalAudioVideoDevice::add_av_device_type(::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType value) {
  _internal_add_av_device_type(value);
  // @@protoc_insertion_point(field_add:metrics.SystemProfileProto.ExternalAudioVideoDevice.av_device_type)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
SystemProfileProto_ExternalAudioVideoDevice::av_device_type() const {
  // @@protoc_insertion_point(field_list:metrics.SystemProfileProto.ExternalAudioVideoDevice.av_device_type)
  return _impl_.av_device_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
SystemProfileProto_ExternalAudioVideoDevice::_internal_mutable_av_device_type() {
  return &_impl_.av_device_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
SystemProfileProto_ExternalAudioVideoDevice::mutable_av_device_type() {
  // @@protoc_insertion_point(field_mutable_list:metrics.SystemProfileProto.ExternalAudioVideoDevice.av_device_type)
  return _internal_mutable_av_device_type();
}

// optional int32 manufacture_year = 5;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_manufacture_year() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_manufacture_year() const {
  return _internal_has_manufacture_year();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_manufacture_year() {
  _impl_.manufacture_year_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_manufacture_year() const {
  return _impl_.manufacture_year_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::manufacture_year() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.manufacture_year)
  return _internal_manufacture_year();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_manufacture_year(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.manufacture_year_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_manufacture_year(int32_t value) {
  _internal_set_manufacture_year(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.manufacture_year)
}

// optional int32 manufacture_week = 6;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_manufacture_week() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_manufacture_week() const {
  return _internal_has_manufacture_week();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_manufacture_week() {
  _impl_.manufacture_week_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_manufacture_week() const {
  return _impl_.manufacture_week_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::manufacture_week() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.manufacture_week)
  return _internal_manufacture_week();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_manufacture_week(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.manufacture_week_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_manufacture_week(int32_t value) {
  _internal_set_manufacture_week(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.manufacture_week)
}

// optional int32 horizontal_resolution = 7;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_horizontal_resolution() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_horizontal_resolution() const {
  return _internal_has_horizontal_resolution();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_horizontal_resolution() {
  _impl_.horizontal_resolution_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_horizontal_resolution() const {
  return _impl_.horizontal_resolution_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::horizontal_resolution() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.horizontal_resolution)
  return _internal_horizontal_resolution();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_horizontal_resolution(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.horizontal_resolution_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_horizontal_resolution(int32_t value) {
  _internal_set_horizontal_resolution(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.horizontal_resolution)
}

// optional int32 vertical_resolution = 8;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_vertical_resolution() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_vertical_resolution() const {
  return _internal_has_vertical_resolution();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_vertical_resolution() {
  _impl_.vertical_resolution_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_vertical_resolution() const {
  return _impl_.vertical_resolution_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::vertical_resolution() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.vertical_resolution)
  return _internal_vertical_resolution();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_vertical_resolution(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.vertical_resolution_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_vertical_resolution(int32_t value) {
  _internal_set_vertical_resolution(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.vertical_resolution)
}

// repeated .metrics.SystemProfileProto.ExternalAudioVideoDevice.AudioDescription audio_description = 9;
inline int SystemProfileProto_ExternalAudioVideoDevice::_internal_audio_description_size() const {
  return _impl_.audio_description_.size();
}
inline int SystemProfileProto_ExternalAudioVideoDevice::audio_description_size() const {
  return _internal_audio_description_size();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_audio_description() {
  _impl_.audio_description_.Clear();
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* SystemProfileProto_ExternalAudioVideoDevice::mutable_audio_description(int index) {
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.ExternalAudioVideoDevice.audio_description)
  return _impl_.audio_description_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription >*
SystemProfileProto_ExternalAudioVideoDevice::mutable_audio_description() {
  // @@protoc_insertion_point(field_mutable_list:metrics.SystemProfileProto.ExternalAudioVideoDevice.audio_description)
  return &_impl_.audio_description_;
}
inline const ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription& SystemProfileProto_ExternalAudioVideoDevice::_internal_audio_description(int index) const {
  return _impl_.audio_description_.Get(index);
}
inline const ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription& SystemProfileProto_ExternalAudioVideoDevice::audio_description(int index) const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.audio_description)
  return _internal_audio_description(index);
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* SystemProfileProto_ExternalAudioVideoDevice::_internal_add_audio_description() {
  return _impl_.audio_description_.Add();
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* SystemProfileProto_ExternalAudioVideoDevice::add_audio_description() {
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription* _add = _internal_add_audio_description();
  // @@protoc_insertion_point(field_add:metrics.SystemProfileProto.ExternalAudioVideoDevice.audio_description)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription >&
SystemProfileProto_ExternalAudioVideoDevice::audio_description() const {
  // @@protoc_insertion_point(field_list:metrics.SystemProfileProto.ExternalAudioVideoDevice.audio_description)
  return _impl_.audio_description_;
}

// optional int32 position_in_setup = 10;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_position_in_setup() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_position_in_setup() const {
  return _internal_has_position_in_setup();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_position_in_setup() {
  _impl_.position_in_setup_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_position_in_setup() const {
  return _impl_.position_in_setup_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::position_in_setup() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.position_in_setup)
  return _internal_position_in_setup();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_position_in_setup(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.position_in_setup_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_position_in_setup(int32_t value) {
  _internal_set_position_in_setup(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.position_in_setup)
}

// optional bool is_in_path_to_tv = 11;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_is_in_path_to_tv() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_is_in_path_to_tv() const {
  return _internal_has_is_in_path_to_tv();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_is_in_path_to_tv() {
  _impl_.is_in_path_to_tv_ = false;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_is_in_path_to_tv() const {
  return _impl_.is_in_path_to_tv_;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::is_in_path_to_tv() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.is_in_path_to_tv)
  return _internal_is_in_path_to_tv();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_is_in_path_to_tv(bool value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.is_in_path_to_tv_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_is_in_path_to_tv(bool value) {
  _internal_set_is_in_path_to_tv(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.is_in_path_to_tv)
}

// optional int32 cec_version = 12;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_cec_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_cec_version() const {
  return _internal_has_cec_version();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_cec_version() {
  _impl_.cec_version_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_cec_version() const {
  return _impl_.cec_version_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::cec_version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.cec_version)
  return _internal_cec_version();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_cec_version(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.cec_version_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_cec_version(int32_t value) {
  _internal_set_cec_version(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.cec_version)
}

// repeated .metrics.SystemProfileProto.ExternalAudioVideoDevice.CECCommand cec_command = 13;
inline int SystemProfileProto_ExternalAudioVideoDevice::_internal_cec_command_size() const {
  return _impl_.cec_command_.size();
}
inline int SystemProfileProto_ExternalAudioVideoDevice::cec_command_size() const {
  return _internal_cec_command_size();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_cec_command() {
  _impl_.cec_command_.Clear();
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand* SystemProfileProto_ExternalAudioVideoDevice::mutable_cec_command(int index) {
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.ExternalAudioVideoDevice.cec_command)
  return _impl_.cec_command_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand >*
SystemProfileProto_ExternalAudioVideoDevice::mutable_cec_command() {
  // @@protoc_insertion_point(field_mutable_list:metrics.SystemProfileProto.ExternalAudioVideoDevice.cec_command)
  return &_impl_.cec_command_;
}
inline const ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand& SystemProfileProto_ExternalAudioVideoDevice::_internal_cec_command(int index) const {
  return _impl_.cec_command_.Get(index);
}
inline const ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand& SystemProfileProto_ExternalAudioVideoDevice::cec_command(int index) const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.cec_command)
  return _internal_cec_command(index);
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand* SystemProfileProto_ExternalAudioVideoDevice::_internal_add_cec_command() {
  return _impl_.cec_command_.Add();
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand* SystemProfileProto_ExternalAudioVideoDevice::add_cec_command() {
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand* _add = _internal_add_cec_command();
  // @@protoc_insertion_point(field_add:metrics.SystemProfileProto.ExternalAudioVideoDevice.cec_command)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_CECCommand >&
SystemProfileProto_ExternalAudioVideoDevice::cec_command() const {
  // @@protoc_insertion_point(field_list:metrics.SystemProfileProto.ExternalAudioVideoDevice.cec_command)
  return _impl_.cec_command_;
}

// optional int32 frame_rate = 14;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_frame_rate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_frame_rate() const {
  return _internal_has_frame_rate();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_frame_rate() {
  _impl_.frame_rate_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_frame_rate() const {
  return _impl_.frame_rate_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::frame_rate() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.frame_rate)
  return _internal_frame_rate();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_frame_rate(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.frame_rate_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_frame_rate(int32_t value) {
  _internal_set_frame_rate(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.frame_rate)
}

// optional .metrics.SystemProfileProto.ExternalAudioVideoDevice.ColorEncoding color_encoding = 15;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_color_encoding() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_color_encoding() const {
  return _internal_has_color_encoding();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_color_encoding() {
  _impl_.color_encoding_ = 0;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding SystemProfileProto_ExternalAudioVideoDevice::_internal_color_encoding() const {
  return static_cast< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding >(_impl_.color_encoding_);
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding SystemProfileProto_ExternalAudioVideoDevice::color_encoding() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.color_encoding)
  return _internal_color_encoding();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_color_encoding(::metrics::SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding value) {
  assert(::metrics::SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.color_encoding_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_color_encoding(::metrics::SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding value) {
  _internal_set_color_encoding(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.color_encoding)
}

// optional int32 bit_depth = 16;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_bit_depth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_bit_depth() const {
  return _internal_has_bit_depth();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_bit_depth() {
  _impl_.bit_depth_ = 0;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_bit_depth() const {
  return _impl_.bit_depth_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::bit_depth() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.bit_depth)
  return _internal_bit_depth();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_bit_depth(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.bit_depth_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_bit_depth(int32_t value) {
  _internal_set_bit_depth(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.bit_depth)
}

// optional int32 tmds = 17;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_tmds() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_tmds() const {
  return _internal_has_tmds();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_tmds() {
  _impl_.tmds_ = 0;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_tmds() const {
  return _impl_.tmds_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::tmds() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.tmds)
  return _internal_tmds();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_tmds(int32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.tmds_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_tmds(int32_t value) {
  _internal_set_tmds(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.tmds)
}

// optional bool hdr10_support = 18;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_hdr10_support() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_hdr10_support() const {
  return _internal_has_hdr10_support();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_hdr10_support() {
  _impl_.hdr10_support_ = false;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_hdr10_support() const {
  return _impl_.hdr10_support_;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::hdr10_support() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.hdr10_support)
  return _internal_hdr10_support();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_hdr10_support(bool value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.hdr10_support_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_hdr10_support(bool value) {
  _internal_set_hdr10_support(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.hdr10_support)
}

// optional bool dolby_vision_support = 19;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_dolby_vision_support() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_dolby_vision_support() const {
  return _internal_has_dolby_vision_support();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_dolby_vision_support() {
  _impl_.dolby_vision_support_ = false;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_dolby_vision_support() const {
  return _impl_.dolby_vision_support_;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::dolby_vision_support() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.dolby_vision_support)
  return _internal_dolby_vision_support();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_dolby_vision_support(bool value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.dolby_vision_support_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_dolby_vision_support(bool value) {
  _internal_set_dolby_vision_support(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.dolby_vision_support)
}

// optional int32 eotf_support = 20;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_eotf_support() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_eotf_support() const {
  return _internal_has_eotf_support();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_eotf_support() {
  _impl_.eotf_support_ = 0;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_eotf_support() const {
  return _impl_.eotf_support_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::eotf_support() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.eotf_support)
  return _internal_eotf_support();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_eotf_support(int32_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.eotf_support_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_eotf_support(int32_t value) {
  _internal_set_eotf_support(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.eotf_support)
}

// optional bool yuv_support = 21;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_yuv_support() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_yuv_support() const {
  return _internal_has_yuv_support();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_yuv_support() {
  _impl_.yuv_support_ = false;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_yuv_support() const {
  return _impl_.yuv_support_;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::yuv_support() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.yuv_support)
  return _internal_yuv_support();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_yuv_support(bool value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.yuv_support_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_yuv_support(bool value) {
  _internal_set_yuv_support(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.yuv_support)
}

// optional bool yuv_420_support = 22;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_yuv_420_support() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_yuv_420_support() const {
  return _internal_has_yuv_420_support();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_yuv_420_support() {
  _impl_.yuv_420_support_ = false;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_yuv_420_support() const {
  return _impl_.yuv_420_support_;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::yuv_420_support() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.yuv_420_support)
  return _internal_yuv_420_support();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_yuv_420_support(bool value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.yuv_420_support_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_yuv_420_support(bool value) {
  _internal_set_yuv_420_support(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.yuv_420_support)
}

// optional int32 maximum_supported_hdcp_version = 23;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_maximum_supported_hdcp_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_maximum_supported_hdcp_version() const {
  return _internal_has_maximum_supported_hdcp_version();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_maximum_supported_hdcp_version() {
  _impl_.maximum_supported_hdcp_version_ = 0;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_maximum_supported_hdcp_version() const {
  return _impl_.maximum_supported_hdcp_version_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::maximum_supported_hdcp_version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.maximum_supported_hdcp_version)
  return _internal_maximum_supported_hdcp_version();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_maximum_supported_hdcp_version(int32_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.maximum_supported_hdcp_version_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_maximum_supported_hdcp_version(int32_t value) {
  _internal_set_maximum_supported_hdcp_version(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.maximum_supported_hdcp_version)
}

// optional int32 current_hdcp_version = 24;
inline bool SystemProfileProto_ExternalAudioVideoDevice::_internal_has_current_hdcp_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAudioVideoDevice::has_current_hdcp_version() const {
  return _internal_has_current_hdcp_version();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::clear_current_hdcp_version() {
  _impl_.current_hdcp_version_ = 0;
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::_internal_current_hdcp_version() const {
  return _impl_.current_hdcp_version_;
}
inline int32_t SystemProfileProto_ExternalAudioVideoDevice::current_hdcp_version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAudioVideoDevice.current_hdcp_version)
  return _internal_current_hdcp_version();
}
inline void SystemProfileProto_ExternalAudioVideoDevice::_internal_set_current_hdcp_version(int32_t value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.current_hdcp_version_ = value;
}
inline void SystemProfileProto_ExternalAudioVideoDevice::set_current_hdcp_version(int32_t value) {
  _internal_set_current_hdcp_version(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAudioVideoDevice.current_hdcp_version)
}

// -------------------------------------------------------------------

// SystemProfileProto_ExternalAccessPoint

// optional string manufacturer = 1;
inline bool SystemProfileProto_ExternalAccessPoint::_internal_has_manufacturer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAccessPoint::has_manufacturer() const {
  return _internal_has_manufacturer();
}
inline void SystemProfileProto_ExternalAccessPoint::clear_manufacturer() {
  _impl_.manufacturer_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SystemProfileProto_ExternalAccessPoint::manufacturer() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAccessPoint.manufacturer)
  return _internal_manufacturer();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_ExternalAccessPoint::set_manufacturer(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.manufacturer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAccessPoint.manufacturer)
}
inline std::string* SystemProfileProto_ExternalAccessPoint::mutable_manufacturer() {
  std::string* _s = _internal_mutable_manufacturer();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.ExternalAccessPoint.manufacturer)
  return _s;
}
inline const std::string& SystemProfileProto_ExternalAccessPoint::_internal_manufacturer() const {
  return _impl_.manufacturer_.Get();
}
inline void SystemProfileProto_ExternalAccessPoint::_internal_set_manufacturer(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.manufacturer_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_ExternalAccessPoint::_internal_mutable_manufacturer() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.manufacturer_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_ExternalAccessPoint::release_manufacturer() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.ExternalAccessPoint.manufacturer)
  if (!_internal_has_manufacturer()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.manufacturer_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.manufacturer_.IsDefault()) {
    _impl_.manufacturer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_ExternalAccessPoint::set_allocated_manufacturer(std::string* manufacturer) {
  if (manufacturer != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.manufacturer_.SetAllocated(manufacturer, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.manufacturer_.IsDefault()) {
    _impl_.manufacturer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.ExternalAccessPoint.manufacturer)
}

// optional string model_name = 2;
inline bool SystemProfileProto_ExternalAccessPoint::_internal_has_model_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAccessPoint::has_model_name() const {
  return _internal_has_model_name();
}
inline void SystemProfileProto_ExternalAccessPoint::clear_model_name() {
  _impl_.model_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SystemProfileProto_ExternalAccessPoint::model_name() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAccessPoint.model_name)
  return _internal_model_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_ExternalAccessPoint::set_model_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.model_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAccessPoint.model_name)
}
inline std::string* SystemProfileProto_ExternalAccessPoint::mutable_model_name() {
  std::string* _s = _internal_mutable_model_name();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.ExternalAccessPoint.model_name)
  return _s;
}
inline const std::string& SystemProfileProto_ExternalAccessPoint::_internal_model_name() const {
  return _impl_.model_name_.Get();
}
inline void SystemProfileProto_ExternalAccessPoint::_internal_set_model_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.model_name_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_ExternalAccessPoint::_internal_mutable_model_name() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.model_name_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_ExternalAccessPoint::release_model_name() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.ExternalAccessPoint.model_name)
  if (!_internal_has_model_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.model_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.model_name_.IsDefault()) {
    _impl_.model_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_ExternalAccessPoint::set_allocated_model_name(std::string* model_name) {
  if (model_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.model_name_.SetAllocated(model_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.model_name_.IsDefault()) {
    _impl_.model_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.ExternalAccessPoint.model_name)
}

// optional string model_number = 3;
inline bool SystemProfileProto_ExternalAccessPoint::_internal_has_model_number() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAccessPoint::has_model_number() const {
  return _internal_has_model_number();
}
inline void SystemProfileProto_ExternalAccessPoint::clear_model_number() {
  _impl_.model_number_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SystemProfileProto_ExternalAccessPoint::model_number() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAccessPoint.model_number)
  return _internal_model_number();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_ExternalAccessPoint::set_model_number(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.model_number_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAccessPoint.model_number)
}
inline std::string* SystemProfileProto_ExternalAccessPoint::mutable_model_number() {
  std::string* _s = _internal_mutable_model_number();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.ExternalAccessPoint.model_number)
  return _s;
}
inline const std::string& SystemProfileProto_ExternalAccessPoint::_internal_model_number() const {
  return _impl_.model_number_.Get();
}
inline void SystemProfileProto_ExternalAccessPoint::_internal_set_model_number(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.model_number_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_ExternalAccessPoint::_internal_mutable_model_number() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.model_number_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_ExternalAccessPoint::release_model_number() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.ExternalAccessPoint.model_number)
  if (!_internal_has_model_number()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.model_number_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.model_number_.IsDefault()) {
    _impl_.model_number_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_ExternalAccessPoint::set_allocated_model_number(std::string* model_number) {
  if (model_number != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.model_number_.SetAllocated(model_number, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.model_number_.IsDefault()) {
    _impl_.model_number_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.ExternalAccessPoint.model_number)
}

// optional string device_name = 4;
inline bool SystemProfileProto_ExternalAccessPoint::_internal_has_device_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_ExternalAccessPoint::has_device_name() const {
  return _internal_has_device_name();
}
inline void SystemProfileProto_ExternalAccessPoint::clear_device_name() {
  _impl_.device_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& SystemProfileProto_ExternalAccessPoint::device_name() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ExternalAccessPoint.device_name)
  return _internal_device_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_ExternalAccessPoint::set_device_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.device_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ExternalAccessPoint.device_name)
}
inline std::string* SystemProfileProto_ExternalAccessPoint::mutable_device_name() {
  std::string* _s = _internal_mutable_device_name();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.ExternalAccessPoint.device_name)
  return _s;
}
inline const std::string& SystemProfileProto_ExternalAccessPoint::_internal_device_name() const {
  return _impl_.device_name_.Get();
}
inline void SystemProfileProto_ExternalAccessPoint::_internal_set_device_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.device_name_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_ExternalAccessPoint::_internal_mutable_device_name() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.device_name_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_ExternalAccessPoint::release_device_name() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.ExternalAccessPoint.device_name)
  if (!_internal_has_device_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.device_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.device_name_.IsDefault()) {
    _impl_.device_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_ExternalAccessPoint::set_allocated_device_name(std::string* device_name) {
  if (device_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.device_name_.SetAllocated(device_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.device_name_.IsDefault()) {
    _impl_.device_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.ExternalAccessPoint.device_name)
}

// -------------------------------------------------------------------

// SystemProfileProto_AntiVirusProduct

// optional string product_name = 1;
inline bool SystemProfileProto_AntiVirusProduct::_internal_has_product_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_AntiVirusProduct::has_product_name() const {
  return _internal_has_product_name();
}
inline void SystemProfileProto_AntiVirusProduct::clear_product_name() {
  _impl_.product_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SystemProfileProto_AntiVirusProduct::product_name() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.AntiVirusProduct.product_name)
  return _internal_product_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_AntiVirusProduct::set_product_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.product_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.AntiVirusProduct.product_name)
}
inline std::string* SystemProfileProto_AntiVirusProduct::mutable_product_name() {
  std::string* _s = _internal_mutable_product_name();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.AntiVirusProduct.product_name)
  return _s;
}
inline const std::string& SystemProfileProto_AntiVirusProduct::_internal_product_name() const {
  return _impl_.product_name_.Get();
}
inline void SystemProfileProto_AntiVirusProduct::_internal_set_product_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.product_name_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_AntiVirusProduct::_internal_mutable_product_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.product_name_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_AntiVirusProduct::release_product_name() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.AntiVirusProduct.product_name)
  if (!_internal_has_product_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.product_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.product_name_.IsDefault()) {
    _impl_.product_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_AntiVirusProduct::set_allocated_product_name(std::string* product_name) {
  if (product_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.product_name_.SetAllocated(product_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.product_name_.IsDefault()) {
    _impl_.product_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.AntiVirusProduct.product_name)
}

// optional fixed32 product_name_hash = 2;
inline bool SystemProfileProto_AntiVirusProduct::_internal_has_product_name_hash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_AntiVirusProduct::has_product_name_hash() const {
  return _internal_has_product_name_hash();
}
inline void SystemProfileProto_AntiVirusProduct::clear_product_name_hash() {
  _impl_.product_name_hash_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t SystemProfileProto_AntiVirusProduct::_internal_product_name_hash() const {
  return _impl_.product_name_hash_;
}
inline uint32_t SystemProfileProto_AntiVirusProduct::product_name_hash() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.AntiVirusProduct.product_name_hash)
  return _internal_product_name_hash();
}
inline void SystemProfileProto_AntiVirusProduct::_internal_set_product_name_hash(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.product_name_hash_ = value;
}
inline void SystemProfileProto_AntiVirusProduct::set_product_name_hash(uint32_t value) {
  _internal_set_product_name_hash(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.AntiVirusProduct.product_name_hash)
}

// optional string product_version = 3;
inline bool SystemProfileProto_AntiVirusProduct::_internal_has_product_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_AntiVirusProduct::has_product_version() const {
  return _internal_has_product_version();
}
inline void SystemProfileProto_AntiVirusProduct::clear_product_version() {
  _impl_.product_version_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SystemProfileProto_AntiVirusProduct::product_version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.AntiVirusProduct.product_version)
  return _internal_product_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_AntiVirusProduct::set_product_version(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.product_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.AntiVirusProduct.product_version)
}
inline std::string* SystemProfileProto_AntiVirusProduct::mutable_product_version() {
  std::string* _s = _internal_mutable_product_version();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.AntiVirusProduct.product_version)
  return _s;
}
inline const std::string& SystemProfileProto_AntiVirusProduct::_internal_product_version() const {
  return _impl_.product_version_.Get();
}
inline void SystemProfileProto_AntiVirusProduct::_internal_set_product_version(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.product_version_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_AntiVirusProduct::_internal_mutable_product_version() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.product_version_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_AntiVirusProduct::release_product_version() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.AntiVirusProduct.product_version)
  if (!_internal_has_product_version()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.product_version_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.product_version_.IsDefault()) {
    _impl_.product_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_AntiVirusProduct::set_allocated_product_version(std::string* product_version) {
  if (product_version != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.product_version_.SetAllocated(product_version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.product_version_.IsDefault()) {
    _impl_.product_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.AntiVirusProduct.product_version)
}

// optional fixed32 product_version_hash = 4;
inline bool SystemProfileProto_AntiVirusProduct::_internal_has_product_version_hash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_AntiVirusProduct::has_product_version_hash() const {
  return _internal_has_product_version_hash();
}
inline void SystemProfileProto_AntiVirusProduct::clear_product_version_hash() {
  _impl_.product_version_hash_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t SystemProfileProto_AntiVirusProduct::_internal_product_version_hash() const {
  return _impl_.product_version_hash_;
}
inline uint32_t SystemProfileProto_AntiVirusProduct::product_version_hash() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.AntiVirusProduct.product_version_hash)
  return _internal_product_version_hash();
}
inline void SystemProfileProto_AntiVirusProduct::_internal_set_product_version_hash(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.product_version_hash_ = value;
}
inline void SystemProfileProto_AntiVirusProduct::set_product_version_hash(uint32_t value) {
  _internal_set_product_version_hash(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.AntiVirusProduct.product_version_hash)
}

// optional .metrics.SystemProfileProto.AntiVirusState product_state = 5;
inline bool SystemProfileProto_AntiVirusProduct::_internal_has_product_state() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SystemProfileProto_AntiVirusProduct::has_product_state() const {
  return _internal_has_product_state();
}
inline void SystemProfileProto_AntiVirusProduct::clear_product_state() {
  _impl_.product_state_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline ::metrics::SystemProfileProto_AntiVirusState SystemProfileProto_AntiVirusProduct::_internal_product_state() const {
  return static_cast< ::metrics::SystemProfileProto_AntiVirusState >(_impl_.product_state_);
}
inline ::metrics::SystemProfileProto_AntiVirusState SystemProfileProto_AntiVirusProduct::product_state() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.AntiVirusProduct.product_state)
  return _internal_product_state();
}
inline void SystemProfileProto_AntiVirusProduct::_internal_set_product_state(::metrics::SystemProfileProto_AntiVirusState value) {
  assert(::metrics::SystemProfileProto_AntiVirusState_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.product_state_ = value;
}
inline void SystemProfileProto_AntiVirusProduct::set_product_state(::metrics::SystemProfileProto_AntiVirusState value) {
  _internal_set_product_state(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.AntiVirusProduct.product_state)
}

// -------------------------------------------------------------------

// SystemProfileProto_ChromeComponent

// optional .metrics.SystemProfileProto.ComponentId component_id = 1 [default = UNKNOWN];
inline bool SystemProfileProto_ChromeComponent::_internal_has_component_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_ChromeComponent::has_component_id() const {
  return _internal_has_component_id();
}
inline void SystemProfileProto_ChromeComponent::clear_component_id() {
  _impl_.component_id_ = 1;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::metrics::SystemProfileProto_ComponentId SystemProfileProto_ChromeComponent::_internal_component_id() const {
  return static_cast< ::metrics::SystemProfileProto_ComponentId >(_impl_.component_id_);
}
inline ::metrics::SystemProfileProto_ComponentId SystemProfileProto_ChromeComponent::component_id() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ChromeComponent.component_id)
  return _internal_component_id();
}
inline void SystemProfileProto_ChromeComponent::_internal_set_component_id(::metrics::SystemProfileProto_ComponentId value) {
  assert(::metrics::SystemProfileProto_ComponentId_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.component_id_ = value;
}
inline void SystemProfileProto_ChromeComponent::set_component_id(::metrics::SystemProfileProto_ComponentId value) {
  _internal_set_component_id(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ChromeComponent.component_id)
}

// optional string version = 2;
inline bool SystemProfileProto_ChromeComponent::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_ChromeComponent::has_version() const {
  return _internal_has_version();
}
inline void SystemProfileProto_ChromeComponent::clear_version() {
  _impl_.version_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SystemProfileProto_ChromeComponent::version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ChromeComponent.version)
  return _internal_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_ChromeComponent::set_version(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ChromeComponent.version)
}
inline std::string* SystemProfileProto_ChromeComponent::mutable_version() {
  std::string* _s = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.ChromeComponent.version)
  return _s;
}
inline const std::string& SystemProfileProto_ChromeComponent::_internal_version() const {
  return _impl_.version_.Get();
}
inline void SystemProfileProto_ChromeComponent::_internal_set_version(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.version_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_ChromeComponent::_internal_mutable_version() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.version_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_ChromeComponent::release_version() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.ChromeComponent.version)
  if (!_internal_has_version()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.version_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.version_.IsDefault()) {
    _impl_.version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_ChromeComponent::set_allocated_version(std::string* version) {
  if (version != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.version_.IsDefault()) {
    _impl_.version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.ChromeComponent.version)
}

// optional fixed32 omaha_fingerprint = 3;
inline bool SystemProfileProto_ChromeComponent::_internal_has_omaha_fingerprint() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_ChromeComponent::has_omaha_fingerprint() const {
  return _internal_has_omaha_fingerprint();
}
inline void SystemProfileProto_ChromeComponent::clear_omaha_fingerprint() {
  _impl_.omaha_fingerprint_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t SystemProfileProto_ChromeComponent::_internal_omaha_fingerprint() const {
  return _impl_.omaha_fingerprint_;
}
inline uint32_t SystemProfileProto_ChromeComponent::omaha_fingerprint() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ChromeComponent.omaha_fingerprint)
  return _internal_omaha_fingerprint();
}
inline void SystemProfileProto_ChromeComponent::_internal_set_omaha_fingerprint(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.omaha_fingerprint_ = value;
}
inline void SystemProfileProto_ChromeComponent::set_omaha_fingerprint(uint32_t value) {
  _internal_set_omaha_fingerprint(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ChromeComponent.omaha_fingerprint)
}

// optional fixed32 cohort_hash = 4;
inline bool SystemProfileProto_ChromeComponent::_internal_has_cohort_hash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_ChromeComponent::has_cohort_hash() const {
  return _internal_has_cohort_hash();
}
inline void SystemProfileProto_ChromeComponent::clear_cohort_hash() {
  _impl_.cohort_hash_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t SystemProfileProto_ChromeComponent::_internal_cohort_hash() const {
  return _impl_.cohort_hash_;
}
inline uint32_t SystemProfileProto_ChromeComponent::cohort_hash() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.ChromeComponent.cohort_hash)
  return _internal_cohort_hash();
}
inline void SystemProfileProto_ChromeComponent::_internal_set_cohort_hash(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.cohort_hash_ = value;
}
inline void SystemProfileProto_ChromeComponent::set_cohort_hash(uint32_t value) {
  _internal_set_cohort_hash(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.ChromeComponent.cohort_hash)
}

// -------------------------------------------------------------------

// SystemProfileProto_LinkedAndroidPhoneData

// optional fixed32 phone_model_name_hash = 1;
inline bool SystemProfileProto_LinkedAndroidPhoneData::_internal_has_phone_model_name_hash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_LinkedAndroidPhoneData::has_phone_model_name_hash() const {
  return _internal_has_phone_model_name_hash();
}
inline void SystemProfileProto_LinkedAndroidPhoneData::clear_phone_model_name_hash() {
  _impl_.phone_model_name_hash_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t SystemProfileProto_LinkedAndroidPhoneData::_internal_phone_model_name_hash() const {
  return _impl_.phone_model_name_hash_;
}
inline uint32_t SystemProfileProto_LinkedAndroidPhoneData::phone_model_name_hash() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.LinkedAndroidPhoneData.phone_model_name_hash)
  return _internal_phone_model_name_hash();
}
inline void SystemProfileProto_LinkedAndroidPhoneData::_internal_set_phone_model_name_hash(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.phone_model_name_hash_ = value;
}
inline void SystemProfileProto_LinkedAndroidPhoneData::set_phone_model_name_hash(uint32_t value) {
  _internal_set_phone_model_name_hash(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.LinkedAndroidPhoneData.phone_model_name_hash)
}

// optional bool is_smartlock_enabled = 2;
inline bool SystemProfileProto_LinkedAndroidPhoneData::_internal_has_is_smartlock_enabled() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_LinkedAndroidPhoneData::has_is_smartlock_enabled() const {
  return _internal_has_is_smartlock_enabled();
}
inline void SystemProfileProto_LinkedAndroidPhoneData::clear_is_smartlock_enabled() {
  _impl_.is_smartlock_enabled_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool SystemProfileProto_LinkedAndroidPhoneData::_internal_is_smartlock_enabled() const {
  return _impl_.is_smartlock_enabled_;
}
inline bool SystemProfileProto_LinkedAndroidPhoneData::is_smartlock_enabled() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.LinkedAndroidPhoneData.is_smartlock_enabled)
  return _internal_is_smartlock_enabled();
}
inline void SystemProfileProto_LinkedAndroidPhoneData::_internal_set_is_smartlock_enabled(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.is_smartlock_enabled_ = value;
}
inline void SystemProfileProto_LinkedAndroidPhoneData::set_is_smartlock_enabled(bool value) {
  _internal_set_is_smartlock_enabled(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.LinkedAndroidPhoneData.is_smartlock_enabled)
}

// optional bool is_instant_tethering_enabled = 3;
inline bool SystemProfileProto_LinkedAndroidPhoneData::_internal_has_is_instant_tethering_enabled() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_LinkedAndroidPhoneData::has_is_instant_tethering_enabled() const {
  return _internal_has_is_instant_tethering_enabled();
}
inline void SystemProfileProto_LinkedAndroidPhoneData::clear_is_instant_tethering_enabled() {
  _impl_.is_instant_tethering_enabled_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool SystemProfileProto_LinkedAndroidPhoneData::_internal_is_instant_tethering_enabled() const {
  return _impl_.is_instant_tethering_enabled_;
}
inline bool SystemProfileProto_LinkedAndroidPhoneData::is_instant_tethering_enabled() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.LinkedAndroidPhoneData.is_instant_tethering_enabled)
  return _internal_is_instant_tethering_enabled();
}
inline void SystemProfileProto_LinkedAndroidPhoneData::_internal_set_is_instant_tethering_enabled(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.is_instant_tethering_enabled_ = value;
}
inline void SystemProfileProto_LinkedAndroidPhoneData::set_is_instant_tethering_enabled(bool value) {
  _internal_set_is_instant_tethering_enabled(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.LinkedAndroidPhoneData.is_instant_tethering_enabled)
}

// optional bool is_messages_enabled = 4 [deprecated = true];
inline bool SystemProfileProto_LinkedAndroidPhoneData::_internal_has_is_messages_enabled() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto_LinkedAndroidPhoneData::has_is_messages_enabled() const {
  return _internal_has_is_messages_enabled();
}
inline void SystemProfileProto_LinkedAndroidPhoneData::clear_is_messages_enabled() {
  _impl_.is_messages_enabled_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool SystemProfileProto_LinkedAndroidPhoneData::_internal_is_messages_enabled() const {
  return _impl_.is_messages_enabled_;
}
inline bool SystemProfileProto_LinkedAndroidPhoneData::is_messages_enabled() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.LinkedAndroidPhoneData.is_messages_enabled)
  return _internal_is_messages_enabled();
}
inline void SystemProfileProto_LinkedAndroidPhoneData::_internal_set_is_messages_enabled(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.is_messages_enabled_ = value;
}
inline void SystemProfileProto_LinkedAndroidPhoneData::set_is_messages_enabled(bool value) {
  _internal_set_is_messages_enabled(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.LinkedAndroidPhoneData.is_messages_enabled)
}

// -------------------------------------------------------------------

// SystemProfileProto_DemoModeDimensions_Retailer

// optional string retailer_id = 1;
inline bool SystemProfileProto_DemoModeDimensions_Retailer::_internal_has_retailer_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_DemoModeDimensions_Retailer::has_retailer_id() const {
  return _internal_has_retailer_id();
}
inline void SystemProfileProto_DemoModeDimensions_Retailer::clear_retailer_id() {
  _impl_.retailer_id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SystemProfileProto_DemoModeDimensions_Retailer::retailer_id() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.DemoModeDimensions.Retailer.retailer_id)
  return _internal_retailer_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_DemoModeDimensions_Retailer::set_retailer_id(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.retailer_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.DemoModeDimensions.Retailer.retailer_id)
}
inline std::string* SystemProfileProto_DemoModeDimensions_Retailer::mutable_retailer_id() {
  std::string* _s = _internal_mutable_retailer_id();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.DemoModeDimensions.Retailer.retailer_id)
  return _s;
}
inline const std::string& SystemProfileProto_DemoModeDimensions_Retailer::_internal_retailer_id() const {
  return _impl_.retailer_id_.Get();
}
inline void SystemProfileProto_DemoModeDimensions_Retailer::_internal_set_retailer_id(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.retailer_id_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_DemoModeDimensions_Retailer::_internal_mutable_retailer_id() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.retailer_id_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_DemoModeDimensions_Retailer::release_retailer_id() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.DemoModeDimensions.Retailer.retailer_id)
  if (!_internal_has_retailer_id()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.retailer_id_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.retailer_id_.IsDefault()) {
    _impl_.retailer_id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_DemoModeDimensions_Retailer::set_allocated_retailer_id(std::string* retailer_id) {
  if (retailer_id != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.retailer_id_.SetAllocated(retailer_id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.retailer_id_.IsDefault()) {
    _impl_.retailer_id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.DemoModeDimensions.Retailer.retailer_id)
}

// optional string store_id = 2;
inline bool SystemProfileProto_DemoModeDimensions_Retailer::_internal_has_store_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_DemoModeDimensions_Retailer::has_store_id() const {
  return _internal_has_store_id();
}
inline void SystemProfileProto_DemoModeDimensions_Retailer::clear_store_id() {
  _impl_.store_id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SystemProfileProto_DemoModeDimensions_Retailer::store_id() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.DemoModeDimensions.Retailer.store_id)
  return _internal_store_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_DemoModeDimensions_Retailer::set_store_id(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.store_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.DemoModeDimensions.Retailer.store_id)
}
inline std::string* SystemProfileProto_DemoModeDimensions_Retailer::mutable_store_id() {
  std::string* _s = _internal_mutable_store_id();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.DemoModeDimensions.Retailer.store_id)
  return _s;
}
inline const std::string& SystemProfileProto_DemoModeDimensions_Retailer::_internal_store_id() const {
  return _impl_.store_id_.Get();
}
inline void SystemProfileProto_DemoModeDimensions_Retailer::_internal_set_store_id(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.store_id_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_DemoModeDimensions_Retailer::_internal_mutable_store_id() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.store_id_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_DemoModeDimensions_Retailer::release_store_id() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.DemoModeDimensions.Retailer.store_id)
  if (!_internal_has_store_id()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.store_id_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.store_id_.IsDefault()) {
    _impl_.store_id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_DemoModeDimensions_Retailer::set_allocated_store_id(std::string* store_id) {
  if (store_id != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.store_id_.SetAllocated(store_id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.store_id_.IsDefault()) {
    _impl_.store_id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.DemoModeDimensions.Retailer.store_id)
}

// -------------------------------------------------------------------

// SystemProfileProto_DemoModeDimensions

// optional string country = 1;
inline bool SystemProfileProto_DemoModeDimensions::_internal_has_country() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto_DemoModeDimensions::has_country() const {
  return _internal_has_country();
}
inline void SystemProfileProto_DemoModeDimensions::clear_country() {
  _impl_.country_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SystemProfileProto_DemoModeDimensions::country() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.DemoModeDimensions.country)
  return _internal_country();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_DemoModeDimensions::set_country(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.country_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.DemoModeDimensions.country)
}
inline std::string* SystemProfileProto_DemoModeDimensions::mutable_country() {
  std::string* _s = _internal_mutable_country();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.DemoModeDimensions.country)
  return _s;
}
inline const std::string& SystemProfileProto_DemoModeDimensions::_internal_country() const {
  return _impl_.country_.Get();
}
inline void SystemProfileProto_DemoModeDimensions::_internal_set_country(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.country_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_DemoModeDimensions::_internal_mutable_country() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.country_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_DemoModeDimensions::release_country() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.DemoModeDimensions.country)
  if (!_internal_has_country()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.country_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.country_.IsDefault()) {
    _impl_.country_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_DemoModeDimensions::set_allocated_country(std::string* country) {
  if (country != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.country_.SetAllocated(country, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.country_.IsDefault()) {
    _impl_.country_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.DemoModeDimensions.country)
}

// optional .metrics.SystemProfileProto.DemoModeDimensions.Retailer retailer = 2;
inline bool SystemProfileProto_DemoModeDimensions::_internal_has_retailer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.retailer_ != nullptr);
  return value;
}
inline bool SystemProfileProto_DemoModeDimensions::has_retailer() const {
  return _internal_has_retailer();
}
inline void SystemProfileProto_DemoModeDimensions::clear_retailer() {
  if (_impl_.retailer_ != nullptr) _impl_.retailer_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::metrics::SystemProfileProto_DemoModeDimensions_Retailer& SystemProfileProto_DemoModeDimensions::_internal_retailer() const {
  const ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* p = _impl_.retailer_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_DemoModeDimensions_Retailer&>(
      ::metrics::_SystemProfileProto_DemoModeDimensions_Retailer_default_instance_);
}
inline const ::metrics::SystemProfileProto_DemoModeDimensions_Retailer& SystemProfileProto_DemoModeDimensions::retailer() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.DemoModeDimensions.retailer)
  return _internal_retailer();
}
inline void SystemProfileProto_DemoModeDimensions::unsafe_arena_set_allocated_retailer(
    ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* retailer) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.retailer_);
  }
  _impl_.retailer_ = retailer;
  if (retailer) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.DemoModeDimensions.retailer)
}
inline ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* SystemProfileProto_DemoModeDimensions::release_retailer() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* temp = _impl_.retailer_;
  _impl_.retailer_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* SystemProfileProto_DemoModeDimensions::unsafe_arena_release_retailer() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.DemoModeDimensions.retailer)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* temp = _impl_.retailer_;
  _impl_.retailer_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* SystemProfileProto_DemoModeDimensions::_internal_mutable_retailer() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.retailer_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_DemoModeDimensions_Retailer>(GetArenaForAllocation());
    _impl_.retailer_ = p;
  }
  return _impl_.retailer_;
}
inline ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* SystemProfileProto_DemoModeDimensions::mutable_retailer() {
  ::metrics::SystemProfileProto_DemoModeDimensions_Retailer* _msg = _internal_mutable_retailer();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.DemoModeDimensions.retailer)
  return _msg;
}
inline void SystemProfileProto_DemoModeDimensions::set_allocated_retailer(::metrics::SystemProfileProto_DemoModeDimensions_Retailer* retailer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.retailer_;
  }
  if (retailer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(retailer);
    if (message_arena != submessage_arena) {
      retailer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, retailer, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.retailer_ = retailer;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.DemoModeDimensions.retailer)
}

// repeated .metrics.SystemProfileProto.DemoModeDimensions.CustomizationFacet customization_facet = 3 [packed = true];
inline int SystemProfileProto_DemoModeDimensions::_internal_customization_facet_size() const {
  return _impl_.customization_facet_.size();
}
inline int SystemProfileProto_DemoModeDimensions::customization_facet_size() const {
  return _internal_customization_facet_size();
}
inline void SystemProfileProto_DemoModeDimensions::clear_customization_facet() {
  _impl_.customization_facet_.Clear();
}
inline ::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet SystemProfileProto_DemoModeDimensions::_internal_customization_facet(int index) const {
  return static_cast< ::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet >(_impl_.customization_facet_.Get(index));
}
inline ::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet SystemProfileProto_DemoModeDimensions::customization_facet(int index) const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.DemoModeDimensions.customization_facet)
  return _internal_customization_facet(index);
}
inline void SystemProfileProto_DemoModeDimensions::set_customization_facet(int index, ::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet value) {
  assert(::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet_IsValid(value));
  _impl_.customization_facet_.Set(index, value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.DemoModeDimensions.customization_facet)
}
inline void SystemProfileProto_DemoModeDimensions::_internal_add_customization_facet(::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet value) {
  assert(::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet_IsValid(value));
  _impl_.customization_facet_.Add(value);
}
inline void SystemProfileProto_DemoModeDimensions::add_customization_facet(::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet value) {
  _internal_add_customization_facet(value);
  // @@protoc_insertion_point(field_add:metrics.SystemProfileProto.DemoModeDimensions.customization_facet)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
SystemProfileProto_DemoModeDimensions::customization_facet() const {
  // @@protoc_insertion_point(field_list:metrics.SystemProfileProto.DemoModeDimensions.customization_facet)
  return _impl_.customization_facet_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
SystemProfileProto_DemoModeDimensions::_internal_mutable_customization_facet() {
  return &_impl_.customization_facet_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
SystemProfileProto_DemoModeDimensions::mutable_customization_facet() {
  // @@protoc_insertion_point(field_mutable_list:metrics.SystemProfileProto.DemoModeDimensions.customization_facet)
  return _internal_mutable_customization_facet();
}

// optional string app_version = 4;
inline bool SystemProfileProto_DemoModeDimensions::_internal_has_app_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto_DemoModeDimensions::has_app_version() const {
  return _internal_has_app_version();
}
inline void SystemProfileProto_DemoModeDimensions::clear_app_version() {
  _impl_.app_version_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SystemProfileProto_DemoModeDimensions::app_version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.DemoModeDimensions.app_version)
  return _internal_app_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_DemoModeDimensions::set_app_version(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.app_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.DemoModeDimensions.app_version)
}
inline std::string* SystemProfileProto_DemoModeDimensions::mutable_app_version() {
  std::string* _s = _internal_mutable_app_version();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.DemoModeDimensions.app_version)
  return _s;
}
inline const std::string& SystemProfileProto_DemoModeDimensions::_internal_app_version() const {
  return _impl_.app_version_.Get();
}
inline void SystemProfileProto_DemoModeDimensions::_internal_set_app_version(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.app_version_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_DemoModeDimensions::_internal_mutable_app_version() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.app_version_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_DemoModeDimensions::release_app_version() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.DemoModeDimensions.app_version)
  if (!_internal_has_app_version()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.app_version_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.app_version_.IsDefault()) {
    _impl_.app_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_DemoModeDimensions::set_allocated_app_version(std::string* app_version) {
  if (app_version != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.app_version_.SetAllocated(app_version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.app_version_.IsDefault()) {
    _impl_.app_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.DemoModeDimensions.app_version)
}

// optional string resources_version = 5;
inline bool SystemProfileProto_DemoModeDimensions::_internal_has_resources_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto_DemoModeDimensions::has_resources_version() const {
  return _internal_has_resources_version();
}
inline void SystemProfileProto_DemoModeDimensions::clear_resources_version() {
  _impl_.resources_version_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SystemProfileProto_DemoModeDimensions::resources_version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.DemoModeDimensions.resources_version)
  return _internal_resources_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto_DemoModeDimensions::set_resources_version(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.resources_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.DemoModeDimensions.resources_version)
}
inline std::string* SystemProfileProto_DemoModeDimensions::mutable_resources_version() {
  std::string* _s = _internal_mutable_resources_version();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.DemoModeDimensions.resources_version)
  return _s;
}
inline const std::string& SystemProfileProto_DemoModeDimensions::_internal_resources_version() const {
  return _impl_.resources_version_.Get();
}
inline void SystemProfileProto_DemoModeDimensions::_internal_set_resources_version(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.resources_version_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto_DemoModeDimensions::_internal_mutable_resources_version() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.resources_version_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto_DemoModeDimensions::release_resources_version() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.DemoModeDimensions.resources_version)
  if (!_internal_has_resources_version()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.resources_version_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.resources_version_.IsDefault()) {
    _impl_.resources_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto_DemoModeDimensions::set_allocated_resources_version(std::string* resources_version) {
  if (resources_version != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.resources_version_.SetAllocated(resources_version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.resources_version_.IsDefault()) {
    _impl_.resources_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.DemoModeDimensions.resources_version)
}

// -------------------------------------------------------------------

// SystemProfileProto

// optional int64 build_timestamp = 1;
inline bool SystemProfileProto::_internal_has_build_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool SystemProfileProto::has_build_timestamp() const {
  return _internal_has_build_timestamp();
}
inline void SystemProfileProto::clear_build_timestamp() {
  _impl_.build_timestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline int64_t SystemProfileProto::_internal_build_timestamp() const {
  return _impl_.build_timestamp_;
}
inline int64_t SystemProfileProto::build_timestamp() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.build_timestamp)
  return _internal_build_timestamp();
}
inline void SystemProfileProto::_internal_set_build_timestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.build_timestamp_ = value;
}
inline void SystemProfileProto::set_build_timestamp(int64_t value) {
  _internal_set_build_timestamp(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.build_timestamp)
}

// optional string app_version = 2;
inline bool SystemProfileProto::_internal_has_app_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto::has_app_version() const {
  return _internal_has_app_version();
}
inline void SystemProfileProto::clear_app_version() {
  _impl_.app_version_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SystemProfileProto::app_version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.app_version)
  return _internal_app_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto::set_app_version(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.app_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.app_version)
}
inline std::string* SystemProfileProto::mutable_app_version() {
  std::string* _s = _internal_mutable_app_version();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.app_version)
  return _s;
}
inline const std::string& SystemProfileProto::_internal_app_version() const {
  return _impl_.app_version_.Get();
}
inline void SystemProfileProto::_internal_set_app_version(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.app_version_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto::_internal_mutable_app_version() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.app_version_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto::release_app_version() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.app_version)
  if (!_internal_has_app_version()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.app_version_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.app_version_.IsDefault()) {
    _impl_.app_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto::set_allocated_app_version(std::string* app_version) {
  if (app_version != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.app_version_.SetAllocated(app_version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.app_version_.IsDefault()) {
    _impl_.app_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.app_version)
}

// optional string log_written_by_app_version = 40;
inline bool SystemProfileProto::_internal_has_log_written_by_app_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool SystemProfileProto::has_log_written_by_app_version() const {
  return _internal_has_log_written_by_app_version();
}
inline void SystemProfileProto::clear_log_written_by_app_version() {
  _impl_.log_written_by_app_version_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& SystemProfileProto::log_written_by_app_version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.log_written_by_app_version)
  return _internal_log_written_by_app_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto::set_log_written_by_app_version(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.log_written_by_app_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.log_written_by_app_version)
}
inline std::string* SystemProfileProto::mutable_log_written_by_app_version() {
  std::string* _s = _internal_mutable_log_written_by_app_version();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.log_written_by_app_version)
  return _s;
}
inline const std::string& SystemProfileProto::_internal_log_written_by_app_version() const {
  return _impl_.log_written_by_app_version_.Get();
}
inline void SystemProfileProto::_internal_set_log_written_by_app_version(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.log_written_by_app_version_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto::_internal_mutable_log_written_by_app_version() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.log_written_by_app_version_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto::release_log_written_by_app_version() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.log_written_by_app_version)
  if (!_internal_has_log_written_by_app_version()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.log_written_by_app_version_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.log_written_by_app_version_.IsDefault()) {
    _impl_.log_written_by_app_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto::set_allocated_log_written_by_app_version(std::string* log_written_by_app_version) {
  if (log_written_by_app_version != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.log_written_by_app_version_.SetAllocated(log_written_by_app_version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.log_written_by_app_version_.IsDefault()) {
    _impl_.log_written_by_app_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.log_written_by_app_version)
}

// optional string brand_code = 12;
inline bool SystemProfileProto::_internal_has_brand_code() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto::has_brand_code() const {
  return _internal_has_brand_code();
}
inline void SystemProfileProto::clear_brand_code() {
  _impl_.brand_code_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SystemProfileProto::brand_code() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.brand_code)
  return _internal_brand_code();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto::set_brand_code(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.brand_code_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.brand_code)
}
inline std::string* SystemProfileProto::mutable_brand_code() {
  std::string* _s = _internal_mutable_brand_code();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.brand_code)
  return _s;
}
inline const std::string& SystemProfileProto::_internal_brand_code() const {
  return _impl_.brand_code_.Get();
}
inline void SystemProfileProto::_internal_set_brand_code(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.brand_code_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto::_internal_mutable_brand_code() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.brand_code_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto::release_brand_code() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.brand_code)
  if (!_internal_has_brand_code()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.brand_code_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.brand_code_.IsDefault()) {
    _impl_.brand_code_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto::set_allocated_brand_code(std::string* brand_code) {
  if (brand_code != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.brand_code_.SetAllocated(brand_code, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.brand_code_.IsDefault()) {
    _impl_.brand_code_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.brand_code)
}

// optional .metrics.SystemProfileProto.Channel channel = 10;
inline bool SystemProfileProto::_internal_has_channel() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool SystemProfileProto::has_channel() const {
  return _internal_has_channel();
}
inline void SystemProfileProto::clear_channel() {
  _impl_.channel_ = 0;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline ::metrics::SystemProfileProto_Channel SystemProfileProto::_internal_channel() const {
  return static_cast< ::metrics::SystemProfileProto_Channel >(_impl_.channel_);
}
inline ::metrics::SystemProfileProto_Channel SystemProfileProto::channel() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.channel)
  return _internal_channel();
}
inline void SystemProfileProto::_internal_set_channel(::metrics::SystemProfileProto_Channel value) {
  assert(::metrics::SystemProfileProto_Channel_IsValid(value));
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.channel_ = value;
}
inline void SystemProfileProto::set_channel(::metrics::SystemProfileProto_Channel value) {
  _internal_set_channel(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.channel)
}

// optional bool is_extended_stable_channel = 36 [default = false];
inline bool SystemProfileProto::_internal_has_is_extended_stable_channel() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  return value;
}
inline bool SystemProfileProto::has_is_extended_stable_channel() const {
  return _internal_has_is_extended_stable_channel();
}
inline void SystemProfileProto::clear_is_extended_stable_channel() {
  _impl_.is_extended_stable_channel_ = false;
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline bool SystemProfileProto::_internal_is_extended_stable_channel() const {
  return _impl_.is_extended_stable_channel_;
}
inline bool SystemProfileProto::is_extended_stable_channel() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.is_extended_stable_channel)
  return _internal_is_extended_stable_channel();
}
inline void SystemProfileProto::_internal_set_is_extended_stable_channel(bool value) {
  _impl_._has_bits_[0] |= 0x00800000u;
  _impl_.is_extended_stable_channel_ = value;
}
inline void SystemProfileProto::set_is_extended_stable_channel(bool value) {
  _internal_set_is_extended_stable_channel(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.is_extended_stable_channel)
}

// optional bool is_instrumented_build = 20 [default = false];
inline bool SystemProfileProto::_internal_has_is_instrumented_build() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  return value;
}
inline bool SystemProfileProto::has_is_instrumented_build() const {
  return _internal_has_is_instrumented_build();
}
inline void SystemProfileProto::clear_is_instrumented_build() {
  _impl_.is_instrumented_build_ = false;
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline bool SystemProfileProto::_internal_is_instrumented_build() const {
  return _impl_.is_instrumented_build_;
}
inline bool SystemProfileProto::is_instrumented_build() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.is_instrumented_build)
  return _internal_is_instrumented_build();
}
inline void SystemProfileProto::_internal_set_is_instrumented_build(bool value) {
  _impl_._has_bits_[0] |= 0x01000000u;
  _impl_.is_instrumented_build_ = value;
}
inline void SystemProfileProto::set_is_instrumented_build(bool value) {
  _internal_set_is_instrumented_build(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.is_instrumented_build)
}

// optional int64 uma_enabled_date = 3;
inline bool SystemProfileProto::_internal_has_uma_enabled_date() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool SystemProfileProto::has_uma_enabled_date() const {
  return _internal_has_uma_enabled_date();
}
inline void SystemProfileProto::clear_uma_enabled_date() {
  _impl_.uma_enabled_date_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline int64_t SystemProfileProto::_internal_uma_enabled_date() const {
  return _impl_.uma_enabled_date_;
}
inline int64_t SystemProfileProto::uma_enabled_date() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.uma_enabled_date)
  return _internal_uma_enabled_date();
}
inline void SystemProfileProto::_internal_set_uma_enabled_date(int64_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.uma_enabled_date_ = value;
}
inline void SystemProfileProto::set_uma_enabled_date(int64_t value) {
  _internal_set_uma_enabled_date(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.uma_enabled_date)
}

// optional int64 install_date = 16;
inline bool SystemProfileProto::_internal_has_install_date() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool SystemProfileProto::has_install_date() const {
  return _internal_has_install_date();
}
inline void SystemProfileProto::clear_install_date() {
  _impl_.install_date_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline int64_t SystemProfileProto::_internal_install_date() const {
  return _impl_.install_date_;
}
inline int64_t SystemProfileProto::install_date() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.install_date)
  return _internal_install_date();
}
inline void SystemProfileProto::_internal_set_install_date(int64_t value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.install_date_ = value;
}
inline void SystemProfileProto::set_install_date(int64_t value) {
  _internal_set_install_date(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.install_date)
}

// optional .metrics.SystemProfileProto.ClonedInstallInfo cloned_install_info = 39;
inline bool SystemProfileProto::_internal_has_cloned_install_info() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.cloned_install_info_ != nullptr);
  return value;
}
inline bool SystemProfileProto::has_cloned_install_info() const {
  return _internal_has_cloned_install_info();
}
inline void SystemProfileProto::clear_cloned_install_info() {
  if (_impl_.cloned_install_info_ != nullptr) _impl_.cloned_install_info_->Clear();
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline const ::metrics::SystemProfileProto_ClonedInstallInfo& SystemProfileProto::_internal_cloned_install_info() const {
  const ::metrics::SystemProfileProto_ClonedInstallInfo* p = _impl_.cloned_install_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_ClonedInstallInfo&>(
      ::metrics::_SystemProfileProto_ClonedInstallInfo_default_instance_);
}
inline const ::metrics::SystemProfileProto_ClonedInstallInfo& SystemProfileProto::cloned_install_info() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.cloned_install_info)
  return _internal_cloned_install_info();
}
inline void SystemProfileProto::unsafe_arena_set_allocated_cloned_install_info(
    ::metrics::SystemProfileProto_ClonedInstallInfo* cloned_install_info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cloned_install_info_);
  }
  _impl_.cloned_install_info_ = cloned_install_info;
  if (cloned_install_info) {
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.cloned_install_info)
}
inline ::metrics::SystemProfileProto_ClonedInstallInfo* SystemProfileProto::release_cloned_install_info() {
  _impl_._has_bits_[0] &= ~0x00004000u;
  ::metrics::SystemProfileProto_ClonedInstallInfo* temp = _impl_.cloned_install_info_;
  _impl_.cloned_install_info_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_ClonedInstallInfo* SystemProfileProto::unsafe_arena_release_cloned_install_info() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.cloned_install_info)
  _impl_._has_bits_[0] &= ~0x00004000u;
  ::metrics::SystemProfileProto_ClonedInstallInfo* temp = _impl_.cloned_install_info_;
  _impl_.cloned_install_info_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_ClonedInstallInfo* SystemProfileProto::_internal_mutable_cloned_install_info() {
  _impl_._has_bits_[0] |= 0x00004000u;
  if (_impl_.cloned_install_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_ClonedInstallInfo>(GetArenaForAllocation());
    _impl_.cloned_install_info_ = p;
  }
  return _impl_.cloned_install_info_;
}
inline ::metrics::SystemProfileProto_ClonedInstallInfo* SystemProfileProto::mutable_cloned_install_info() {
  ::metrics::SystemProfileProto_ClonedInstallInfo* _msg = _internal_mutable_cloned_install_info();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.cloned_install_info)
  return _msg;
}
inline void SystemProfileProto::set_allocated_cloned_install_info(::metrics::SystemProfileProto_ClonedInstallInfo* cloned_install_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.cloned_install_info_;
  }
  if (cloned_install_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cloned_install_info);
    if (message_arena != submessage_arena) {
      cloned_install_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cloned_install_info, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  _impl_.cloned_install_info_ = cloned_install_info;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.cloned_install_info)
}

// optional int32 low_entropy_source = 31;
inline bool SystemProfileProto::_internal_has_low_entropy_source() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  return value;
}
inline bool SystemProfileProto::has_low_entropy_source() const {
  return _internal_has_low_entropy_source();
}
inline void SystemProfileProto::clear_low_entropy_source() {
  _impl_.low_entropy_source_ = 0;
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline int32_t SystemProfileProto::_internal_low_entropy_source() const {
  return _impl_.low_entropy_source_;
}
inline int32_t SystemProfileProto::low_entropy_source() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.low_entropy_source)
  return _internal_low_entropy_source();
}
inline void SystemProfileProto::_internal_set_low_entropy_source(int32_t value) {
  _impl_._has_bits_[0] |= 0x04000000u;
  _impl_.low_entropy_source_ = value;
}
inline void SystemProfileProto::set_low_entropy_source(int32_t value) {
  _internal_set_low_entropy_source(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.low_entropy_source)
}

// optional int32 old_low_entropy_source = 32;
inline bool SystemProfileProto::_internal_has_old_low_entropy_source() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline bool SystemProfileProto::has_old_low_entropy_source() const {
  return _internal_has_old_low_entropy_source();
}
inline void SystemProfileProto::clear_old_low_entropy_source() {
  _impl_.old_low_entropy_source_ = 0;
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline int32_t SystemProfileProto::_internal_old_low_entropy_source() const {
  return _impl_.old_low_entropy_source_;
}
inline int32_t SystemProfileProto::old_low_entropy_source() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.old_low_entropy_source)
  return _internal_old_low_entropy_source();
}
inline void SystemProfileProto::_internal_set_old_low_entropy_source(int32_t value) {
  _impl_._has_bits_[0] |= 0x08000000u;
  _impl_.old_low_entropy_source_ = value;
}
inline void SystemProfileProto::set_old_low_entropy_source(int32_t value) {
  _internal_set_old_low_entropy_source(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.old_low_entropy_source)
}

// optional int32 pseudo_low_entropy_source = 37;
inline bool SystemProfileProto::_internal_has_pseudo_low_entropy_source() const {
  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
  return value;
}
inline bool SystemProfileProto::has_pseudo_low_entropy_source() const {
  return _internal_has_pseudo_low_entropy_source();
}
inline void SystemProfileProto::clear_pseudo_low_entropy_source() {
  _impl_.pseudo_low_entropy_source_ = 0;
  _impl_._has_bits_[0] &= ~0x20000000u;
}
inline int32_t SystemProfileProto::_internal_pseudo_low_entropy_source() const {
  return _impl_.pseudo_low_entropy_source_;
}
inline int32_t SystemProfileProto::pseudo_low_entropy_source() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.pseudo_low_entropy_source)
  return _internal_pseudo_low_entropy_source();
}
inline void SystemProfileProto::_internal_set_pseudo_low_entropy_source(int32_t value) {
  _impl_._has_bits_[0] |= 0x20000000u;
  _impl_.pseudo_low_entropy_source_ = value;
}
inline void SystemProfileProto::set_pseudo_low_entropy_source(int32_t value) {
  _internal_set_pseudo_low_entropy_source(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.pseudo_low_entropy_source)
}

// optional string application_locale = 4;
inline bool SystemProfileProto::_internal_has_application_locale() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto::has_application_locale() const {
  return _internal_has_application_locale();
}
inline void SystemProfileProto::clear_application_locale() {
  _impl_.application_locale_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SystemProfileProto::application_locale() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.application_locale)
  return _internal_application_locale();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto::set_application_locale(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.application_locale_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.application_locale)
}
inline std::string* SystemProfileProto::mutable_application_locale() {
  std::string* _s = _internal_mutable_application_locale();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.application_locale)
  return _s;
}
inline const std::string& SystemProfileProto::_internal_application_locale() const {
  return _impl_.application_locale_.Get();
}
inline void SystemProfileProto::_internal_set_application_locale(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.application_locale_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto::_internal_mutable_application_locale() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.application_locale_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto::release_application_locale() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.application_locale)
  if (!_internal_has_application_locale()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.application_locale_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.application_locale_.IsDefault()) {
    _impl_.application_locale_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto::set_allocated_application_locale(std::string* application_locale) {
  if (application_locale != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.application_locale_.SetAllocated(application_locale, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.application_locale_.IsDefault()) {
    _impl_.application_locale_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.application_locale)
}

// repeated fixed32 command_line_key_hash = 38 [packed = true];
inline int SystemProfileProto::_internal_command_line_key_hash_size() const {
  return _impl_.command_line_key_hash_.size();
}
inline int SystemProfileProto::command_line_key_hash_size() const {
  return _internal_command_line_key_hash_size();
}
inline void SystemProfileProto::clear_command_line_key_hash() {
  _impl_.command_line_key_hash_.Clear();
}
inline uint32_t SystemProfileProto::_internal_command_line_key_hash(int index) const {
  return _impl_.command_line_key_hash_.Get(index);
}
inline uint32_t SystemProfileProto::command_line_key_hash(int index) const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.command_line_key_hash)
  return _internal_command_line_key_hash(index);
}
inline void SystemProfileProto::set_command_line_key_hash(int index, uint32_t value) {
  _impl_.command_line_key_hash_.Set(index, value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.command_line_key_hash)
}
inline void SystemProfileProto::_internal_add_command_line_key_hash(uint32_t value) {
  _impl_.command_line_key_hash_.Add(value);
}
inline void SystemProfileProto::add_command_line_key_hash(uint32_t value) {
  _internal_add_command_line_key_hash(value);
  // @@protoc_insertion_point(field_add:metrics.SystemProfileProto.command_line_key_hash)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
SystemProfileProto::_internal_command_line_key_hash() const {
  return _impl_.command_line_key_hash_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
SystemProfileProto::command_line_key_hash() const {
  // @@protoc_insertion_point(field_list:metrics.SystemProfileProto.command_line_key_hash)
  return _internal_command_line_key_hash();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
SystemProfileProto::_internal_mutable_command_line_key_hash() {
  return &_impl_.command_line_key_hash_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
SystemProfileProto::mutable_command_line_key_hash() {
  // @@protoc_insertion_point(field_mutable_list:metrics.SystemProfileProto.command_line_key_hash)
  return _internal_mutable_command_line_key_hash();
}

// optional .metrics.SystemProfileProto.OS os = 5;
inline bool SystemProfileProto::_internal_has_os() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.os_ != nullptr);
  return value;
}
inline bool SystemProfileProto::has_os() const {
  return _internal_has_os();
}
inline void SystemProfileProto::clear_os() {
  if (_impl_.os_ != nullptr) _impl_.os_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::metrics::SystemProfileProto_OS& SystemProfileProto::_internal_os() const {
  const ::metrics::SystemProfileProto_OS* p = _impl_.os_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_OS&>(
      ::metrics::_SystemProfileProto_OS_default_instance_);
}
inline const ::metrics::SystemProfileProto_OS& SystemProfileProto::os() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.os)
  return _internal_os();
}
inline void SystemProfileProto::unsafe_arena_set_allocated_os(
    ::metrics::SystemProfileProto_OS* os) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.os_);
  }
  _impl_.os_ = os;
  if (os) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.os)
}
inline ::metrics::SystemProfileProto_OS* SystemProfileProto::release_os() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::metrics::SystemProfileProto_OS* temp = _impl_.os_;
  _impl_.os_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_OS* SystemProfileProto::unsafe_arena_release_os() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.os)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::metrics::SystemProfileProto_OS* temp = _impl_.os_;
  _impl_.os_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_OS* SystemProfileProto::_internal_mutable_os() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.os_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_OS>(GetArenaForAllocation());
    _impl_.os_ = p;
  }
  return _impl_.os_;
}
inline ::metrics::SystemProfileProto_OS* SystemProfileProto::mutable_os() {
  ::metrics::SystemProfileProto_OS* _msg = _internal_mutable_os();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.os)
  return _msg;
}
inline void SystemProfileProto::set_allocated_os(::metrics::SystemProfileProto_OS* os) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.os_;
  }
  if (os) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(os);
    if (message_arena != submessage_arena) {
      os = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, os, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.os_ = os;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.os)
}

// optional .metrics.SystemProfileProto.Hardware hardware = 6;
inline bool SystemProfileProto::_internal_has_hardware() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.hardware_ != nullptr);
  return value;
}
inline bool SystemProfileProto::has_hardware() const {
  return _internal_has_hardware();
}
inline void SystemProfileProto::clear_hardware() {
  if (_impl_.hardware_ != nullptr) _impl_.hardware_->Clear();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const ::metrics::SystemProfileProto_Hardware& SystemProfileProto::_internal_hardware() const {
  const ::metrics::SystemProfileProto_Hardware* p = _impl_.hardware_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_Hardware&>(
      ::metrics::_SystemProfileProto_Hardware_default_instance_);
}
inline const ::metrics::SystemProfileProto_Hardware& SystemProfileProto::hardware() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.hardware)
  return _internal_hardware();
}
inline void SystemProfileProto::unsafe_arena_set_allocated_hardware(
    ::metrics::SystemProfileProto_Hardware* hardware) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hardware_);
  }
  _impl_.hardware_ = hardware;
  if (hardware) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.hardware)
}
inline ::metrics::SystemProfileProto_Hardware* SystemProfileProto::release_hardware() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::metrics::SystemProfileProto_Hardware* temp = _impl_.hardware_;
  _impl_.hardware_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_Hardware* SystemProfileProto::unsafe_arena_release_hardware() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.hardware)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::metrics::SystemProfileProto_Hardware* temp = _impl_.hardware_;
  _impl_.hardware_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_Hardware* SystemProfileProto::_internal_mutable_hardware() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.hardware_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_Hardware>(GetArenaForAllocation());
    _impl_.hardware_ = p;
  }
  return _impl_.hardware_;
}
inline ::metrics::SystemProfileProto_Hardware* SystemProfileProto::mutable_hardware() {
  ::metrics::SystemProfileProto_Hardware* _msg = _internal_mutable_hardware();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.hardware)
  return _msg;
}
inline void SystemProfileProto::set_allocated_hardware(::metrics::SystemProfileProto_Hardware* hardware) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.hardware_;
  }
  if (hardware) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hardware);
    if (message_arena != submessage_arena) {
      hardware = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hardware, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.hardware_ = hardware;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.hardware)
}

// optional .metrics.SystemProfileProto.Network network = 13;
inline bool SystemProfileProto::_internal_has_network() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.network_ != nullptr);
  return value;
}
inline bool SystemProfileProto::has_network() const {
  return _internal_has_network();
}
inline void SystemProfileProto::clear_network() {
  if (_impl_.network_ != nullptr) _impl_.network_->Clear();
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline const ::metrics::SystemProfileProto_Network& SystemProfileProto::_internal_network() const {
  const ::metrics::SystemProfileProto_Network* p = _impl_.network_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_Network&>(
      ::metrics::_SystemProfileProto_Network_default_instance_);
}
inline const ::metrics::SystemProfileProto_Network& SystemProfileProto::network() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.network)
  return _internal_network();
}
inline void SystemProfileProto::unsafe_arena_set_allocated_network(
    ::metrics::SystemProfileProto_Network* network) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.network_);
  }
  _impl_.network_ = network;
  if (network) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.network)
}
inline ::metrics::SystemProfileProto_Network* SystemProfileProto::release_network() {
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::metrics::SystemProfileProto_Network* temp = _impl_.network_;
  _impl_.network_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_Network* SystemProfileProto::unsafe_arena_release_network() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.network)
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::metrics::SystemProfileProto_Network* temp = _impl_.network_;
  _impl_.network_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_Network* SystemProfileProto::_internal_mutable_network() {
  _impl_._has_bits_[0] |= 0x00000800u;
  if (_impl_.network_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_Network>(GetArenaForAllocation());
    _impl_.network_ = p;
  }
  return _impl_.network_;
}
inline ::metrics::SystemProfileProto_Network* SystemProfileProto::mutable_network() {
  ::metrics::SystemProfileProto_Network* _msg = _internal_mutable_network();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.network)
  return _msg;
}
inline void SystemProfileProto::set_allocated_network(::metrics::SystemProfileProto_Network* network) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.network_;
  }
  if (network) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(network);
    if (message_arena != submessage_arena) {
      network = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, network, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.network_ = network;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.network)
}

// optional .metrics.SystemProfileProto.GoogleUpdate google_update = 11;
inline bool SystemProfileProto::_internal_has_google_update() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.google_update_ != nullptr);
  return value;
}
inline bool SystemProfileProto::has_google_update() const {
  return _internal_has_google_update();
}
inline void SystemProfileProto::clear_google_update() {
  if (_impl_.google_update_ != nullptr) _impl_.google_update_->Clear();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const ::metrics::SystemProfileProto_GoogleUpdate& SystemProfileProto::_internal_google_update() const {
  const ::metrics::SystemProfileProto_GoogleUpdate* p = _impl_.google_update_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_GoogleUpdate&>(
      ::metrics::_SystemProfileProto_GoogleUpdate_default_instance_);
}
inline const ::metrics::SystemProfileProto_GoogleUpdate& SystemProfileProto::google_update() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.google_update)
  return _internal_google_update();
}
inline void SystemProfileProto::unsafe_arena_set_allocated_google_update(
    ::metrics::SystemProfileProto_GoogleUpdate* google_update) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.google_update_);
  }
  _impl_.google_update_ = google_update;
  if (google_update) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.google_update)
}
inline ::metrics::SystemProfileProto_GoogleUpdate* SystemProfileProto::release_google_update() {
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::metrics::SystemProfileProto_GoogleUpdate* temp = _impl_.google_update_;
  _impl_.google_update_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_GoogleUpdate* SystemProfileProto::unsafe_arena_release_google_update() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.google_update)
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::metrics::SystemProfileProto_GoogleUpdate* temp = _impl_.google_update_;
  _impl_.google_update_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_GoogleUpdate* SystemProfileProto::_internal_mutable_google_update() {
  _impl_._has_bits_[0] |= 0x00000400u;
  if (_impl_.google_update_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_GoogleUpdate>(GetArenaForAllocation());
    _impl_.google_update_ = p;
  }
  return _impl_.google_update_;
}
inline ::metrics::SystemProfileProto_GoogleUpdate* SystemProfileProto::mutable_google_update() {
  ::metrics::SystemProfileProto_GoogleUpdate* _msg = _internal_mutable_google_update();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.google_update)
  return _msg;
}
inline void SystemProfileProto::set_allocated_google_update(::metrics::SystemProfileProto_GoogleUpdate* google_update) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.google_update_;
  }
  if (google_update) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(google_update);
    if (message_arena != submessage_arena) {
      google_update = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, google_update, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.google_update_ = google_update;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.google_update)
}

// optional .metrics.SystemProfileProto.Stability stability = 8;
inline bool SystemProfileProto::_internal_has_stability() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.stability_ != nullptr);
  return value;
}
inline bool SystemProfileProto::has_stability() const {
  return _internal_has_stability();
}
inline void SystemProfileProto::clear_stability() {
  if (_impl_.stability_ != nullptr) _impl_.stability_->Clear();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const ::metrics::SystemProfileProto_Stability& SystemProfileProto::_internal_stability() const {
  const ::metrics::SystemProfileProto_Stability* p = _impl_.stability_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_Stability&>(
      ::metrics::_SystemProfileProto_Stability_default_instance_);
}
inline const ::metrics::SystemProfileProto_Stability& SystemProfileProto::stability() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.stability)
  return _internal_stability();
}
inline void SystemProfileProto::unsafe_arena_set_allocated_stability(
    ::metrics::SystemProfileProto_Stability* stability) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stability_);
  }
  _impl_.stability_ = stability;
  if (stability) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.stability)
}
inline ::metrics::SystemProfileProto_Stability* SystemProfileProto::release_stability() {
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::metrics::SystemProfileProto_Stability* temp = _impl_.stability_;
  _impl_.stability_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_Stability* SystemProfileProto::unsafe_arena_release_stability() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.stability)
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::metrics::SystemProfileProto_Stability* temp = _impl_.stability_;
  _impl_.stability_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_Stability* SystemProfileProto::_internal_mutable_stability() {
  _impl_._has_bits_[0] |= 0x00000200u;
  if (_impl_.stability_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_Stability>(GetArenaForAllocation());
    _impl_.stability_ = p;
  }
  return _impl_.stability_;
}
inline ::metrics::SystemProfileProto_Stability* SystemProfileProto::mutable_stability() {
  ::metrics::SystemProfileProto_Stability* _msg = _internal_mutable_stability();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.stability)
  return _msg;
}
inline void SystemProfileProto::set_allocated_stability(::metrics::SystemProfileProto_Stability* stability) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.stability_;
  }
  if (stability) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stability);
    if (message_arena != submessage_arena) {
      stability = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, stability, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.stability_ = stability;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.stability)
}

// repeated .metrics.SystemProfileProto.FieldTrial field_trial = 9;
inline int SystemProfileProto::_internal_field_trial_size() const {
  return _impl_.field_trial_.size();
}
inline int SystemProfileProto::field_trial_size() const {
  return _internal_field_trial_size();
}
inline void SystemProfileProto::clear_field_trial() {
  _impl_.field_trial_.Clear();
}
inline ::metrics::SystemProfileProto_FieldTrial* SystemProfileProto::mutable_field_trial(int index) {
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.field_trial)
  return _impl_.field_trial_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_FieldTrial >*
SystemProfileProto::mutable_field_trial() {
  // @@protoc_insertion_point(field_mutable_list:metrics.SystemProfileProto.field_trial)
  return &_impl_.field_trial_;
}
inline const ::metrics::SystemProfileProto_FieldTrial& SystemProfileProto::_internal_field_trial(int index) const {
  return _impl_.field_trial_.Get(index);
}
inline const ::metrics::SystemProfileProto_FieldTrial& SystemProfileProto::field_trial(int index) const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.field_trial)
  return _internal_field_trial(index);
}
inline ::metrics::SystemProfileProto_FieldTrial* SystemProfileProto::_internal_add_field_trial() {
  return _impl_.field_trial_.Add();
}
inline ::metrics::SystemProfileProto_FieldTrial* SystemProfileProto::add_field_trial() {
  ::metrics::SystemProfileProto_FieldTrial* _add = _internal_add_field_trial();
  // @@protoc_insertion_point(field_add:metrics.SystemProfileProto.field_trial)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_FieldTrial >&
SystemProfileProto::field_trial() const {
  // @@protoc_insertion_point(field_list:metrics.SystemProfileProto.field_trial)
  return _impl_.field_trial_;
}

// optional string variations_seed_version = 28;
inline bool SystemProfileProto::_internal_has_variations_seed_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SystemProfileProto::has_variations_seed_version() const {
  return _internal_has_variations_seed_version();
}
inline void SystemProfileProto::clear_variations_seed_version() {
  _impl_.variations_seed_version_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& SystemProfileProto::variations_seed_version() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.variations_seed_version)
  return _internal_variations_seed_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto::set_variations_seed_version(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.variations_seed_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.variations_seed_version)
}
inline std::string* SystemProfileProto::mutable_variations_seed_version() {
  std::string* _s = _internal_mutable_variations_seed_version();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.variations_seed_version)
  return _s;
}
inline const std::string& SystemProfileProto::_internal_variations_seed_version() const {
  return _impl_.variations_seed_version_.Get();
}
inline void SystemProfileProto::_internal_set_variations_seed_version(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.variations_seed_version_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto::_internal_mutable_variations_seed_version() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.variations_seed_version_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto::release_variations_seed_version() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.variations_seed_version)
  if (!_internal_has_variations_seed_version()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.variations_seed_version_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.variations_seed_version_.IsDefault()) {
    _impl_.variations_seed_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto::set_allocated_variations_seed_version(std::string* variations_seed_version) {
  if (variations_seed_version != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.variations_seed_version_.SetAllocated(variations_seed_version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.variations_seed_version_.IsDefault()) {
    _impl_.variations_seed_version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.variations_seed_version)
}

// optional bool client_id_was_used_for_trial_assignment = 33;
inline bool SystemProfileProto::_internal_has_client_id_was_used_for_trial_assignment() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  return value;
}
inline bool SystemProfileProto::has_client_id_was_used_for_trial_assignment() const {
  return _internal_has_client_id_was_used_for_trial_assignment();
}
inline void SystemProfileProto::clear_client_id_was_used_for_trial_assignment() {
  _impl_.client_id_was_used_for_trial_assignment_ = false;
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline bool SystemProfileProto::_internal_client_id_was_used_for_trial_assignment() const {
  return _impl_.client_id_was_used_for_trial_assignment_;
}
inline bool SystemProfileProto::client_id_was_used_for_trial_assignment() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.client_id_was_used_for_trial_assignment)
  return _internal_client_id_was_used_for_trial_assignment();
}
inline void SystemProfileProto::_internal_set_client_id_was_used_for_trial_assignment(bool value) {
  _impl_._has_bits_[0] |= 0x02000000u;
  _impl_.client_id_was_used_for_trial_assignment_ = value;
}
inline void SystemProfileProto::set_client_id_was_used_for_trial_assignment(bool value) {
  _internal_set_client_id_was_used_for_trial_assignment(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.client_id_was_used_for_trial_assignment)
}

// optional string client_uuid = 34;
inline bool SystemProfileProto::_internal_has_client_uuid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SystemProfileProto::has_client_uuid() const {
  return _internal_has_client_uuid();
}
inline void SystemProfileProto::clear_client_uuid() {
  _impl_.client_uuid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& SystemProfileProto::client_uuid() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.client_uuid)
  return _internal_client_uuid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto::set_client_uuid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.client_uuid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.client_uuid)
}
inline std::string* SystemProfileProto::mutable_client_uuid() {
  std::string* _s = _internal_mutable_client_uuid();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.client_uuid)
  return _s;
}
inline const std::string& SystemProfileProto::_internal_client_uuid() const {
  return _impl_.client_uuid_.Get();
}
inline void SystemProfileProto::_internal_set_client_uuid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.client_uuid_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto::_internal_mutable_client_uuid() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.client_uuid_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto::release_client_uuid() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.client_uuid)
  if (!_internal_has_client_uuid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.client_uuid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.client_uuid_.IsDefault()) {
    _impl_.client_uuid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto::set_allocated_client_uuid(std::string* client_uuid) {
  if (client_uuid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.client_uuid_.SetAllocated(client_uuid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.client_uuid_.IsDefault()) {
    _impl_.client_uuid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.client_uuid)
}

// optional fixed64 session_hash = 46;
inline bool SystemProfileProto::_internal_has_session_hash() const {
  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
  return value;
}
inline bool SystemProfileProto::has_session_hash() const {
  return _internal_has_session_hash();
}
inline void SystemProfileProto::clear_session_hash() {
  _impl_.session_hash_ = uint64_t{0u};
  _impl_._has_bits_[1] &= ~0x00000002u;
}
inline uint64_t SystemProfileProto::_internal_session_hash() const {
  return _impl_.session_hash_;
}
inline uint64_t SystemProfileProto::session_hash() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.session_hash)
  return _internal_session_hash();
}
inline void SystemProfileProto::_internal_set_session_hash(uint64_t value) {
  _impl_._has_bits_[1] |= 0x00000002u;
  _impl_.session_hash_ = value;
}
inline void SystemProfileProto::set_session_hash(uint64_t value) {
  _internal_set_session_hash(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.session_hash)
}

// repeated .metrics.SystemProfileProto.ExternalAudioVideoDevice external_audio_video_device = 14;
inline int SystemProfileProto::_internal_external_audio_video_device_size() const {
  return _impl_.external_audio_video_device_.size();
}
inline int SystemProfileProto::external_audio_video_device_size() const {
  return _internal_external_audio_video_device_size();
}
inline void SystemProfileProto::clear_external_audio_video_device() {
  _impl_.external_audio_video_device_.Clear();
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice* SystemProfileProto::mutable_external_audio_video_device(int index) {
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.external_audio_video_device)
  return _impl_.external_audio_video_device_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice >*
SystemProfileProto::mutable_external_audio_video_device() {
  // @@protoc_insertion_point(field_mutable_list:metrics.SystemProfileProto.external_audio_video_device)
  return &_impl_.external_audio_video_device_;
}
inline const ::metrics::SystemProfileProto_ExternalAudioVideoDevice& SystemProfileProto::_internal_external_audio_video_device(int index) const {
  return _impl_.external_audio_video_device_.Get(index);
}
inline const ::metrics::SystemProfileProto_ExternalAudioVideoDevice& SystemProfileProto::external_audio_video_device(int index) const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.external_audio_video_device)
  return _internal_external_audio_video_device(index);
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice* SystemProfileProto::_internal_add_external_audio_video_device() {
  return _impl_.external_audio_video_device_.Add();
}
inline ::metrics::SystemProfileProto_ExternalAudioVideoDevice* SystemProfileProto::add_external_audio_video_device() {
  ::metrics::SystemProfileProto_ExternalAudioVideoDevice* _add = _internal_add_external_audio_video_device();
  // @@protoc_insertion_point(field_add:metrics.SystemProfileProto.external_audio_video_device)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ExternalAudioVideoDevice >&
SystemProfileProto::external_audio_video_device() const {
  // @@protoc_insertion_point(field_list:metrics.SystemProfileProto.external_audio_video_device)
  return _impl_.external_audio_video_device_;
}

// optional .metrics.SystemProfileProto.ExternalAccessPoint external_access_point = 15;
inline bool SystemProfileProto::_internal_has_external_access_point() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.external_access_point_ != nullptr);
  return value;
}
inline bool SystemProfileProto::has_external_access_point() const {
  return _internal_has_external_access_point();
}
inline void SystemProfileProto::clear_external_access_point() {
  if (_impl_.external_access_point_ != nullptr) _impl_.external_access_point_->Clear();
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline const ::metrics::SystemProfileProto_ExternalAccessPoint& SystemProfileProto::_internal_external_access_point() const {
  const ::metrics::SystemProfileProto_ExternalAccessPoint* p = _impl_.external_access_point_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_ExternalAccessPoint&>(
      ::metrics::_SystemProfileProto_ExternalAccessPoint_default_instance_);
}
inline const ::metrics::SystemProfileProto_ExternalAccessPoint& SystemProfileProto::external_access_point() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.external_access_point)
  return _internal_external_access_point();
}
inline void SystemProfileProto::unsafe_arena_set_allocated_external_access_point(
    ::metrics::SystemProfileProto_ExternalAccessPoint* external_access_point) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.external_access_point_);
  }
  _impl_.external_access_point_ = external_access_point;
  if (external_access_point) {
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.external_access_point)
}
inline ::metrics::SystemProfileProto_ExternalAccessPoint* SystemProfileProto::release_external_access_point() {
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::metrics::SystemProfileProto_ExternalAccessPoint* temp = _impl_.external_access_point_;
  _impl_.external_access_point_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_ExternalAccessPoint* SystemProfileProto::unsafe_arena_release_external_access_point() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.external_access_point)
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::metrics::SystemProfileProto_ExternalAccessPoint* temp = _impl_.external_access_point_;
  _impl_.external_access_point_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_ExternalAccessPoint* SystemProfileProto::_internal_mutable_external_access_point() {
  _impl_._has_bits_[0] |= 0x00001000u;
  if (_impl_.external_access_point_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_ExternalAccessPoint>(GetArenaForAllocation());
    _impl_.external_access_point_ = p;
  }
  return _impl_.external_access_point_;
}
inline ::metrics::SystemProfileProto_ExternalAccessPoint* SystemProfileProto::mutable_external_access_point() {
  ::metrics::SystemProfileProto_ExternalAccessPoint* _msg = _internal_mutable_external_access_point();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.external_access_point)
  return _msg;
}
inline void SystemProfileProto::set_allocated_external_access_point(::metrics::SystemProfileProto_ExternalAccessPoint* external_access_point) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.external_access_point_;
  }
  if (external_access_point) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(external_access_point);
    if (message_arena != submessage_arena) {
      external_access_point = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, external_access_point, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  _impl_.external_access_point_ = external_access_point;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.external_access_point)
}

// optional uint32 multi_profile_user_count = 17;
inline bool SystemProfileProto::_internal_has_multi_profile_user_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool SystemProfileProto::has_multi_profile_user_count() const {
  return _internal_has_multi_profile_user_count();
}
inline void SystemProfileProto::clear_multi_profile_user_count() {
  _impl_.multi_profile_user_count_ = 0u;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline uint32_t SystemProfileProto::_internal_multi_profile_user_count() const {
  return _impl_.multi_profile_user_count_;
}
inline uint32_t SystemProfileProto::multi_profile_user_count() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.multi_profile_user_count)
  return _internal_multi_profile_user_count();
}
inline void SystemProfileProto::_internal_set_multi_profile_user_count(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.multi_profile_user_count_ = value;
}
inline void SystemProfileProto::set_multi_profile_user_count(uint32_t value) {
  _internal_set_multi_profile_user_count(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.multi_profile_user_count)
}

// repeated int32 occupied_extension_bucket = 18;
inline int SystemProfileProto::_internal_occupied_extension_bucket_size() const {
  return _impl_.occupied_extension_bucket_.size();
}
inline int SystemProfileProto::occupied_extension_bucket_size() const {
  return _internal_occupied_extension_bucket_size();
}
inline void SystemProfileProto::clear_occupied_extension_bucket() {
  _impl_.occupied_extension_bucket_.Clear();
}
inline int32_t SystemProfileProto::_internal_occupied_extension_bucket(int index) const {
  return _impl_.occupied_extension_bucket_.Get(index);
}
inline int32_t SystemProfileProto::occupied_extension_bucket(int index) const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.occupied_extension_bucket)
  return _internal_occupied_extension_bucket(index);
}
inline void SystemProfileProto::set_occupied_extension_bucket(int index, int32_t value) {
  _impl_.occupied_extension_bucket_.Set(index, value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.occupied_extension_bucket)
}
inline void SystemProfileProto::_internal_add_occupied_extension_bucket(int32_t value) {
  _impl_.occupied_extension_bucket_.Add(value);
}
inline void SystemProfileProto::add_occupied_extension_bucket(int32_t value) {
  _internal_add_occupied_extension_bucket(value);
  // @@protoc_insertion_point(field_add:metrics.SystemProfileProto.occupied_extension_bucket)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SystemProfileProto::_internal_occupied_extension_bucket() const {
  return _impl_.occupied_extension_bucket_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SystemProfileProto::occupied_extension_bucket() const {
  // @@protoc_insertion_point(field_list:metrics.SystemProfileProto.occupied_extension_bucket)
  return _internal_occupied_extension_bucket();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SystemProfileProto::_internal_mutable_occupied_extension_bucket() {
  return &_impl_.occupied_extension_bucket_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SystemProfileProto::mutable_occupied_extension_bucket() {
  // @@protoc_insertion_point(field_mutable_list:metrics.SystemProfileProto.occupied_extension_bucket)
  return _internal_mutable_occupied_extension_bucket();
}

// optional .metrics.SystemProfileProto.ExtensionsState offstore_extensions_state = 19;
inline bool SystemProfileProto::_internal_has_offstore_extensions_state() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool SystemProfileProto::has_offstore_extensions_state() const {
  return _internal_has_offstore_extensions_state();
}
inline void SystemProfileProto::clear_offstore_extensions_state() {
  _impl_.offstore_extensions_state_ = 0;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline ::metrics::SystemProfileProto_ExtensionsState SystemProfileProto::_internal_offstore_extensions_state() const {
  return static_cast< ::metrics::SystemProfileProto_ExtensionsState >(_impl_.offstore_extensions_state_);
}
inline ::metrics::SystemProfileProto_ExtensionsState SystemProfileProto::offstore_extensions_state() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.offstore_extensions_state)
  return _internal_offstore_extensions_state();
}
inline void SystemProfileProto::_internal_set_offstore_extensions_state(::metrics::SystemProfileProto_ExtensionsState value) {
  assert(::metrics::SystemProfileProto_ExtensionsState_IsValid(value));
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.offstore_extensions_state_ = value;
}
inline void SystemProfileProto::set_offstore_extensions_state(::metrics::SystemProfileProto_ExtensionsState value) {
  _internal_set_offstore_extensions_state(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.offstore_extensions_state)
}

// optional .metrics.SystemProfileProto.UmaDefaultState uma_default_state = 22;
inline bool SystemProfileProto::_internal_has_uma_default_state() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool SystemProfileProto::has_uma_default_state() const {
  return _internal_has_uma_default_state();
}
inline void SystemProfileProto::clear_uma_default_state() {
  _impl_.uma_default_state_ = 0;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline ::metrics::SystemProfileProto_UmaDefaultState SystemProfileProto::_internal_uma_default_state() const {
  return static_cast< ::metrics::SystemProfileProto_UmaDefaultState >(_impl_.uma_default_state_);
}
inline ::metrics::SystemProfileProto_UmaDefaultState SystemProfileProto::uma_default_state() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.uma_default_state)
  return _internal_uma_default_state();
}
inline void SystemProfileProto::_internal_set_uma_default_state(::metrics::SystemProfileProto_UmaDefaultState value) {
  assert(::metrics::SystemProfileProto_UmaDefaultState_IsValid(value));
  _impl_._has_bits_[0] |= 0x00400000u;
  _impl_.uma_default_state_ = value;
}
inline void SystemProfileProto::set_uma_default_state(::metrics::SystemProfileProto_UmaDefaultState value) {
  _internal_set_uma_default_state(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.uma_default_state)
}

// repeated .metrics.SystemProfileProto.AntiVirusProduct antivirus_product = 23;
inline int SystemProfileProto::_internal_antivirus_product_size() const {
  return _impl_.antivirus_product_.size();
}
inline int SystemProfileProto::antivirus_product_size() const {
  return _internal_antivirus_product_size();
}
inline void SystemProfileProto::clear_antivirus_product() {
  _impl_.antivirus_product_.Clear();
}
inline ::metrics::SystemProfileProto_AntiVirusProduct* SystemProfileProto::mutable_antivirus_product(int index) {
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.antivirus_product)
  return _impl_.antivirus_product_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_AntiVirusProduct >*
SystemProfileProto::mutable_antivirus_product() {
  // @@protoc_insertion_point(field_mutable_list:metrics.SystemProfileProto.antivirus_product)
  return &_impl_.antivirus_product_;
}
inline const ::metrics::SystemProfileProto_AntiVirusProduct& SystemProfileProto::_internal_antivirus_product(int index) const {
  return _impl_.antivirus_product_.Get(index);
}
inline const ::metrics::SystemProfileProto_AntiVirusProduct& SystemProfileProto::antivirus_product(int index) const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.antivirus_product)
  return _internal_antivirus_product(index);
}
inline ::metrics::SystemProfileProto_AntiVirusProduct* SystemProfileProto::_internal_add_antivirus_product() {
  return _impl_.antivirus_product_.Add();
}
inline ::metrics::SystemProfileProto_AntiVirusProduct* SystemProfileProto::add_antivirus_product() {
  ::metrics::SystemProfileProto_AntiVirusProduct* _add = _internal_add_antivirus_product();
  // @@protoc_insertion_point(field_add:metrics.SystemProfileProto.antivirus_product)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_AntiVirusProduct >&
SystemProfileProto::antivirus_product() const {
  // @@protoc_insertion_point(field_list:metrics.SystemProfileProto.antivirus_product)
  return _impl_.antivirus_product_;
}

// repeated .metrics.SystemProfileProto.ChromeComponent chrome_component = 24;
inline int SystemProfileProto::_internal_chrome_component_size() const {
  return _impl_.chrome_component_.size();
}
inline int SystemProfileProto::chrome_component_size() const {
  return _internal_chrome_component_size();
}
inline void SystemProfileProto::clear_chrome_component() {
  _impl_.chrome_component_.Clear();
}
inline ::metrics::SystemProfileProto_ChromeComponent* SystemProfileProto::mutable_chrome_component(int index) {
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.chrome_component)
  return _impl_.chrome_component_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ChromeComponent >*
SystemProfileProto::mutable_chrome_component() {
  // @@protoc_insertion_point(field_mutable_list:metrics.SystemProfileProto.chrome_component)
  return &_impl_.chrome_component_;
}
inline const ::metrics::SystemProfileProto_ChromeComponent& SystemProfileProto::_internal_chrome_component(int index) const {
  return _impl_.chrome_component_.Get(index);
}
inline const ::metrics::SystemProfileProto_ChromeComponent& SystemProfileProto::chrome_component(int index) const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.chrome_component)
  return _internal_chrome_component(index);
}
inline ::metrics::SystemProfileProto_ChromeComponent* SystemProfileProto::_internal_add_chrome_component() {
  return _impl_.chrome_component_.Add();
}
inline ::metrics::SystemProfileProto_ChromeComponent* SystemProfileProto::add_chrome_component() {
  ::metrics::SystemProfileProto_ChromeComponent* _add = _internal_add_chrome_component();
  // @@protoc_insertion_point(field_add:metrics.SystemProfileProto.chrome_component)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::SystemProfileProto_ChromeComponent >&
SystemProfileProto::chrome_component() const {
  // @@protoc_insertion_point(field_list:metrics.SystemProfileProto.chrome_component)
  return _impl_.chrome_component_;
}

// repeated .metrics.ExtensionInstallProto extension_install = 25;
inline int SystemProfileProto::_internal_extension_install_size() const {
  return _impl_.extension_install_.size();
}
inline int SystemProfileProto::extension_install_size() const {
  return _internal_extension_install_size();
}
inline ::metrics::ExtensionInstallProto* SystemProfileProto::mutable_extension_install(int index) {
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.extension_install)
  return _impl_.extension_install_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::ExtensionInstallProto >*
SystemProfileProto::mutable_extension_install() {
  // @@protoc_insertion_point(field_mutable_list:metrics.SystemProfileProto.extension_install)
  return &_impl_.extension_install_;
}
inline const ::metrics::ExtensionInstallProto& SystemProfileProto::_internal_extension_install(int index) const {
  return _impl_.extension_install_.Get(index);
}
inline const ::metrics::ExtensionInstallProto& SystemProfileProto::extension_install(int index) const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.extension_install)
  return _internal_extension_install(index);
}
inline ::metrics::ExtensionInstallProto* SystemProfileProto::_internal_add_extension_install() {
  return _impl_.extension_install_.Add();
}
inline ::metrics::ExtensionInstallProto* SystemProfileProto::add_extension_install() {
  ::metrics::ExtensionInstallProto* _add = _internal_add_extension_install();
  // @@protoc_insertion_point(field_add:metrics.SystemProfileProto.extension_install)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::metrics::ExtensionInstallProto >&
SystemProfileProto::extension_install() const {
  // @@protoc_insertion_point(field_list:metrics.SystemProfileProto.extension_install)
  return _impl_.extension_install_;
}

// optional string app_package_name = 26;
inline bool SystemProfileProto::_internal_has_app_package_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SystemProfileProto::has_app_package_name() const {
  return _internal_has_app_package_name();
}
inline void SystemProfileProto::clear_app_package_name() {
  _impl_.app_package_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& SystemProfileProto::app_package_name() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.app_package_name)
  return _internal_app_package_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SystemProfileProto::set_app_package_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.app_package_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.app_package_name)
}
inline std::string* SystemProfileProto::mutable_app_package_name() {
  std::string* _s = _internal_mutable_app_package_name();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.app_package_name)
  return _s;
}
inline const std::string& SystemProfileProto::_internal_app_package_name() const {
  return _impl_.app_package_name_.Get();
}
inline void SystemProfileProto::_internal_set_app_package_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.app_package_name_.Set(value, GetArenaForAllocation());
}
inline std::string* SystemProfileProto::_internal_mutable_app_package_name() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.app_package_name_.Mutable(GetArenaForAllocation());
}
inline std::string* SystemProfileProto::release_app_package_name() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.app_package_name)
  if (!_internal_has_app_package_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.app_package_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.app_package_name_.IsDefault()) {
    _impl_.app_package_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SystemProfileProto::set_allocated_app_package_name(std::string* app_package_name) {
  if (app_package_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.app_package_name_.SetAllocated(app_package_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.app_package_name_.IsDefault()) {
    _impl_.app_package_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.app_package_name)
}

// optional .metrics.SystemProfileProto.AppPackageNameAllowlistFilter app_package_name_allowlist_filter = 42;
inline bool SystemProfileProto::_internal_has_app_package_name_allowlist_filter() const {
  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
  return value;
}
inline bool SystemProfileProto::has_app_package_name_allowlist_filter() const {
  return _internal_has_app_package_name_allowlist_filter();
}
inline void SystemProfileProto::clear_app_package_name_allowlist_filter() {
  _impl_.app_package_name_allowlist_filter_ = 0;
  _impl_._has_bits_[0] &= ~0x40000000u;
}
inline ::metrics::SystemProfileProto_AppPackageNameAllowlistFilter SystemProfileProto::_internal_app_package_name_allowlist_filter() const {
  return static_cast< ::metrics::SystemProfileProto_AppPackageNameAllowlistFilter >(_impl_.app_package_name_allowlist_filter_);
}
inline ::metrics::SystemProfileProto_AppPackageNameAllowlistFilter SystemProfileProto::app_package_name_allowlist_filter() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.app_package_name_allowlist_filter)
  return _internal_app_package_name_allowlist_filter();
}
inline void SystemProfileProto::_internal_set_app_package_name_allowlist_filter(::metrics::SystemProfileProto_AppPackageNameAllowlistFilter value) {
  assert(::metrics::SystemProfileProto_AppPackageNameAllowlistFilter_IsValid(value));
  _impl_._has_bits_[0] |= 0x40000000u;
  _impl_.app_package_name_allowlist_filter_ = value;
}
inline void SystemProfileProto::set_app_package_name_allowlist_filter(::metrics::SystemProfileProto_AppPackageNameAllowlistFilter value) {
  _internal_set_app_package_name_allowlist_filter(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.app_package_name_allowlist_filter)
}

// optional .metrics.SystemProfileProto.ClientSideSamplingStatus client_side_sampling_status = 43;
inline bool SystemProfileProto::_internal_has_client_side_sampling_status() const {
  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
  return value;
}
inline bool SystemProfileProto::has_client_side_sampling_status() const {
  return _internal_has_client_side_sampling_status();
}
inline void SystemProfileProto::clear_client_side_sampling_status() {
  _impl_.client_side_sampling_status_ = 0;
  _impl_._has_bits_[0] &= ~0x80000000u;
}
inline ::metrics::SystemProfileProto_ClientSideSamplingStatus SystemProfileProto::_internal_client_side_sampling_status() const {
  return static_cast< ::metrics::SystemProfileProto_ClientSideSamplingStatus >(_impl_.client_side_sampling_status_);
}
inline ::metrics::SystemProfileProto_ClientSideSamplingStatus SystemProfileProto::client_side_sampling_status() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.client_side_sampling_status)
  return _internal_client_side_sampling_status();
}
inline void SystemProfileProto::_internal_set_client_side_sampling_status(::metrics::SystemProfileProto_ClientSideSamplingStatus value) {
  assert(::metrics::SystemProfileProto_ClientSideSamplingStatus_IsValid(value));
  _impl_._has_bits_[0] |= 0x80000000u;
  _impl_.client_side_sampling_status_ = value;
}
inline void SystemProfileProto::set_client_side_sampling_status(::metrics::SystemProfileProto_ClientSideSamplingStatus value) {
  _internal_set_client_side_sampling_status(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.client_side_sampling_status)
}

// optional .metrics.SystemProfileProto.MetricsFilteringStatus metrics_filtering_status = 44;
inline bool SystemProfileProto::_internal_has_metrics_filtering_status() const {
  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
  return value;
}
inline bool SystemProfileProto::has_metrics_filtering_status() const {
  return _internal_has_metrics_filtering_status();
}
inline void SystemProfileProto::clear_metrics_filtering_status() {
  _impl_.metrics_filtering_status_ = 0;
  _impl_._has_bits_[1] &= ~0x00000001u;
}
inline ::metrics::SystemProfileProto_MetricsFilteringStatus SystemProfileProto::_internal_metrics_filtering_status() const {
  return static_cast< ::metrics::SystemProfileProto_MetricsFilteringStatus >(_impl_.metrics_filtering_status_);
}
inline ::metrics::SystemProfileProto_MetricsFilteringStatus SystemProfileProto::metrics_filtering_status() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.metrics_filtering_status)
  return _internal_metrics_filtering_status();
}
inline void SystemProfileProto::_internal_set_metrics_filtering_status(::metrics::SystemProfileProto_MetricsFilteringStatus value) {
  assert(::metrics::SystemProfileProto_MetricsFilteringStatus_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000001u;
  _impl_.metrics_filtering_status_ = value;
}
inline void SystemProfileProto::set_metrics_filtering_status(::metrics::SystemProfileProto_MetricsFilteringStatus value) {
  _internal_set_metrics_filtering_status(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.metrics_filtering_status)
}

// optional .metrics.SystemProfileProto.InstallerPackage installer_package = 35;
inline bool SystemProfileProto::_internal_has_installer_package() const {
  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
  return value;
}
inline bool SystemProfileProto::has_installer_package() const {
  return _internal_has_installer_package();
}
inline void SystemProfileProto::clear_installer_package() {
  _impl_.installer_package_ = 0;
  _impl_._has_bits_[0] &= ~0x10000000u;
}
inline ::metrics::SystemProfileProto_InstallerPackage SystemProfileProto::_internal_installer_package() const {
  return static_cast< ::metrics::SystemProfileProto_InstallerPackage >(_impl_.installer_package_);
}
inline ::metrics::SystemProfileProto_InstallerPackage SystemProfileProto::installer_package() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.installer_package)
  return _internal_installer_package();
}
inline void SystemProfileProto::_internal_set_installer_package(::metrics::SystemProfileProto_InstallerPackage value) {
  assert(::metrics::SystemProfileProto_InstallerPackage_IsValid(value));
  _impl_._has_bits_[0] |= 0x10000000u;
  _impl_.installer_package_ = value;
}
inline void SystemProfileProto::set_installer_package(::metrics::SystemProfileProto_InstallerPackage value) {
  _internal_set_installer_package(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.installer_package)
}

// optional .metrics.SystemProfileProto.LinkedAndroidPhoneData linked_android_phone_data = 29;
inline bool SystemProfileProto::_internal_has_linked_android_phone_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.linked_android_phone_data_ != nullptr);
  return value;
}
inline bool SystemProfileProto::has_linked_android_phone_data() const {
  return _internal_has_linked_android_phone_data();
}
inline void SystemProfileProto::clear_linked_android_phone_data() {
  if (_impl_.linked_android_phone_data_ != nullptr) _impl_.linked_android_phone_data_->Clear();
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline const ::metrics::SystemProfileProto_LinkedAndroidPhoneData& SystemProfileProto::_internal_linked_android_phone_data() const {
  const ::metrics::SystemProfileProto_LinkedAndroidPhoneData* p = _impl_.linked_android_phone_data_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_LinkedAndroidPhoneData&>(
      ::metrics::_SystemProfileProto_LinkedAndroidPhoneData_default_instance_);
}
inline const ::metrics::SystemProfileProto_LinkedAndroidPhoneData& SystemProfileProto::linked_android_phone_data() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.linked_android_phone_data)
  return _internal_linked_android_phone_data();
}
inline void SystemProfileProto::unsafe_arena_set_allocated_linked_android_phone_data(
    ::metrics::SystemProfileProto_LinkedAndroidPhoneData* linked_android_phone_data) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.linked_android_phone_data_);
  }
  _impl_.linked_android_phone_data_ = linked_android_phone_data;
  if (linked_android_phone_data) {
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.linked_android_phone_data)
}
inline ::metrics::SystemProfileProto_LinkedAndroidPhoneData* SystemProfileProto::release_linked_android_phone_data() {
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::metrics::SystemProfileProto_LinkedAndroidPhoneData* temp = _impl_.linked_android_phone_data_;
  _impl_.linked_android_phone_data_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_LinkedAndroidPhoneData* SystemProfileProto::unsafe_arena_release_linked_android_phone_data() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.linked_android_phone_data)
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::metrics::SystemProfileProto_LinkedAndroidPhoneData* temp = _impl_.linked_android_phone_data_;
  _impl_.linked_android_phone_data_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_LinkedAndroidPhoneData* SystemProfileProto::_internal_mutable_linked_android_phone_data() {
  _impl_._has_bits_[0] |= 0x00002000u;
  if (_impl_.linked_android_phone_data_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_LinkedAndroidPhoneData>(GetArenaForAllocation());
    _impl_.linked_android_phone_data_ = p;
  }
  return _impl_.linked_android_phone_data_;
}
inline ::metrics::SystemProfileProto_LinkedAndroidPhoneData* SystemProfileProto::mutable_linked_android_phone_data() {
  ::metrics::SystemProfileProto_LinkedAndroidPhoneData* _msg = _internal_mutable_linked_android_phone_data();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.linked_android_phone_data)
  return _msg;
}
inline void SystemProfileProto::set_allocated_linked_android_phone_data(::metrics::SystemProfileProto_LinkedAndroidPhoneData* linked_android_phone_data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.linked_android_phone_data_;
  }
  if (linked_android_phone_data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(linked_android_phone_data);
    if (message_arena != submessage_arena) {
      linked_android_phone_data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, linked_android_phone_data, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  _impl_.linked_android_phone_data_ = linked_android_phone_data;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.linked_android_phone_data)
}

// optional .metrics.SystemProfileProto.DemoModeDimensions demo_mode_dimensions = 41;
inline bool SystemProfileProto::_internal_has_demo_mode_dimensions() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.demo_mode_dimensions_ != nullptr);
  return value;
}
inline bool SystemProfileProto::has_demo_mode_dimensions() const {
  return _internal_has_demo_mode_dimensions();
}
inline void SystemProfileProto::clear_demo_mode_dimensions() {
  if (_impl_.demo_mode_dimensions_ != nullptr) _impl_.demo_mode_dimensions_->Clear();
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline const ::metrics::SystemProfileProto_DemoModeDimensions& SystemProfileProto::_internal_demo_mode_dimensions() const {
  const ::metrics::SystemProfileProto_DemoModeDimensions* p = _impl_.demo_mode_dimensions_;
  return p != nullptr ? *p : reinterpret_cast<const ::metrics::SystemProfileProto_DemoModeDimensions&>(
      ::metrics::_SystemProfileProto_DemoModeDimensions_default_instance_);
}
inline const ::metrics::SystemProfileProto_DemoModeDimensions& SystemProfileProto::demo_mode_dimensions() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.demo_mode_dimensions)
  return _internal_demo_mode_dimensions();
}
inline void SystemProfileProto::unsafe_arena_set_allocated_demo_mode_dimensions(
    ::metrics::SystemProfileProto_DemoModeDimensions* demo_mode_dimensions) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.demo_mode_dimensions_);
  }
  _impl_.demo_mode_dimensions_ = demo_mode_dimensions;
  if (demo_mode_dimensions) {
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:metrics.SystemProfileProto.demo_mode_dimensions)
}
inline ::metrics::SystemProfileProto_DemoModeDimensions* SystemProfileProto::release_demo_mode_dimensions() {
  _impl_._has_bits_[0] &= ~0x00008000u;
  ::metrics::SystemProfileProto_DemoModeDimensions* temp = _impl_.demo_mode_dimensions_;
  _impl_.demo_mode_dimensions_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::metrics::SystemProfileProto_DemoModeDimensions* SystemProfileProto::unsafe_arena_release_demo_mode_dimensions() {
  // @@protoc_insertion_point(field_release:metrics.SystemProfileProto.demo_mode_dimensions)
  _impl_._has_bits_[0] &= ~0x00008000u;
  ::metrics::SystemProfileProto_DemoModeDimensions* temp = _impl_.demo_mode_dimensions_;
  _impl_.demo_mode_dimensions_ = nullptr;
  return temp;
}
inline ::metrics::SystemProfileProto_DemoModeDimensions* SystemProfileProto::_internal_mutable_demo_mode_dimensions() {
  _impl_._has_bits_[0] |= 0x00008000u;
  if (_impl_.demo_mode_dimensions_ == nullptr) {
    auto* p = CreateMaybeMessage<::metrics::SystemProfileProto_DemoModeDimensions>(GetArenaForAllocation());
    _impl_.demo_mode_dimensions_ = p;
  }
  return _impl_.demo_mode_dimensions_;
}
inline ::metrics::SystemProfileProto_DemoModeDimensions* SystemProfileProto::mutable_demo_mode_dimensions() {
  ::metrics::SystemProfileProto_DemoModeDimensions* _msg = _internal_mutable_demo_mode_dimensions();
  // @@protoc_insertion_point(field_mutable:metrics.SystemProfileProto.demo_mode_dimensions)
  return _msg;
}
inline void SystemProfileProto::set_allocated_demo_mode_dimensions(::metrics::SystemProfileProto_DemoModeDimensions* demo_mode_dimensions) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.demo_mode_dimensions_;
  }
  if (demo_mode_dimensions) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(demo_mode_dimensions);
    if (message_arena != submessage_arena) {
      demo_mode_dimensions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, demo_mode_dimensions, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  _impl_.demo_mode_dimensions_ = demo_mode_dimensions;
  // @@protoc_insertion_point(field_set_allocated:metrics.SystemProfileProto.demo_mode_dimensions)
}

// optional .metrics.SystemProfileProto.LTSChannel lts_channel = 45;
inline bool SystemProfileProto::_internal_has_lts_channel() const {
  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
  return value;
}
inline bool SystemProfileProto::has_lts_channel() const {
  return _internal_has_lts_channel();
}
inline void SystemProfileProto::clear_lts_channel() {
  _impl_.lts_channel_ = 0;
  _impl_._has_bits_[1] &= ~0x00000004u;
}
inline ::metrics::SystemProfileProto_LTSChannel SystemProfileProto::_internal_lts_channel() const {
  return static_cast< ::metrics::SystemProfileProto_LTSChannel >(_impl_.lts_channel_);
}
inline ::metrics::SystemProfileProto_LTSChannel SystemProfileProto::lts_channel() const {
  // @@protoc_insertion_point(field_get:metrics.SystemProfileProto.lts_channel)
  return _internal_lts_channel();
}
inline void SystemProfileProto::_internal_set_lts_channel(::metrics::SystemProfileProto_LTSChannel value) {
  assert(::metrics::SystemProfileProto_LTSChannel_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000004u;
  _impl_.lts_channel_ = value;
}
inline void SystemProfileProto::set_lts_channel(::metrics::SystemProfileProto_LTSChannel value) {
  _internal_set_lts_channel(value);
  // @@protoc_insertion_point(field_set:metrics.SystemProfileProto.lts_channel)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace metrics

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::metrics::SystemProfileProto_OS_DarkModeState> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_OS_XdgSessionType> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_OS_XdgCurrentDesktop> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Type> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Hardware_InternalStorageDevice_Purpose> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Hardware_FormFactor> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Hardware_BiosType> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Hardware_TpmType> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Network_ConnectionType> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Network_WifiPHYLayerProtocol> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Network_EffectiveConnectionType> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_GoogleUpdate_ProductInfo_InstallResult> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_AudioFormat> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AudioDescription_OutputMode> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_AVDeviceType> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_ExternalAudioVideoDevice_ColorEncoding> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_DemoModeDimensions_CustomizationFacet> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_Channel> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_ExtensionsState> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_UmaDefaultState> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_AntiVirusState> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_ComponentId> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_AppPackageNameAllowlistFilter> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_ClientSideSamplingStatus> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_MetricsFilteringStatus> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_InstallerPackage> : ::std::true_type {};
template <> struct is_proto_enum< ::metrics::SystemProfileProto_LTSChannel> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_system_5fprofile_2eproto