// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: tensorflow/compiler/xla/service/hlo.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_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 3021009 < 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/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/map.h>  // IWYU pragma: export
#include <google/protobuf/map_entry.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "tensorflow/compiler/xla/xla_data.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
namespace xla {
class BufferAllocationProto;
struct BufferAllocationProtoDefaultTypeInternal;
extern BufferAllocationProtoDefaultTypeInternal _BufferAllocationProto_default_instance_;
class BufferAllocationProto_Assigned;
struct BufferAllocationProto_AssignedDefaultTypeInternal;
extern BufferAllocationProto_AssignedDefaultTypeInternal _BufferAllocationProto_Assigned_default_instance_;
class BufferAssignmentProto;
struct BufferAssignmentProtoDefaultTypeInternal;
extern BufferAssignmentProtoDefaultTypeInternal _BufferAssignmentProto_default_instance_;
class BufferAssignmentProto_BufferAlias;
struct BufferAssignmentProto_BufferAliasDefaultTypeInternal;
extern BufferAssignmentProto_BufferAliasDefaultTypeInternal _BufferAssignmentProto_BufferAlias_default_instance_;
class CrossProgramPrefetch;
struct CrossProgramPrefetchDefaultTypeInternal;
extern CrossProgramPrefetchDefaultTypeInternal _CrossProgramPrefetch_default_instance_;
class DynamicParameterBindingProto;
struct DynamicParameterBindingProtoDefaultTypeInternal;
extern DynamicParameterBindingProtoDefaultTypeInternal _DynamicParameterBindingProto_default_instance_;
class DynamicParameterBindingProto_Binding;
struct DynamicParameterBindingProto_BindingDefaultTypeInternal;
extern DynamicParameterBindingProto_BindingDefaultTypeInternal _DynamicParameterBindingProto_Binding_default_instance_;
class EntryFunctionAttributes;
struct EntryFunctionAttributesDefaultTypeInternal;
extern EntryFunctionAttributesDefaultTypeInternal _EntryFunctionAttributes_default_instance_;
class EntryFunctionAttributes_BufferParameterAttributes;
struct EntryFunctionAttributes_BufferParameterAttributesDefaultTypeInternal;
extern EntryFunctionAttributes_BufferParameterAttributesDefaultTypeInternal _EntryFunctionAttributes_BufferParameterAttributes_default_instance_;
class EntryFunctionAttributes_ShapeIndex;
struct EntryFunctionAttributes_ShapeIndexDefaultTypeInternal;
extern EntryFunctionAttributes_ShapeIndexDefaultTypeInternal _EntryFunctionAttributes_ShapeIndex_default_instance_;
class HeapSimulatorTrace;
struct HeapSimulatorTraceDefaultTypeInternal;
extern HeapSimulatorTraceDefaultTypeInternal _HeapSimulatorTrace_default_instance_;
class HeapSimulatorTrace_Event;
struct HeapSimulatorTrace_EventDefaultTypeInternal;
extern HeapSimulatorTrace_EventDefaultTypeInternal _HeapSimulatorTrace_Event_default_instance_;
class HloComputationProto;
struct HloComputationProtoDefaultTypeInternal;
extern HloComputationProtoDefaultTypeInternal _HloComputationProto_default_instance_;
class HloInputOutputAliasProto;
struct HloInputOutputAliasProtoDefaultTypeInternal;
extern HloInputOutputAliasProtoDefaultTypeInternal _HloInputOutputAliasProto_default_instance_;
class HloInputOutputAliasProto_AliasEntryProto;
struct HloInputOutputAliasProto_AliasEntryProtoDefaultTypeInternal;
extern HloInputOutputAliasProto_AliasEntryProtoDefaultTypeInternal _HloInputOutputAliasProto_AliasEntryProto_default_instance_;
class HloInstructionProto;
struct HloInstructionProtoDefaultTypeInternal;
extern HloInstructionProtoDefaultTypeInternal _HloInstructionProto_default_instance_;
class HloInstructionProto_SliceDimensions;
struct HloInstructionProto_SliceDimensionsDefaultTypeInternal;
extern HloInstructionProto_SliceDimensionsDefaultTypeInternal _HloInstructionProto_SliceDimensions_default_instance_;
class HloModuleGroupProto;
struct HloModuleGroupProtoDefaultTypeInternal;
extern HloModuleGroupProtoDefaultTypeInternal _HloModuleGroupProto_default_instance_;
class HloModuleMetadataProto;
struct HloModuleMetadataProtoDefaultTypeInternal;
extern HloModuleMetadataProtoDefaultTypeInternal _HloModuleMetadataProto_default_instance_;
class HloModuleProto;
struct HloModuleProtoDefaultTypeInternal;
extern HloModuleProtoDefaultTypeInternal _HloModuleProto_default_instance_;
class HloModuleProto_ProfileInfo;
struct HloModuleProto_ProfileInfoDefaultTypeInternal;
extern HloModuleProto_ProfileInfoDefaultTypeInternal _HloModuleProto_ProfileInfo_default_instance_;
class HloPassMetadata;
struct HloPassMetadataDefaultTypeInternal;
extern HloPassMetadataDefaultTypeInternal _HloPassMetadata_default_instance_;
class HloProto;
struct HloProtoDefaultTypeInternal;
extern HloProtoDefaultTypeInternal _HloProto_default_instance_;
class HloScheduleProto;
struct HloScheduleProtoDefaultTypeInternal;
extern HloScheduleProtoDefaultTypeInternal _HloScheduleProto_default_instance_;
class HloScheduleProto_InstructionSequence;
struct HloScheduleProto_InstructionSequenceDefaultTypeInternal;
extern HloScheduleProto_InstructionSequenceDefaultTypeInternal _HloScheduleProto_InstructionSequence_default_instance_;
class HloScheduleProto_SequencesEntry_DoNotUse;
struct HloScheduleProto_SequencesEntry_DoNotUseDefaultTypeInternal;
extern HloScheduleProto_SequencesEntry_DoNotUseDefaultTypeInternal _HloScheduleProto_SequencesEntry_DoNotUse_default_instance_;
class HloSnapshot;
struct HloSnapshotDefaultTypeInternal;
extern HloSnapshotDefaultTypeInternal _HloSnapshot_default_instance_;
class LogicalBufferProto;
struct LogicalBufferProtoDefaultTypeInternal;
extern LogicalBufferProtoDefaultTypeInternal _LogicalBufferProto_default_instance_;
class LogicalBufferProto_Location;
struct LogicalBufferProto_LocationDefaultTypeInternal;
extern LogicalBufferProto_LocationDefaultTypeInternal _LogicalBufferProto_Location_default_instance_;
class XlaRuntimeExecutableProto;
struct XlaRuntimeExecutableProtoDefaultTypeInternal;
extern XlaRuntimeExecutableProtoDefaultTypeInternal _XlaRuntimeExecutableProto_default_instance_;
}  // namespace xla
PROTOBUF_NAMESPACE_OPEN
template<> ::xla::BufferAllocationProto* Arena::CreateMaybeMessage<::xla::BufferAllocationProto>(Arena*);
template<> ::xla::BufferAllocationProto_Assigned* Arena::CreateMaybeMessage<::xla::BufferAllocationProto_Assigned>(Arena*);
template<> ::xla::BufferAssignmentProto* Arena::CreateMaybeMessage<::xla::BufferAssignmentProto>(Arena*);
template<> ::xla::BufferAssignmentProto_BufferAlias* Arena::CreateMaybeMessage<::xla::BufferAssignmentProto_BufferAlias>(Arena*);
template<> ::xla::CrossProgramPrefetch* Arena::CreateMaybeMessage<::xla::CrossProgramPrefetch>(Arena*);
template<> ::xla::DynamicParameterBindingProto* Arena::CreateMaybeMessage<::xla::DynamicParameterBindingProto>(Arena*);
template<> ::xla::DynamicParameterBindingProto_Binding* Arena::CreateMaybeMessage<::xla::DynamicParameterBindingProto_Binding>(Arena*);
template<> ::xla::EntryFunctionAttributes* Arena::CreateMaybeMessage<::xla::EntryFunctionAttributes>(Arena*);
template<> ::xla::EntryFunctionAttributes_BufferParameterAttributes* Arena::CreateMaybeMessage<::xla::EntryFunctionAttributes_BufferParameterAttributes>(Arena*);
template<> ::xla::EntryFunctionAttributes_ShapeIndex* Arena::CreateMaybeMessage<::xla::EntryFunctionAttributes_ShapeIndex>(Arena*);
template<> ::xla::HeapSimulatorTrace* Arena::CreateMaybeMessage<::xla::HeapSimulatorTrace>(Arena*);
template<> ::xla::HeapSimulatorTrace_Event* Arena::CreateMaybeMessage<::xla::HeapSimulatorTrace_Event>(Arena*);
template<> ::xla::HloComputationProto* Arena::CreateMaybeMessage<::xla::HloComputationProto>(Arena*);
template<> ::xla::HloInputOutputAliasProto* Arena::CreateMaybeMessage<::xla::HloInputOutputAliasProto>(Arena*);
template<> ::xla::HloInputOutputAliasProto_AliasEntryProto* Arena::CreateMaybeMessage<::xla::HloInputOutputAliasProto_AliasEntryProto>(Arena*);
template<> ::xla::HloInstructionProto* Arena::CreateMaybeMessage<::xla::HloInstructionProto>(Arena*);
template<> ::xla::HloInstructionProto_SliceDimensions* Arena::CreateMaybeMessage<::xla::HloInstructionProto_SliceDimensions>(Arena*);
template<> ::xla::HloModuleGroupProto* Arena::CreateMaybeMessage<::xla::HloModuleGroupProto>(Arena*);
template<> ::xla::HloModuleMetadataProto* Arena::CreateMaybeMessage<::xla::HloModuleMetadataProto>(Arena*);
template<> ::xla::HloModuleProto* Arena::CreateMaybeMessage<::xla::HloModuleProto>(Arena*);
template<> ::xla::HloModuleProto_ProfileInfo* Arena::CreateMaybeMessage<::xla::HloModuleProto_ProfileInfo>(Arena*);
template<> ::xla::HloPassMetadata* Arena::CreateMaybeMessage<::xla::HloPassMetadata>(Arena*);
template<> ::xla::HloProto* Arena::CreateMaybeMessage<::xla::HloProto>(Arena*);
template<> ::xla::HloScheduleProto* Arena::CreateMaybeMessage<::xla::HloScheduleProto>(Arena*);
template<> ::xla::HloScheduleProto_InstructionSequence* Arena::CreateMaybeMessage<::xla::HloScheduleProto_InstructionSequence>(Arena*);
template<> ::xla::HloScheduleProto_SequencesEntry_DoNotUse* Arena::CreateMaybeMessage<::xla::HloScheduleProto_SequencesEntry_DoNotUse>(Arena*);
template<> ::xla::HloSnapshot* Arena::CreateMaybeMessage<::xla::HloSnapshot>(Arena*);
template<> ::xla::LogicalBufferProto* Arena::CreateMaybeMessage<::xla::LogicalBufferProto>(Arena*);
template<> ::xla::LogicalBufferProto_Location* Arena::CreateMaybeMessage<::xla::LogicalBufferProto_Location>(Arena*);
template<> ::xla::XlaRuntimeExecutableProto* Arena::CreateMaybeMessage<::xla::XlaRuntimeExecutableProto>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace xla {

enum HloModuleProto_ProfileType : int {
  HloModuleProto_ProfileType_INVALID = 0,
  HloModuleProto_ProfileType_FLAG = 1,
  HloModuleProto_ProfileType_FUSION = 2,
  HloModuleProto_ProfileType_LAYOUT = 3,
  HloModuleProto_ProfileType_DOT = 4,
  HloModuleProto_ProfileType_HloModuleProto_ProfileType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  HloModuleProto_ProfileType_HloModuleProto_ProfileType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool HloModuleProto_ProfileType_IsValid(int value);
constexpr HloModuleProto_ProfileType HloModuleProto_ProfileType_ProfileType_MIN = HloModuleProto_ProfileType_INVALID;
constexpr HloModuleProto_ProfileType HloModuleProto_ProfileType_ProfileType_MAX = HloModuleProto_ProfileType_DOT;
constexpr int HloModuleProto_ProfileType_ProfileType_ARRAYSIZE = HloModuleProto_ProfileType_ProfileType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HloModuleProto_ProfileType_descriptor();
template<typename T>
inline const std::string& HloModuleProto_ProfileType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, HloModuleProto_ProfileType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function HloModuleProto_ProfileType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    HloModuleProto_ProfileType_descriptor(), enum_t_value);
}
inline bool HloModuleProto_ProfileType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HloModuleProto_ProfileType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HloModuleProto_ProfileType>(
    HloModuleProto_ProfileType_descriptor(), name, value);
}
enum HeapSimulatorTrace_Event_Kind : int {
  HeapSimulatorTrace_Event_Kind_ALLOC = 0,
  HeapSimulatorTrace_Event_Kind_FREE = 1,
  HeapSimulatorTrace_Event_Kind_SHARE_WITH = 2,
  HeapSimulatorTrace_Event_Kind_HeapSimulatorTrace_Event_Kind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  HeapSimulatorTrace_Event_Kind_HeapSimulatorTrace_Event_Kind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool HeapSimulatorTrace_Event_Kind_IsValid(int value);
constexpr HeapSimulatorTrace_Event_Kind HeapSimulatorTrace_Event_Kind_Kind_MIN = HeapSimulatorTrace_Event_Kind_ALLOC;
constexpr HeapSimulatorTrace_Event_Kind HeapSimulatorTrace_Event_Kind_Kind_MAX = HeapSimulatorTrace_Event_Kind_SHARE_WITH;
constexpr int HeapSimulatorTrace_Event_Kind_Kind_ARRAYSIZE = HeapSimulatorTrace_Event_Kind_Kind_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HeapSimulatorTrace_Event_Kind_descriptor();
template<typename T>
inline const std::string& HeapSimulatorTrace_Event_Kind_Name(T enum_t_value) {
  static_assert(::std::is_same<T, HeapSimulatorTrace_Event_Kind>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function HeapSimulatorTrace_Event_Kind_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    HeapSimulatorTrace_Event_Kind_descriptor(), enum_t_value);
}
inline bool HeapSimulatorTrace_Event_Kind_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HeapSimulatorTrace_Event_Kind* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HeapSimulatorTrace_Event_Kind>(
    HeapSimulatorTrace_Event_Kind_descriptor(), name, value);
}
enum CustomCallSchedule : int {
  SCHEDULE_NONE = 0,
  SCHEDULE_LATEST = 1,
  SCHEDULE_EARLIEST = 2,
  CustomCallSchedule_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  CustomCallSchedule_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool CustomCallSchedule_IsValid(int value);
constexpr CustomCallSchedule CustomCallSchedule_MIN = SCHEDULE_NONE;
constexpr CustomCallSchedule CustomCallSchedule_MAX = SCHEDULE_EARLIEST;
constexpr int CustomCallSchedule_ARRAYSIZE = CustomCallSchedule_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CustomCallSchedule_descriptor();
template<typename T>
inline const std::string& CustomCallSchedule_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CustomCallSchedule>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CustomCallSchedule_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CustomCallSchedule_descriptor(), enum_t_value);
}
inline bool CustomCallSchedule_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CustomCallSchedule* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CustomCallSchedule>(
    CustomCallSchedule_descriptor(), name, value);
}
enum CustomCallApiVersion : int {
  API_VERSION_UNSPECIFIED = 0,
  API_VERSION_ORIGINAL = 1,
  API_VERSION_STATUS_RETURNING = 2,
  API_VERSION_STATUS_RETURNING_UNIFIED = 3,
  API_VERSION_TYPED_FFI = 4,
  CustomCallApiVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  CustomCallApiVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool CustomCallApiVersion_IsValid(int value);
constexpr CustomCallApiVersion CustomCallApiVersion_MIN = API_VERSION_UNSPECIFIED;
constexpr CustomCallApiVersion CustomCallApiVersion_MAX = API_VERSION_TYPED_FFI;
constexpr int CustomCallApiVersion_ARRAYSIZE = CustomCallApiVersion_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CustomCallApiVersion_descriptor();
template<typename T>
inline const std::string& CustomCallApiVersion_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CustomCallApiVersion>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CustomCallApiVersion_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CustomCallApiVersion_descriptor(), enum_t_value);
}
inline bool CustomCallApiVersion_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CustomCallApiVersion* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CustomCallApiVersion>(
    CustomCallApiVersion_descriptor(), name, value);
}
enum Kind : int {
  UNDEFINED_ALIAS = 0,
  MAY_ALIAS = 1,
  MUST_ALIAS = 2,
  Kind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  Kind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool Kind_IsValid(int value);
constexpr Kind Kind_MIN = UNDEFINED_ALIAS;
constexpr Kind Kind_MAX = MUST_ALIAS;
constexpr int Kind_ARRAYSIZE = Kind_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Kind_descriptor();
template<typename T>
inline const std::string& Kind_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Kind>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Kind_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Kind_descriptor(), enum_t_value);
}
inline bool Kind_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Kind* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Kind>(
    Kind_descriptor(), name, value);
}
// ===================================================================

class HloInstructionProto_SliceDimensions final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.HloInstructionProto.SliceDimensions) */ {
 public:
  inline HloInstructionProto_SliceDimensions() : HloInstructionProto_SliceDimensions(nullptr) {}
  ~HloInstructionProto_SliceDimensions() override;
  explicit PROTOBUF_CONSTEXPR HloInstructionProto_SliceDimensions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline HloInstructionProto_SliceDimensions& operator=(const HloInstructionProto_SliceDimensions& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloInstructionProto_SliceDimensions& operator=(HloInstructionProto_SliceDimensions&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloInstructionProto_SliceDimensions& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloInstructionProto_SliceDimensions* internal_default_instance() {
    return reinterpret_cast<const HloInstructionProto_SliceDimensions*>(
               &_HloInstructionProto_SliceDimensions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(HloInstructionProto_SliceDimensions& a, HloInstructionProto_SliceDimensions& b) {
    a.Swap(&b);
  }
  inline void Swap(HloInstructionProto_SliceDimensions* 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(HloInstructionProto_SliceDimensions* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HloInstructionProto_SliceDimensions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HloInstructionProto_SliceDimensions>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HloInstructionProto_SliceDimensions& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HloInstructionProto_SliceDimensions& from) {
    HloInstructionProto_SliceDimensions::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(HloInstructionProto_SliceDimensions* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kStartFieldNumber = 1,
    kLimitFieldNumber = 2,
    kStrideFieldNumber = 3,
  };
  // int64 start = 1;
  void clear_start();
  int64_t start() const;
  void set_start(int64_t value);
  private:
  int64_t _internal_start() const;
  void _internal_set_start(int64_t value);
  public:

  // int64 limit = 2;
  void clear_limit();
  int64_t limit() const;
  void set_limit(int64_t value);
  private:
  int64_t _internal_limit() const;
  void _internal_set_limit(int64_t value);
  public:

  // int64 stride = 3;
  void clear_stride();
  int64_t stride() const;
  void set_stride(int64_t value);
  private:
  int64_t _internal_stride() const;
  void _internal_set_stride(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:xla.HloInstructionProto.SliceDimensions)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    int64_t start_;
    int64_t limit_;
    int64_t stride_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline HloInstructionProto& operator=(const HloInstructionProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloInstructionProto& operator=(HloInstructionProto&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloInstructionProto& default_instance() {
    return *internal_default_instance();
  }
  enum OptionalCrossProgramPrefetchIndexCase {
    kCrossProgramPrefetchIndex = 80,
    OPTIONAL_CROSS_PROGRAM_PREFETCH_INDEX_NOT_SET = 0,
  };

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

  friend void swap(HloInstructionProto& a, HloInstructionProto& b) {
    a.Swap(&b);
  }
  inline void Swap(HloInstructionProto* 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(HloInstructionProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HloInstructionProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HloInstructionProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HloInstructionProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HloInstructionProto& from) {
    HloInstructionProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(HloInstructionProto* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef HloInstructionProto_SliceDimensions SliceDimensions;

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

  enum : int {
    kDimensionsFieldNumber = 14,
    kSliceDimensionsFieldNumber = 17,
    kDynamicSliceSizesFieldNumber = 20,
    kFftLengthFieldNumber = 32,
    kGatherSliceSizesFieldNumber = 34,
    kOperandIdsFieldNumber = 36,
    kControlPredecessorIdsFieldNumber = 37,
    kCalledComputationIdsFieldNumber = 38,
    kReplicaGroupsFieldNumber = 49,
    kSourceTargetPairsFieldNumber = 52,
    kOperandShapesWithLayoutFieldNumber = 57,
    kOutputOperandAliasingFieldNumber = 74,
    kNameFieldNumber = 1,
    kOpcodeFieldNumber = 2,
    kFusionKindFieldNumber = 11,
    kOutfeedConfigFieldNumber = 22,
    kInfeedConfigFieldNumber = 27,
    kCustomCallTargetFieldNumber = 28,
    kBackendConfigFieldNumber = 43,
    kComparisonDirectionFieldNumber = 63,
    kComparisonTypeFieldNumber = 72,
    kAsyncExecutionThreadFieldNumber = 79,
    kShapeFieldNumber = 3,
    kMetadataFieldNumber = 7,
    kLiteralFieldNumber = 8,
    kWindowFieldNumber = 15,
    kConvolutionDimensionNumbersFieldNumber = 16,
    kPaddingConfigFieldNumber = 21,
    kOutfeedShapeFieldNumber = 29,
    kDotDimensionNumbersFieldNumber = 30,
    kGatherDimensionNumbersFieldNumber = 33,
    kShardingFieldNumber = 40,
    kScatterDimensionNumbersFieldNumber = 48,
    kPrecisionConfigFieldNumber = 51,
    kDomainEntryShardingFieldNumber = 54,
    kDomainExitShardingFieldNumber = 55,
    kTriangularSolveOptionsFieldNumber = 59,
    kParameterReplicationFieldNumber = 61,
    kCholeskyOptionsFieldNumber = 62,
    kFrontendAttributesFieldNumber = 68,
    kParameterNumberFieldNumber = 9,
    kTupleIndexFieldNumber = 13,
    kExponentBitsFieldNumber = 18,
    kMantissaBitsFieldNumber = 19,
    kDistributionFieldNumber = 23,
    kEpsilonFieldNumber = 24,
    kFeatureIndexFieldNumber = 25,
    kChannelIdFieldNumber = 26,
    kIdFieldNumber = 35,
    kAllReduceIdFieldNumber = 45,
    kFeatureGroupCountFieldNumber = 50,
    kFftTypeFieldNumber = 31,
    kUseGlobalDeviceIdsFieldNumber = 71,
    kIsHostTransferFieldNumber = 47,
    kIsStableFieldNumber = 60,
    kConstrainLayoutFieldNumber = 56,
    kBatchGroupCountFieldNumber = 58,
    kDeltaFieldNumber = 66,
    kCustomCallHasSideEffectFieldNumber = 65,
    kIndicesAreSortedFieldNumber = 67,
    kUniqueIndicesFieldNumber = 69,
    kIsCrossProgramPrefetchFieldNumber = 73,
    kRngAlgorithmFieldNumber = 70,
    kPaddingTypeFieldNumber = 75,
    kCustomCallScheduleFieldNumber = 76,
    kAsyncGroupIdFieldNumber = 78,
    kCustomCallApiVersionFieldNumber = 77,
    kCrossProgramPrefetchIndexFieldNumber = 80,
  };
  // repeated int64 dimensions = 14;
  int dimensions_size() const;
  private:
  int _internal_dimensions_size() const;
  public:
  void clear_dimensions();
  private:
  int64_t _internal_dimensions(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_dimensions() const;
  void _internal_add_dimensions(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_dimensions();
  public:
  int64_t dimensions(int index) const;
  void set_dimensions(int index, int64_t value);
  void add_dimensions(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      dimensions() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_dimensions();

  // repeated .xla.HloInstructionProto.SliceDimensions slice_dimensions = 17;
  int slice_dimensions_size() const;
  private:
  int _internal_slice_dimensions_size() const;
  public:
  void clear_slice_dimensions();
  ::xla::HloInstructionProto_SliceDimensions* mutable_slice_dimensions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloInstructionProto_SliceDimensions >*
      mutable_slice_dimensions();
  private:
  const ::xla::HloInstructionProto_SliceDimensions& _internal_slice_dimensions(int index) const;
  ::xla::HloInstructionProto_SliceDimensions* _internal_add_slice_dimensions();
  public:
  const ::xla::HloInstructionProto_SliceDimensions& slice_dimensions(int index) const;
  ::xla::HloInstructionProto_SliceDimensions* add_slice_dimensions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloInstructionProto_SliceDimensions >&
      slice_dimensions() const;

  // repeated int64 dynamic_slice_sizes = 20;
  int dynamic_slice_sizes_size() const;
  private:
  int _internal_dynamic_slice_sizes_size() const;
  public:
  void clear_dynamic_slice_sizes();
  private:
  int64_t _internal_dynamic_slice_sizes(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_dynamic_slice_sizes() const;
  void _internal_add_dynamic_slice_sizes(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_dynamic_slice_sizes();
  public:
  int64_t dynamic_slice_sizes(int index) const;
  void set_dynamic_slice_sizes(int index, int64_t value);
  void add_dynamic_slice_sizes(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      dynamic_slice_sizes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_dynamic_slice_sizes();

  // repeated int64 fft_length = 32;
  int fft_length_size() const;
  private:
  int _internal_fft_length_size() const;
  public:
  void clear_fft_length();
  private:
  int64_t _internal_fft_length(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_fft_length() const;
  void _internal_add_fft_length(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_fft_length();
  public:
  int64_t fft_length(int index) const;
  void set_fft_length(int index, int64_t value);
  void add_fft_length(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      fft_length() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_fft_length();

  // repeated int64 gather_slice_sizes = 34;
  int gather_slice_sizes_size() const;
  private:
  int _internal_gather_slice_sizes_size() const;
  public:
  void clear_gather_slice_sizes();
  private:
  int64_t _internal_gather_slice_sizes(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_gather_slice_sizes() const;
  void _internal_add_gather_slice_sizes(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_gather_slice_sizes();
  public:
  int64_t gather_slice_sizes(int index) const;
  void set_gather_slice_sizes(int index, int64_t value);
  void add_gather_slice_sizes(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      gather_slice_sizes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_gather_slice_sizes();

  // repeated int64 operand_ids = 36;
  int operand_ids_size() const;
  private:
  int _internal_operand_ids_size() const;
  public:
  void clear_operand_ids();
  private:
  int64_t _internal_operand_ids(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_operand_ids() const;
  void _internal_add_operand_ids(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_operand_ids();
  public:
  int64_t operand_ids(int index) const;
  void set_operand_ids(int index, int64_t value);
  void add_operand_ids(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      operand_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_operand_ids();

  // repeated int64 control_predecessor_ids = 37;
  int control_predecessor_ids_size() const;
  private:
  int _internal_control_predecessor_ids_size() const;
  public:
  void clear_control_predecessor_ids();
  private:
  int64_t _internal_control_predecessor_ids(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_control_predecessor_ids() const;
  void _internal_add_control_predecessor_ids(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_control_predecessor_ids();
  public:
  int64_t control_predecessor_ids(int index) const;
  void set_control_predecessor_ids(int index, int64_t value);
  void add_control_predecessor_ids(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      control_predecessor_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_control_predecessor_ids();

  // repeated int64 called_computation_ids = 38;
  int called_computation_ids_size() const;
  private:
  int _internal_called_computation_ids_size() const;
  public:
  void clear_called_computation_ids();
  private:
  int64_t _internal_called_computation_ids(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_called_computation_ids() const;
  void _internal_add_called_computation_ids(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_called_computation_ids();
  public:
  int64_t called_computation_ids(int index) const;
  void set_called_computation_ids(int index, int64_t value);
  void add_called_computation_ids(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      called_computation_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_called_computation_ids();

  // repeated .xla.ReplicaGroup replica_groups = 49;
  int replica_groups_size() const;
  private:
  int _internal_replica_groups_size() const;
  public:
  void clear_replica_groups();
  ::xla::ReplicaGroup* mutable_replica_groups(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ReplicaGroup >*
      mutable_replica_groups();
  private:
  const ::xla::ReplicaGroup& _internal_replica_groups(int index) const;
  ::xla::ReplicaGroup* _internal_add_replica_groups();
  public:
  const ::xla::ReplicaGroup& replica_groups(int index) const;
  ::xla::ReplicaGroup* add_replica_groups();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ReplicaGroup >&
      replica_groups() const;

  // repeated .xla.SourceTarget source_target_pairs = 52;
  int source_target_pairs_size() const;
  private:
  int _internal_source_target_pairs_size() const;
  public:
  void clear_source_target_pairs();
  ::xla::SourceTarget* mutable_source_target_pairs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::SourceTarget >*
      mutable_source_target_pairs();
  private:
  const ::xla::SourceTarget& _internal_source_target_pairs(int index) const;
  ::xla::SourceTarget* _internal_add_source_target_pairs();
  public:
  const ::xla::SourceTarget& source_target_pairs(int index) const;
  ::xla::SourceTarget* add_source_target_pairs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::SourceTarget >&
      source_target_pairs() const;

  // repeated .xla.ShapeProto operand_shapes_with_layout = 57;
  int operand_shapes_with_layout_size() const;
  private:
  int _internal_operand_shapes_with_layout_size() const;
  public:
  void clear_operand_shapes_with_layout();
  ::xla::ShapeProto* mutable_operand_shapes_with_layout(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShapeProto >*
      mutable_operand_shapes_with_layout();
  private:
  const ::xla::ShapeProto& _internal_operand_shapes_with_layout(int index) const;
  ::xla::ShapeProto* _internal_add_operand_shapes_with_layout();
  public:
  const ::xla::ShapeProto& operand_shapes_with_layout(int index) const;
  ::xla::ShapeProto* add_operand_shapes_with_layout();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShapeProto >&
      operand_shapes_with_layout() const;

  // repeated .xla.OutputOperandAliasing output_operand_aliasing = 74;
  int output_operand_aliasing_size() const;
  private:
  int _internal_output_operand_aliasing_size() const;
  public:
  void clear_output_operand_aliasing();
  ::xla::OutputOperandAliasing* mutable_output_operand_aliasing(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::OutputOperandAliasing >*
      mutable_output_operand_aliasing();
  private:
  const ::xla::OutputOperandAliasing& _internal_output_operand_aliasing(int index) const;
  ::xla::OutputOperandAliasing* _internal_add_output_operand_aliasing();
  public:
  const ::xla::OutputOperandAliasing& output_operand_aliasing(int index) const;
  ::xla::OutputOperandAliasing* add_output_operand_aliasing();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::OutputOperandAliasing >&
      output_operand_aliasing() const;

  // string name = 1;
  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:

  // string opcode = 2;
  void clear_opcode();
  const std::string& opcode() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_opcode(ArgT0&& arg0, ArgT... args);
  std::string* mutable_opcode();
  PROTOBUF_NODISCARD std::string* release_opcode();
  void set_allocated_opcode(std::string* opcode);
  private:
  const std::string& _internal_opcode() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_opcode(const std::string& value);
  std::string* _internal_mutable_opcode();
  public:

  // string fusion_kind = 11;
  void clear_fusion_kind();
  const std::string& fusion_kind() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fusion_kind(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fusion_kind();
  PROTOBUF_NODISCARD std::string* release_fusion_kind();
  void set_allocated_fusion_kind(std::string* fusion_kind);
  private:
  const std::string& _internal_fusion_kind() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fusion_kind(const std::string& value);
  std::string* _internal_mutable_fusion_kind();
  public:

  // bytes outfeed_config = 22;
  void clear_outfeed_config();
  const std::string& outfeed_config() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_outfeed_config(ArgT0&& arg0, ArgT... args);
  std::string* mutable_outfeed_config();
  PROTOBUF_NODISCARD std::string* release_outfeed_config();
  void set_allocated_outfeed_config(std::string* outfeed_config);
  private:
  const std::string& _internal_outfeed_config() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_outfeed_config(const std::string& value);
  std::string* _internal_mutable_outfeed_config();
  public:

  // bytes infeed_config = 27;
  void clear_infeed_config();
  const std::string& infeed_config() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_infeed_config(ArgT0&& arg0, ArgT... args);
  std::string* mutable_infeed_config();
  PROTOBUF_NODISCARD std::string* release_infeed_config();
  void set_allocated_infeed_config(std::string* infeed_config);
  private:
  const std::string& _internal_infeed_config() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_infeed_config(const std::string& value);
  std::string* _internal_mutable_infeed_config();
  public:

  // string custom_call_target = 28;
  void clear_custom_call_target();
  const std::string& custom_call_target() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_custom_call_target(ArgT0&& arg0, ArgT... args);
  std::string* mutable_custom_call_target();
  PROTOBUF_NODISCARD std::string* release_custom_call_target();
  void set_allocated_custom_call_target(std::string* custom_call_target);
  private:
  const std::string& _internal_custom_call_target() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_custom_call_target(const std::string& value);
  std::string* _internal_mutable_custom_call_target();
  public:

  // bytes backend_config = 43;
  void clear_backend_config();
  const std::string& backend_config() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_backend_config(ArgT0&& arg0, ArgT... args);
  std::string* mutable_backend_config();
  PROTOBUF_NODISCARD std::string* release_backend_config();
  void set_allocated_backend_config(std::string* backend_config);
  private:
  const std::string& _internal_backend_config() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_backend_config(const std::string& value);
  std::string* _internal_mutable_backend_config();
  public:

  // string comparison_direction = 63;
  void clear_comparison_direction();
  const std::string& comparison_direction() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_comparison_direction(ArgT0&& arg0, ArgT... args);
  std::string* mutable_comparison_direction();
  PROTOBUF_NODISCARD std::string* release_comparison_direction();
  void set_allocated_comparison_direction(std::string* comparison_direction);
  private:
  const std::string& _internal_comparison_direction() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_comparison_direction(const std::string& value);
  std::string* _internal_mutable_comparison_direction();
  public:

  // string comparison_type = 72;
  void clear_comparison_type();
  const std::string& comparison_type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_comparison_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_comparison_type();
  PROTOBUF_NODISCARD std::string* release_comparison_type();
  void set_allocated_comparison_type(std::string* comparison_type);
  private:
  const std::string& _internal_comparison_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_comparison_type(const std::string& value);
  std::string* _internal_mutable_comparison_type();
  public:

  // string async_execution_thread = 79;
  void clear_async_execution_thread();
  const std::string& async_execution_thread() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_async_execution_thread(ArgT0&& arg0, ArgT... args);
  std::string* mutable_async_execution_thread();
  PROTOBUF_NODISCARD std::string* release_async_execution_thread();
  void set_allocated_async_execution_thread(std::string* async_execution_thread);
  private:
  const std::string& _internal_async_execution_thread() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_async_execution_thread(const std::string& value);
  std::string* _internal_mutable_async_execution_thread();
  public:

  // .xla.ShapeProto shape = 3;
  bool has_shape() const;
  private:
  bool _internal_has_shape() const;
  public:
  void clear_shape();
  const ::xla::ShapeProto& shape() const;
  PROTOBUF_NODISCARD ::xla::ShapeProto* release_shape();
  ::xla::ShapeProto* mutable_shape();
  void set_allocated_shape(::xla::ShapeProto* shape);
  private:
  const ::xla::ShapeProto& _internal_shape() const;
  ::xla::ShapeProto* _internal_mutable_shape();
  public:
  void unsafe_arena_set_allocated_shape(
      ::xla::ShapeProto* shape);
  ::xla::ShapeProto* unsafe_arena_release_shape();

  // .xla.OpMetadata metadata = 7;
  bool has_metadata() const;
  private:
  bool _internal_has_metadata() const;
  public:
  void clear_metadata();
  const ::xla::OpMetadata& metadata() const;
  PROTOBUF_NODISCARD ::xla::OpMetadata* release_metadata();
  ::xla::OpMetadata* mutable_metadata();
  void set_allocated_metadata(::xla::OpMetadata* metadata);
  private:
  const ::xla::OpMetadata& _internal_metadata() const;
  ::xla::OpMetadata* _internal_mutable_metadata();
  public:
  void unsafe_arena_set_allocated_metadata(
      ::xla::OpMetadata* metadata);
  ::xla::OpMetadata* unsafe_arena_release_metadata();

  // .xla.LiteralProto literal = 8;
  bool has_literal() const;
  private:
  bool _internal_has_literal() const;
  public:
  void clear_literal();
  const ::xla::LiteralProto& literal() const;
  PROTOBUF_NODISCARD ::xla::LiteralProto* release_literal();
  ::xla::LiteralProto* mutable_literal();
  void set_allocated_literal(::xla::LiteralProto* literal);
  private:
  const ::xla::LiteralProto& _internal_literal() const;
  ::xla::LiteralProto* _internal_mutable_literal();
  public:
  void unsafe_arena_set_allocated_literal(
      ::xla::LiteralProto* literal);
  ::xla::LiteralProto* unsafe_arena_release_literal();

  // .xla.Window window = 15;
  bool has_window() const;
  private:
  bool _internal_has_window() const;
  public:
  void clear_window();
  const ::xla::Window& window() const;
  PROTOBUF_NODISCARD ::xla::Window* release_window();
  ::xla::Window* mutable_window();
  void set_allocated_window(::xla::Window* window);
  private:
  const ::xla::Window& _internal_window() const;
  ::xla::Window* _internal_mutable_window();
  public:
  void unsafe_arena_set_allocated_window(
      ::xla::Window* window);
  ::xla::Window* unsafe_arena_release_window();

  // .xla.ConvolutionDimensionNumbers convolution_dimension_numbers = 16;
  bool has_convolution_dimension_numbers() const;
  private:
  bool _internal_has_convolution_dimension_numbers() const;
  public:
  void clear_convolution_dimension_numbers();
  const ::xla::ConvolutionDimensionNumbers& convolution_dimension_numbers() const;
  PROTOBUF_NODISCARD ::xla::ConvolutionDimensionNumbers* release_convolution_dimension_numbers();
  ::xla::ConvolutionDimensionNumbers* mutable_convolution_dimension_numbers();
  void set_allocated_convolution_dimension_numbers(::xla::ConvolutionDimensionNumbers* convolution_dimension_numbers);
  private:
  const ::xla::ConvolutionDimensionNumbers& _internal_convolution_dimension_numbers() const;
  ::xla::ConvolutionDimensionNumbers* _internal_mutable_convolution_dimension_numbers();
  public:
  void unsafe_arena_set_allocated_convolution_dimension_numbers(
      ::xla::ConvolutionDimensionNumbers* convolution_dimension_numbers);
  ::xla::ConvolutionDimensionNumbers* unsafe_arena_release_convolution_dimension_numbers();

  // .xla.PaddingConfig padding_config = 21;
  bool has_padding_config() const;
  private:
  bool _internal_has_padding_config() const;
  public:
  void clear_padding_config();
  const ::xla::PaddingConfig& padding_config() const;
  PROTOBUF_NODISCARD ::xla::PaddingConfig* release_padding_config();
  ::xla::PaddingConfig* mutable_padding_config();
  void set_allocated_padding_config(::xla::PaddingConfig* padding_config);
  private:
  const ::xla::PaddingConfig& _internal_padding_config() const;
  ::xla::PaddingConfig* _internal_mutable_padding_config();
  public:
  void unsafe_arena_set_allocated_padding_config(
      ::xla::PaddingConfig* padding_config);
  ::xla::PaddingConfig* unsafe_arena_release_padding_config();

  // .xla.ShapeProto outfeed_shape = 29;
  bool has_outfeed_shape() const;
  private:
  bool _internal_has_outfeed_shape() const;
  public:
  void clear_outfeed_shape();
  const ::xla::ShapeProto& outfeed_shape() const;
  PROTOBUF_NODISCARD ::xla::ShapeProto* release_outfeed_shape();
  ::xla::ShapeProto* mutable_outfeed_shape();
  void set_allocated_outfeed_shape(::xla::ShapeProto* outfeed_shape);
  private:
  const ::xla::ShapeProto& _internal_outfeed_shape() const;
  ::xla::ShapeProto* _internal_mutable_outfeed_shape();
  public:
  void unsafe_arena_set_allocated_outfeed_shape(
      ::xla::ShapeProto* outfeed_shape);
  ::xla::ShapeProto* unsafe_arena_release_outfeed_shape();

  // .xla.DotDimensionNumbers dot_dimension_numbers = 30;
  bool has_dot_dimension_numbers() const;
  private:
  bool _internal_has_dot_dimension_numbers() const;
  public:
  void clear_dot_dimension_numbers();
  const ::xla::DotDimensionNumbers& dot_dimension_numbers() const;
  PROTOBUF_NODISCARD ::xla::DotDimensionNumbers* release_dot_dimension_numbers();
  ::xla::DotDimensionNumbers* mutable_dot_dimension_numbers();
  void set_allocated_dot_dimension_numbers(::xla::DotDimensionNumbers* dot_dimension_numbers);
  private:
  const ::xla::DotDimensionNumbers& _internal_dot_dimension_numbers() const;
  ::xla::DotDimensionNumbers* _internal_mutable_dot_dimension_numbers();
  public:
  void unsafe_arena_set_allocated_dot_dimension_numbers(
      ::xla::DotDimensionNumbers* dot_dimension_numbers);
  ::xla::DotDimensionNumbers* unsafe_arena_release_dot_dimension_numbers();

  // .xla.GatherDimensionNumbers gather_dimension_numbers = 33;
  bool has_gather_dimension_numbers() const;
  private:
  bool _internal_has_gather_dimension_numbers() const;
  public:
  void clear_gather_dimension_numbers();
  const ::xla::GatherDimensionNumbers& gather_dimension_numbers() const;
  PROTOBUF_NODISCARD ::xla::GatherDimensionNumbers* release_gather_dimension_numbers();
  ::xla::GatherDimensionNumbers* mutable_gather_dimension_numbers();
  void set_allocated_gather_dimension_numbers(::xla::GatherDimensionNumbers* gather_dimension_numbers);
  private:
  const ::xla::GatherDimensionNumbers& _internal_gather_dimension_numbers() const;
  ::xla::GatherDimensionNumbers* _internal_mutable_gather_dimension_numbers();
  public:
  void unsafe_arena_set_allocated_gather_dimension_numbers(
      ::xla::GatherDimensionNumbers* gather_dimension_numbers);
  ::xla::GatherDimensionNumbers* unsafe_arena_release_gather_dimension_numbers();

  // .xla.OpSharding sharding = 40;
  bool has_sharding() const;
  private:
  bool _internal_has_sharding() const;
  public:
  void clear_sharding();
  const ::xla::OpSharding& sharding() const;
  PROTOBUF_NODISCARD ::xla::OpSharding* release_sharding();
  ::xla::OpSharding* mutable_sharding();
  void set_allocated_sharding(::xla::OpSharding* sharding);
  private:
  const ::xla::OpSharding& _internal_sharding() const;
  ::xla::OpSharding* _internal_mutable_sharding();
  public:
  void unsafe_arena_set_allocated_sharding(
      ::xla::OpSharding* sharding);
  ::xla::OpSharding* unsafe_arena_release_sharding();

  // .xla.ScatterDimensionNumbers scatter_dimension_numbers = 48;
  bool has_scatter_dimension_numbers() const;
  private:
  bool _internal_has_scatter_dimension_numbers() const;
  public:
  void clear_scatter_dimension_numbers();
  const ::xla::ScatterDimensionNumbers& scatter_dimension_numbers() const;
  PROTOBUF_NODISCARD ::xla::ScatterDimensionNumbers* release_scatter_dimension_numbers();
  ::xla::ScatterDimensionNumbers* mutable_scatter_dimension_numbers();
  void set_allocated_scatter_dimension_numbers(::xla::ScatterDimensionNumbers* scatter_dimension_numbers);
  private:
  const ::xla::ScatterDimensionNumbers& _internal_scatter_dimension_numbers() const;
  ::xla::ScatterDimensionNumbers* _internal_mutable_scatter_dimension_numbers();
  public:
  void unsafe_arena_set_allocated_scatter_dimension_numbers(
      ::xla::ScatterDimensionNumbers* scatter_dimension_numbers);
  ::xla::ScatterDimensionNumbers* unsafe_arena_release_scatter_dimension_numbers();

  // .xla.PrecisionConfig precision_config = 51;
  bool has_precision_config() const;
  private:
  bool _internal_has_precision_config() const;
  public:
  void clear_precision_config();
  const ::xla::PrecisionConfig& precision_config() const;
  PROTOBUF_NODISCARD ::xla::PrecisionConfig* release_precision_config();
  ::xla::PrecisionConfig* mutable_precision_config();
  void set_allocated_precision_config(::xla::PrecisionConfig* precision_config);
  private:
  const ::xla::PrecisionConfig& _internal_precision_config() const;
  ::xla::PrecisionConfig* _internal_mutable_precision_config();
  public:
  void unsafe_arena_set_allocated_precision_config(
      ::xla::PrecisionConfig* precision_config);
  ::xla::PrecisionConfig* unsafe_arena_release_precision_config();

  // .xla.OpSharding domain_entry_sharding = 54;
  bool has_domain_entry_sharding() const;
  private:
  bool _internal_has_domain_entry_sharding() const;
  public:
  void clear_domain_entry_sharding();
  const ::xla::OpSharding& domain_entry_sharding() const;
  PROTOBUF_NODISCARD ::xla::OpSharding* release_domain_entry_sharding();
  ::xla::OpSharding* mutable_domain_entry_sharding();
  void set_allocated_domain_entry_sharding(::xla::OpSharding* domain_entry_sharding);
  private:
  const ::xla::OpSharding& _internal_domain_entry_sharding() const;
  ::xla::OpSharding* _internal_mutable_domain_entry_sharding();
  public:
  void unsafe_arena_set_allocated_domain_entry_sharding(
      ::xla::OpSharding* domain_entry_sharding);
  ::xla::OpSharding* unsafe_arena_release_domain_entry_sharding();

  // .xla.OpSharding domain_exit_sharding = 55;
  bool has_domain_exit_sharding() const;
  private:
  bool _internal_has_domain_exit_sharding() const;
  public:
  void clear_domain_exit_sharding();
  const ::xla::OpSharding& domain_exit_sharding() const;
  PROTOBUF_NODISCARD ::xla::OpSharding* release_domain_exit_sharding();
  ::xla::OpSharding* mutable_domain_exit_sharding();
  void set_allocated_domain_exit_sharding(::xla::OpSharding* domain_exit_sharding);
  private:
  const ::xla::OpSharding& _internal_domain_exit_sharding() const;
  ::xla::OpSharding* _internal_mutable_domain_exit_sharding();
  public:
  void unsafe_arena_set_allocated_domain_exit_sharding(
      ::xla::OpSharding* domain_exit_sharding);
  ::xla::OpSharding* unsafe_arena_release_domain_exit_sharding();

  // .xla.TriangularSolveOptions triangular_solve_options = 59;
  bool has_triangular_solve_options() const;
  private:
  bool _internal_has_triangular_solve_options() const;
  public:
  void clear_triangular_solve_options();
  const ::xla::TriangularSolveOptions& triangular_solve_options() const;
  PROTOBUF_NODISCARD ::xla::TriangularSolveOptions* release_triangular_solve_options();
  ::xla::TriangularSolveOptions* mutable_triangular_solve_options();
  void set_allocated_triangular_solve_options(::xla::TriangularSolveOptions* triangular_solve_options);
  private:
  const ::xla::TriangularSolveOptions& _internal_triangular_solve_options() const;
  ::xla::TriangularSolveOptions* _internal_mutable_triangular_solve_options();
  public:
  void unsafe_arena_set_allocated_triangular_solve_options(
      ::xla::TriangularSolveOptions* triangular_solve_options);
  ::xla::TriangularSolveOptions* unsafe_arena_release_triangular_solve_options();

  // .xla.ParameterReplication parameter_replication = 61;
  bool has_parameter_replication() const;
  private:
  bool _internal_has_parameter_replication() const;
  public:
  void clear_parameter_replication();
  const ::xla::ParameterReplication& parameter_replication() const;
  PROTOBUF_NODISCARD ::xla::ParameterReplication* release_parameter_replication();
  ::xla::ParameterReplication* mutable_parameter_replication();
  void set_allocated_parameter_replication(::xla::ParameterReplication* parameter_replication);
  private:
  const ::xla::ParameterReplication& _internal_parameter_replication() const;
  ::xla::ParameterReplication* _internal_mutable_parameter_replication();
  public:
  void unsafe_arena_set_allocated_parameter_replication(
      ::xla::ParameterReplication* parameter_replication);
  ::xla::ParameterReplication* unsafe_arena_release_parameter_replication();

  // .xla.CholeskyOptions cholesky_options = 62;
  bool has_cholesky_options() const;
  private:
  bool _internal_has_cholesky_options() const;
  public:
  void clear_cholesky_options();
  const ::xla::CholeskyOptions& cholesky_options() const;
  PROTOBUF_NODISCARD ::xla::CholeskyOptions* release_cholesky_options();
  ::xla::CholeskyOptions* mutable_cholesky_options();
  void set_allocated_cholesky_options(::xla::CholeskyOptions* cholesky_options);
  private:
  const ::xla::CholeskyOptions& _internal_cholesky_options() const;
  ::xla::CholeskyOptions* _internal_mutable_cholesky_options();
  public:
  void unsafe_arena_set_allocated_cholesky_options(
      ::xla::CholeskyOptions* cholesky_options);
  ::xla::CholeskyOptions* unsafe_arena_release_cholesky_options();

  // .xla.FrontendAttributes frontend_attributes = 68;
  bool has_frontend_attributes() const;
  private:
  bool _internal_has_frontend_attributes() const;
  public:
  void clear_frontend_attributes();
  const ::xla::FrontendAttributes& frontend_attributes() const;
  PROTOBUF_NODISCARD ::xla::FrontendAttributes* release_frontend_attributes();
  ::xla::FrontendAttributes* mutable_frontend_attributes();
  void set_allocated_frontend_attributes(::xla::FrontendAttributes* frontend_attributes);
  private:
  const ::xla::FrontendAttributes& _internal_frontend_attributes() const;
  ::xla::FrontendAttributes* _internal_mutable_frontend_attributes();
  public:
  void unsafe_arena_set_allocated_frontend_attributes(
      ::xla::FrontendAttributes* frontend_attributes);
  ::xla::FrontendAttributes* unsafe_arena_release_frontend_attributes();

  // int64 parameter_number = 9;
  void clear_parameter_number();
  int64_t parameter_number() const;
  void set_parameter_number(int64_t value);
  private:
  int64_t _internal_parameter_number() const;
  void _internal_set_parameter_number(int64_t value);
  public:

  // int64 tuple_index = 13;
  void clear_tuple_index();
  int64_t tuple_index() const;
  void set_tuple_index(int64_t value);
  private:
  int64_t _internal_tuple_index() const;
  void _internal_set_tuple_index(int64_t value);
  public:

  // int32 exponent_bits = 18;
  void clear_exponent_bits();
  int32_t exponent_bits() const;
  void set_exponent_bits(int32_t value);
  private:
  int32_t _internal_exponent_bits() const;
  void _internal_set_exponent_bits(int32_t value);
  public:

  // int32 mantissa_bits = 19;
  void clear_mantissa_bits();
  int32_t mantissa_bits() const;
  void set_mantissa_bits(int32_t value);
  private:
  int32_t _internal_mantissa_bits() const;
  void _internal_set_mantissa_bits(int32_t value);
  public:

  // .xla.RandomDistribution distribution = 23;
  void clear_distribution();
  ::xla::RandomDistribution distribution() const;
  void set_distribution(::xla::RandomDistribution value);
  private:
  ::xla::RandomDistribution _internal_distribution() const;
  void _internal_set_distribution(::xla::RandomDistribution value);
  public:

  // float epsilon = 24;
  void clear_epsilon();
  float epsilon() const;
  void set_epsilon(float value);
  private:
  float _internal_epsilon() const;
  void _internal_set_epsilon(float value);
  public:

  // int64 feature_index = 25;
  void clear_feature_index();
  int64_t feature_index() const;
  void set_feature_index(int64_t value);
  private:
  int64_t _internal_feature_index() const;
  void _internal_set_feature_index(int64_t value);
  public:

  // int64 channel_id = 26;
  void clear_channel_id();
  int64_t channel_id() const;
  void set_channel_id(int64_t value);
  private:
  int64_t _internal_channel_id() const;
  void _internal_set_channel_id(int64_t value);
  public:

  // int64 id = 35;
  void clear_id();
  int64_t id() const;
  void set_id(int64_t value);
  private:
  int64_t _internal_id() const;
  void _internal_set_id(int64_t value);
  public:

  // int64 all_reduce_id = 45 [deprecated = true];
  PROTOBUF_DEPRECATED void clear_all_reduce_id();
  PROTOBUF_DEPRECATED int64_t all_reduce_id() const;
  PROTOBUF_DEPRECATED void set_all_reduce_id(int64_t value);
  private:
  int64_t _internal_all_reduce_id() const;
  void _internal_set_all_reduce_id(int64_t value);
  public:

  // int64 feature_group_count = 50;
  void clear_feature_group_count();
  int64_t feature_group_count() const;
  void set_feature_group_count(int64_t value);
  private:
  int64_t _internal_feature_group_count() const;
  void _internal_set_feature_group_count(int64_t value);
  public:

  // .xla.FftType fft_type = 31;
  void clear_fft_type();
  ::xla::FftType fft_type() const;
  void set_fft_type(::xla::FftType value);
  private:
  ::xla::FftType _internal_fft_type() const;
  void _internal_set_fft_type(::xla::FftType value);
  public:

  // bool use_global_device_ids = 71;
  void clear_use_global_device_ids();
  bool use_global_device_ids() const;
  void set_use_global_device_ids(bool value);
  private:
  bool _internal_use_global_device_ids() const;
  void _internal_set_use_global_device_ids(bool value);
  public:

  // bool is_host_transfer = 47;
  void clear_is_host_transfer();
  bool is_host_transfer() const;
  void set_is_host_transfer(bool value);
  private:
  bool _internal_is_host_transfer() const;
  void _internal_set_is_host_transfer(bool value);
  public:

  // bool is_stable = 60;
  void clear_is_stable();
  bool is_stable() const;
  void set_is_stable(bool value);
  private:
  bool _internal_is_stable() const;
  void _internal_set_is_stable(bool value);
  public:

  // bool constrain_layout = 56;
  void clear_constrain_layout();
  bool constrain_layout() const;
  void set_constrain_layout(bool value);
  private:
  bool _internal_constrain_layout() const;
  void _internal_set_constrain_layout(bool value);
  public:

  // int64 batch_group_count = 58;
  void clear_batch_group_count();
  int64_t batch_group_count() const;
  void set_batch_group_count(int64_t value);
  private:
  int64_t _internal_batch_group_count() const;
  void _internal_set_batch_group_count(int64_t value);
  public:

  // int64 delta = 66;
  void clear_delta();
  int64_t delta() const;
  void set_delta(int64_t value);
  private:
  int64_t _internal_delta() const;
  void _internal_set_delta(int64_t value);
  public:

  // bool custom_call_has_side_effect = 65;
  void clear_custom_call_has_side_effect();
  bool custom_call_has_side_effect() const;
  void set_custom_call_has_side_effect(bool value);
  private:
  bool _internal_custom_call_has_side_effect() const;
  void _internal_set_custom_call_has_side_effect(bool value);
  public:

  // bool indices_are_sorted = 67;
  void clear_indices_are_sorted();
  bool indices_are_sorted() const;
  void set_indices_are_sorted(bool value);
  private:
  bool _internal_indices_are_sorted() const;
  void _internal_set_indices_are_sorted(bool value);
  public:

  // bool unique_indices = 69;
  void clear_unique_indices();
  bool unique_indices() const;
  void set_unique_indices(bool value);
  private:
  bool _internal_unique_indices() const;
  void _internal_set_unique_indices(bool value);
  public:

  // bool is_cross_program_prefetch = 73 [deprecated = true];
  PROTOBUF_DEPRECATED void clear_is_cross_program_prefetch();
  PROTOBUF_DEPRECATED bool is_cross_program_prefetch() const;
  PROTOBUF_DEPRECATED void set_is_cross_program_prefetch(bool value);
  private:
  bool _internal_is_cross_program_prefetch() const;
  void _internal_set_is_cross_program_prefetch(bool value);
  public:

  // .xla.RandomAlgorithm rng_algorithm = 70;
  void clear_rng_algorithm();
  ::xla::RandomAlgorithm rng_algorithm() const;
  void set_rng_algorithm(::xla::RandomAlgorithm value);
  private:
  ::xla::RandomAlgorithm _internal_rng_algorithm() const;
  void _internal_set_rng_algorithm(::xla::RandomAlgorithm value);
  public:

  // .xla.PaddingType padding_type = 75;
  void clear_padding_type();
  ::xla::PaddingType padding_type() const;
  void set_padding_type(::xla::PaddingType value);
  private:
  ::xla::PaddingType _internal_padding_type() const;
  void _internal_set_padding_type(::xla::PaddingType value);
  public:

  // .xla.CustomCallSchedule custom_call_schedule = 76;
  void clear_custom_call_schedule();
  ::xla::CustomCallSchedule custom_call_schedule() const;
  void set_custom_call_schedule(::xla::CustomCallSchedule value);
  private:
  ::xla::CustomCallSchedule _internal_custom_call_schedule() const;
  void _internal_set_custom_call_schedule(::xla::CustomCallSchedule value);
  public:

  // int64 async_group_id = 78;
  void clear_async_group_id();
  int64_t async_group_id() const;
  void set_async_group_id(int64_t value);
  private:
  int64_t _internal_async_group_id() const;
  void _internal_set_async_group_id(int64_t value);
  public:

  // .xla.CustomCallApiVersion custom_call_api_version = 77;
  void clear_custom_call_api_version();
  ::xla::CustomCallApiVersion custom_call_api_version() const;
  void set_custom_call_api_version(::xla::CustomCallApiVersion value);
  private:
  ::xla::CustomCallApiVersion _internal_custom_call_api_version() const;
  void _internal_set_custom_call_api_version(::xla::CustomCallApiVersion value);
  public:

  // int32 cross_program_prefetch_index = 80;
  bool has_cross_program_prefetch_index() const;
  private:
  bool _internal_has_cross_program_prefetch_index() const;
  public:
  void clear_cross_program_prefetch_index();
  int32_t cross_program_prefetch_index() const;
  void set_cross_program_prefetch_index(int32_t value);
  private:
  int32_t _internal_cross_program_prefetch_index() const;
  void _internal_set_cross_program_prefetch_index(int32_t value);
  public:

  void clear_optional_cross_program_prefetch_index();
  OptionalCrossProgramPrefetchIndexCase optional_cross_program_prefetch_index_case() const;
  // @@protoc_insertion_point(class_scope:xla.HloInstructionProto)
 private:
  class _Internal;
  void set_has_cross_program_prefetch_index();

  inline bool has_optional_cross_program_prefetch_index() const;
  inline void clear_has_optional_cross_program_prefetch_index();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > dimensions_;
    mutable std::atomic<int> _dimensions_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloInstructionProto_SliceDimensions > slice_dimensions_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > dynamic_slice_sizes_;
    mutable std::atomic<int> _dynamic_slice_sizes_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > fft_length_;
    mutable std::atomic<int> _fft_length_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > gather_slice_sizes_;
    mutable std::atomic<int> _gather_slice_sizes_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > operand_ids_;
    mutable std::atomic<int> _operand_ids_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > control_predecessor_ids_;
    mutable std::atomic<int> _control_predecessor_ids_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > called_computation_ids_;
    mutable std::atomic<int> _called_computation_ids_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ReplicaGroup > replica_groups_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::SourceTarget > source_target_pairs_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShapeProto > operand_shapes_with_layout_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::OutputOperandAliasing > output_operand_aliasing_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr opcode_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fusion_kind_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr outfeed_config_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr infeed_config_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr custom_call_target_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backend_config_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comparison_direction_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comparison_type_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr async_execution_thread_;
    ::xla::ShapeProto* shape_;
    ::xla::OpMetadata* metadata_;
    ::xla::LiteralProto* literal_;
    ::xla::Window* window_;
    ::xla::ConvolutionDimensionNumbers* convolution_dimension_numbers_;
    ::xla::PaddingConfig* padding_config_;
    ::xla::ShapeProto* outfeed_shape_;
    ::xla::DotDimensionNumbers* dot_dimension_numbers_;
    ::xla::GatherDimensionNumbers* gather_dimension_numbers_;
    ::xla::OpSharding* sharding_;
    ::xla::ScatterDimensionNumbers* scatter_dimension_numbers_;
    ::xla::PrecisionConfig* precision_config_;
    ::xla::OpSharding* domain_entry_sharding_;
    ::xla::OpSharding* domain_exit_sharding_;
    ::xla::TriangularSolveOptions* triangular_solve_options_;
    ::xla::ParameterReplication* parameter_replication_;
    ::xla::CholeskyOptions* cholesky_options_;
    ::xla::FrontendAttributes* frontend_attributes_;
    int64_t parameter_number_;
    int64_t tuple_index_;
    int32_t exponent_bits_;
    int32_t mantissa_bits_;
    int distribution_;
    float epsilon_;
    int64_t feature_index_;
    int64_t channel_id_;
    int64_t id_;
    int64_t all_reduce_id_;
    int64_t feature_group_count_;
    int fft_type_;
    bool use_global_device_ids_;
    bool is_host_transfer_;
    bool is_stable_;
    bool constrain_layout_;
    int64_t batch_group_count_;
    int64_t delta_;
    bool custom_call_has_side_effect_;
    bool indices_are_sorted_;
    bool unique_indices_;
    bool is_cross_program_prefetch_;
    int rng_algorithm_;
    int padding_type_;
    int custom_call_schedule_;
    int64_t async_group_id_;
    int custom_call_api_version_;
    union OptionalCrossProgramPrefetchIndexUnion {
      constexpr OptionalCrossProgramPrefetchIndexUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      int32_t cross_program_prefetch_index_;
    } optional_cross_program_prefetch_index_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline HloComputationProto& operator=(const HloComputationProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloComputationProto& operator=(HloComputationProto&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloComputationProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloComputationProto* internal_default_instance() {
    return reinterpret_cast<const HloComputationProto*>(
               &_HloComputationProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(HloComputationProto& a, HloComputationProto& b) {
    a.Swap(&b);
  }
  inline void Swap(HloComputationProto* 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(HloComputationProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HloComputationProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HloComputationProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HloComputationProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HloComputationProto& from) {
    HloComputationProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(HloComputationProto* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kInstructionsFieldNumber = 2,
    kNameFieldNumber = 1,
    kExecutionThreadFieldNumber = 8,
    kProgramShapeFieldNumber = 4,
    kIdFieldNumber = 5,
    kRootIdFieldNumber = 6,
    kIsFusionComputationFieldNumber = 7,
  };
  // repeated .xla.HloInstructionProto instructions = 2;
  int instructions_size() const;
  private:
  int _internal_instructions_size() const;
  public:
  void clear_instructions();
  ::xla::HloInstructionProto* mutable_instructions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloInstructionProto >*
      mutable_instructions();
  private:
  const ::xla::HloInstructionProto& _internal_instructions(int index) const;
  ::xla::HloInstructionProto* _internal_add_instructions();
  public:
  const ::xla::HloInstructionProto& instructions(int index) const;
  ::xla::HloInstructionProto* add_instructions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloInstructionProto >&
      instructions() const;

  // string name = 1;
  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:

  // string execution_thread = 8;
  void clear_execution_thread();
  const std::string& execution_thread() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_execution_thread(ArgT0&& arg0, ArgT... args);
  std::string* mutable_execution_thread();
  PROTOBUF_NODISCARD std::string* release_execution_thread();
  void set_allocated_execution_thread(std::string* execution_thread);
  private:
  const std::string& _internal_execution_thread() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_execution_thread(const std::string& value);
  std::string* _internal_mutable_execution_thread();
  public:

  // .xla.ProgramShapeProto program_shape = 4;
  bool has_program_shape() const;
  private:
  bool _internal_has_program_shape() const;
  public:
  void clear_program_shape();
  const ::xla::ProgramShapeProto& program_shape() const;
  PROTOBUF_NODISCARD ::xla::ProgramShapeProto* release_program_shape();
  ::xla::ProgramShapeProto* mutable_program_shape();
  void set_allocated_program_shape(::xla::ProgramShapeProto* program_shape);
  private:
  const ::xla::ProgramShapeProto& _internal_program_shape() const;
  ::xla::ProgramShapeProto* _internal_mutable_program_shape();
  public:
  void unsafe_arena_set_allocated_program_shape(
      ::xla::ProgramShapeProto* program_shape);
  ::xla::ProgramShapeProto* unsafe_arena_release_program_shape();

  // int64 id = 5;
  void clear_id();
  int64_t id() const;
  void set_id(int64_t value);
  private:
  int64_t _internal_id() const;
  void _internal_set_id(int64_t value);
  public:

  // int64 root_id = 6;
  void clear_root_id();
  int64_t root_id() const;
  void set_root_id(int64_t value);
  private:
  int64_t _internal_root_id() const;
  void _internal_set_root_id(int64_t value);
  public:

  // bool is_fusion_computation = 7;
  void clear_is_fusion_computation();
  bool is_fusion_computation() const;
  void set_is_fusion_computation(bool value);
  private:
  bool _internal_is_fusion_computation() const;
  void _internal_set_is_fusion_computation(bool value);
  public:

  // @@protoc_insertion_point(class_scope:xla.HloComputationProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloInstructionProto > instructions_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr execution_thread_;
    ::xla::ProgramShapeProto* program_shape_;
    int64_t id_;
    int64_t root_id_;
    bool is_fusion_computation_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

class HloScheduleProto_InstructionSequence final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.HloScheduleProto.InstructionSequence) */ {
 public:
  inline HloScheduleProto_InstructionSequence() : HloScheduleProto_InstructionSequence(nullptr) {}
  ~HloScheduleProto_InstructionSequence() override;
  explicit PROTOBUF_CONSTEXPR HloScheduleProto_InstructionSequence(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline HloScheduleProto_InstructionSequence& operator=(const HloScheduleProto_InstructionSequence& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloScheduleProto_InstructionSequence& operator=(HloScheduleProto_InstructionSequence&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloScheduleProto_InstructionSequence& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloScheduleProto_InstructionSequence* internal_default_instance() {
    return reinterpret_cast<const HloScheduleProto_InstructionSequence*>(
               &_HloScheduleProto_InstructionSequence_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(HloScheduleProto_InstructionSequence& a, HloScheduleProto_InstructionSequence& b) {
    a.Swap(&b);
  }
  inline void Swap(HloScheduleProto_InstructionSequence* 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(HloScheduleProto_InstructionSequence* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HloScheduleProto_InstructionSequence* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HloScheduleProto_InstructionSequence>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HloScheduleProto_InstructionSequence& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HloScheduleProto_InstructionSequence& from) {
    HloScheduleProto_InstructionSequence::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(HloScheduleProto_InstructionSequence* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kInstructionIdsFieldNumber = 1,
  };
  // repeated int64 instruction_ids = 1;
  int instruction_ids_size() const;
  private:
  int _internal_instruction_ids_size() const;
  public:
  void clear_instruction_ids();
  private:
  int64_t _internal_instruction_ids(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_instruction_ids() const;
  void _internal_add_instruction_ids(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_instruction_ids();
  public:
  int64_t instruction_ids(int index) const;
  void set_instruction_ids(int index, int64_t value);
  void add_instruction_ids(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      instruction_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_instruction_ids();

  // @@protoc_insertion_point(class_scope:xla.HloScheduleProto.InstructionSequence)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > instruction_ids_;
    mutable std::atomic<int> _instruction_ids_cached_byte_size_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

class HloScheduleProto_SequencesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<HloScheduleProto_SequencesEntry_DoNotUse, 
    int64_t, ::xla::HloScheduleProto_InstructionSequence,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<HloScheduleProto_SequencesEntry_DoNotUse, 
    int64_t, ::xla::HloScheduleProto_InstructionSequence,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  HloScheduleProto_SequencesEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR HloScheduleProto_SequencesEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit HloScheduleProto_SequencesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const HloScheduleProto_SequencesEntry_DoNotUse& other);
  static const HloScheduleProto_SequencesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const HloScheduleProto_SequencesEntry_DoNotUse*>(&_HloScheduleProto_SequencesEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(void*) { return true; }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};

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

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

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

  inline HloScheduleProto& operator=(const HloScheduleProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloScheduleProto& operator=(HloScheduleProto&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloScheduleProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloScheduleProto* internal_default_instance() {
    return reinterpret_cast<const HloScheduleProto*>(
               &_HloScheduleProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(HloScheduleProto& a, HloScheduleProto& b) {
    a.Swap(&b);
  }
  inline void Swap(HloScheduleProto* 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(HloScheduleProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HloScheduleProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HloScheduleProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HloScheduleProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HloScheduleProto& from) {
    HloScheduleProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(HloScheduleProto* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef HloScheduleProto_InstructionSequence InstructionSequence;

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

  enum : int {
    kSequencesFieldNumber = 1,
  };
  // map<int64, .xla.HloScheduleProto.InstructionSequence> sequences = 1;
  int sequences_size() const;
  private:
  int _internal_sequences_size() const;
  public:
  void clear_sequences();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::xla::HloScheduleProto_InstructionSequence >&
      _internal_sequences() const;
  ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::xla::HloScheduleProto_InstructionSequence >*
      _internal_mutable_sequences();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::xla::HloScheduleProto_InstructionSequence >&
      sequences() const;
  ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::xla::HloScheduleProto_InstructionSequence >*
      mutable_sequences();

  // @@protoc_insertion_point(class_scope:xla.HloScheduleProto)
 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::MapField<
        HloScheduleProto_SequencesEntry_DoNotUse,
        int64_t, ::xla::HloScheduleProto_InstructionSequence,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> sequences_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

class HloInputOutputAliasProto_AliasEntryProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.HloInputOutputAliasProto.AliasEntryProto) */ {
 public:
  inline HloInputOutputAliasProto_AliasEntryProto() : HloInputOutputAliasProto_AliasEntryProto(nullptr) {}
  ~HloInputOutputAliasProto_AliasEntryProto() override;
  explicit PROTOBUF_CONSTEXPR HloInputOutputAliasProto_AliasEntryProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline HloInputOutputAliasProto_AliasEntryProto& operator=(const HloInputOutputAliasProto_AliasEntryProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloInputOutputAliasProto_AliasEntryProto& operator=(HloInputOutputAliasProto_AliasEntryProto&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloInputOutputAliasProto_AliasEntryProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloInputOutputAliasProto_AliasEntryProto* internal_default_instance() {
    return reinterpret_cast<const HloInputOutputAliasProto_AliasEntryProto*>(
               &_HloInputOutputAliasProto_AliasEntryProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(HloInputOutputAliasProto_AliasEntryProto& a, HloInputOutputAliasProto_AliasEntryProto& b) {
    a.Swap(&b);
  }
  inline void Swap(HloInputOutputAliasProto_AliasEntryProto* 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(HloInputOutputAliasProto_AliasEntryProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HloInputOutputAliasProto_AliasEntryProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HloInputOutputAliasProto_AliasEntryProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HloInputOutputAliasProto_AliasEntryProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HloInputOutputAliasProto_AliasEntryProto& from) {
    HloInputOutputAliasProto_AliasEntryProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(HloInputOutputAliasProto_AliasEntryProto* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kOutputShapeIndexFieldNumber = 1,
    kParameterShapeIndexFieldNumber = 3,
    kParameterNumberFieldNumber = 2,
    kKindFieldNumber = 4,
  };
  // repeated int64 output_shape_index = 1;
  int output_shape_index_size() const;
  private:
  int _internal_output_shape_index_size() const;
  public:
  void clear_output_shape_index();
  private:
  int64_t _internal_output_shape_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_output_shape_index() const;
  void _internal_add_output_shape_index(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_output_shape_index();
  public:
  int64_t output_shape_index(int index) const;
  void set_output_shape_index(int index, int64_t value);
  void add_output_shape_index(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      output_shape_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_output_shape_index();

  // repeated int64 parameter_shape_index = 3;
  int parameter_shape_index_size() const;
  private:
  int _internal_parameter_shape_index_size() const;
  public:
  void clear_parameter_shape_index();
  private:
  int64_t _internal_parameter_shape_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_parameter_shape_index() const;
  void _internal_add_parameter_shape_index(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_parameter_shape_index();
  public:
  int64_t parameter_shape_index(int index) const;
  void set_parameter_shape_index(int index, int64_t value);
  void add_parameter_shape_index(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      parameter_shape_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_parameter_shape_index();

  // int64 parameter_number = 2;
  void clear_parameter_number();
  int64_t parameter_number() const;
  void set_parameter_number(int64_t value);
  private:
  int64_t _internal_parameter_number() const;
  void _internal_set_parameter_number(int64_t value);
  public:

  // .xla.Kind kind = 4;
  void clear_kind();
  ::xla::Kind kind() const;
  void set_kind(::xla::Kind value);
  private:
  ::xla::Kind _internal_kind() const;
  void _internal_set_kind(::xla::Kind value);
  public:

  // @@protoc_insertion_point(class_scope:xla.HloInputOutputAliasProto.AliasEntryProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > output_shape_index_;
    mutable std::atomic<int> _output_shape_index_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > parameter_shape_index_;
    mutable std::atomic<int> _parameter_shape_index_cached_byte_size_;
    int64_t parameter_number_;
    int kind_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline HloInputOutputAliasProto& operator=(const HloInputOutputAliasProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloInputOutputAliasProto& operator=(HloInputOutputAliasProto&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloInputOutputAliasProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloInputOutputAliasProto* internal_default_instance() {
    return reinterpret_cast<const HloInputOutputAliasProto*>(
               &_HloInputOutputAliasProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(HloInputOutputAliasProto& a, HloInputOutputAliasProto& b) {
    a.Swap(&b);
  }
  inline void Swap(HloInputOutputAliasProto* 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(HloInputOutputAliasProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HloInputOutputAliasProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HloInputOutputAliasProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HloInputOutputAliasProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HloInputOutputAliasProto& from) {
    HloInputOutputAliasProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(HloInputOutputAliasProto* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef HloInputOutputAliasProto_AliasEntryProto AliasEntryProto;

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

  enum : int {
    kEntriesFieldNumber = 1,
  };
  // repeated .xla.HloInputOutputAliasProto.AliasEntryProto entries = 1;
  int entries_size() const;
  private:
  int _internal_entries_size() const;
  public:
  void clear_entries();
  ::xla::HloInputOutputAliasProto_AliasEntryProto* mutable_entries(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloInputOutputAliasProto_AliasEntryProto >*
      mutable_entries();
  private:
  const ::xla::HloInputOutputAliasProto_AliasEntryProto& _internal_entries(int index) const;
  ::xla::HloInputOutputAliasProto_AliasEntryProto* _internal_add_entries();
  public:
  const ::xla::HloInputOutputAliasProto_AliasEntryProto& entries(int index) const;
  ::xla::HloInputOutputAliasProto_AliasEntryProto* add_entries();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloInputOutputAliasProto_AliasEntryProto >&
      entries() const;

  // @@protoc_insertion_point(class_scope:xla.HloInputOutputAliasProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloInputOutputAliasProto_AliasEntryProto > entries_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

class DynamicParameterBindingProto_Binding final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.DynamicParameterBindingProto.Binding) */ {
 public:
  inline DynamicParameterBindingProto_Binding() : DynamicParameterBindingProto_Binding(nullptr) {}
  ~DynamicParameterBindingProto_Binding() override;
  explicit PROTOBUF_CONSTEXPR DynamicParameterBindingProto_Binding(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline DynamicParameterBindingProto_Binding& operator=(const DynamicParameterBindingProto_Binding& from) {
    CopyFrom(from);
    return *this;
  }
  inline DynamicParameterBindingProto_Binding& operator=(DynamicParameterBindingProto_Binding&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DynamicParameterBindingProto_Binding& default_instance() {
    return *internal_default_instance();
  }
  static inline const DynamicParameterBindingProto_Binding* internal_default_instance() {
    return reinterpret_cast<const DynamicParameterBindingProto_Binding*>(
               &_DynamicParameterBindingProto_Binding_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(DynamicParameterBindingProto_Binding& a, DynamicParameterBindingProto_Binding& b) {
    a.Swap(&b);
  }
  inline void Swap(DynamicParameterBindingProto_Binding* 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(DynamicParameterBindingProto_Binding* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DynamicParameterBindingProto_Binding* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DynamicParameterBindingProto_Binding>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DynamicParameterBindingProto_Binding& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const DynamicParameterBindingProto_Binding& from) {
    DynamicParameterBindingProto_Binding::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(DynamicParameterBindingProto_Binding* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDynamicParamIndexFieldNumber = 2,
    kTargetParamIndexFieldNumber = 4,
    kDynamicParamNumFieldNumber = 1,
    kTargetParamNumFieldNumber = 3,
    kTargetParamDimNumFieldNumber = 5,
  };
  // repeated int64 dynamic_param_index = 2;
  int dynamic_param_index_size() const;
  private:
  int _internal_dynamic_param_index_size() const;
  public:
  void clear_dynamic_param_index();
  private:
  int64_t _internal_dynamic_param_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_dynamic_param_index() const;
  void _internal_add_dynamic_param_index(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_dynamic_param_index();
  public:
  int64_t dynamic_param_index(int index) const;
  void set_dynamic_param_index(int index, int64_t value);
  void add_dynamic_param_index(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      dynamic_param_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_dynamic_param_index();

  // repeated int64 target_param_index = 4;
  int target_param_index_size() const;
  private:
  int _internal_target_param_index_size() const;
  public:
  void clear_target_param_index();
  private:
  int64_t _internal_target_param_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_target_param_index() const;
  void _internal_add_target_param_index(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_target_param_index();
  public:
  int64_t target_param_index(int index) const;
  void set_target_param_index(int index, int64_t value);
  void add_target_param_index(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      target_param_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_target_param_index();

  // int64 dynamic_param_num = 1;
  void clear_dynamic_param_num();
  int64_t dynamic_param_num() const;
  void set_dynamic_param_num(int64_t value);
  private:
  int64_t _internal_dynamic_param_num() const;
  void _internal_set_dynamic_param_num(int64_t value);
  public:

  // int64 target_param_num = 3;
  void clear_target_param_num();
  int64_t target_param_num() const;
  void set_target_param_num(int64_t value);
  private:
  int64_t _internal_target_param_num() const;
  void _internal_set_target_param_num(int64_t value);
  public:

  // int64 target_param_dim_num = 5;
  void clear_target_param_dim_num();
  int64_t target_param_dim_num() const;
  void set_target_param_dim_num(int64_t value);
  private:
  int64_t _internal_target_param_dim_num() const;
  void _internal_set_target_param_dim_num(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:xla.DynamicParameterBindingProto.Binding)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > dynamic_param_index_;
    mutable std::atomic<int> _dynamic_param_index_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > target_param_index_;
    mutable std::atomic<int> _target_param_index_cached_byte_size_;
    int64_t dynamic_param_num_;
    int64_t target_param_num_;
    int64_t target_param_dim_num_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline DynamicParameterBindingProto& operator=(const DynamicParameterBindingProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline DynamicParameterBindingProto& operator=(DynamicParameterBindingProto&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DynamicParameterBindingProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const DynamicParameterBindingProto* internal_default_instance() {
    return reinterpret_cast<const DynamicParameterBindingProto*>(
               &_DynamicParameterBindingProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(DynamicParameterBindingProto& a, DynamicParameterBindingProto& b) {
    a.Swap(&b);
  }
  inline void Swap(DynamicParameterBindingProto* 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(DynamicParameterBindingProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DynamicParameterBindingProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DynamicParameterBindingProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DynamicParameterBindingProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const DynamicParameterBindingProto& from) {
    DynamicParameterBindingProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(DynamicParameterBindingProto* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef DynamicParameterBindingProto_Binding Binding;

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

  enum : int {
    kEntriesFieldNumber = 1,
  };
  // repeated .xla.DynamicParameterBindingProto.Binding entries = 1;
  int entries_size() const;
  private:
  int _internal_entries_size() const;
  public:
  void clear_entries();
  ::xla::DynamicParameterBindingProto_Binding* mutable_entries(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DynamicParameterBindingProto_Binding >*
      mutable_entries();
  private:
  const ::xla::DynamicParameterBindingProto_Binding& _internal_entries(int index) const;
  ::xla::DynamicParameterBindingProto_Binding* _internal_add_entries();
  public:
  const ::xla::DynamicParameterBindingProto_Binding& entries(int index) const;
  ::xla::DynamicParameterBindingProto_Binding* add_entries();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DynamicParameterBindingProto_Binding >&
      entries() const;

  // @@protoc_insertion_point(class_scope:xla.DynamicParameterBindingProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DynamicParameterBindingProto_Binding > entries_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CrossProgramPrefetch& operator=(const CrossProgramPrefetch& from) {
    CopyFrom(from);
    return *this;
  }
  inline CrossProgramPrefetch& operator=(CrossProgramPrefetch&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CrossProgramPrefetch& default_instance() {
    return *internal_default_instance();
  }
  static inline const CrossProgramPrefetch* internal_default_instance() {
    return reinterpret_cast<const CrossProgramPrefetch*>(
               &_CrossProgramPrefetch_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(CrossProgramPrefetch& a, CrossProgramPrefetch& b) {
    a.Swap(&b);
  }
  inline void Swap(CrossProgramPrefetch* 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(CrossProgramPrefetch* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CrossProgramPrefetch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CrossProgramPrefetch>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CrossProgramPrefetch& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CrossProgramPrefetch& from) {
    CrossProgramPrefetch::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(CrossProgramPrefetch* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kIndexFieldNumber = 2,
    kParameterFieldNumber = 1,
    kOffsetFieldNumber = 3,
  };
  // repeated int64 index = 2;
  int index_size() const;
  private:
  int _internal_index_size() const;
  public:
  void clear_index();
  private:
  int64_t _internal_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_index() const;
  void _internal_add_index(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_index();
  public:
  int64_t index(int index) const;
  void set_index(int index, int64_t value);
  void add_index(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_index();

  // int64 parameter = 1;
  void clear_parameter();
  int64_t parameter() const;
  void set_parameter(int64_t value);
  private:
  int64_t _internal_parameter() const;
  void _internal_set_parameter(int64_t value);
  public:

  // int64 offset = 3;
  void clear_offset();
  int64_t offset() const;
  void set_offset(int64_t value);
  private:
  int64_t _internal_offset() const;
  void _internal_set_offset(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:xla.CrossProgramPrefetch)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > index_;
    mutable std::atomic<int> _index_cached_byte_size_;
    int64_t parameter_;
    int64_t offset_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

class HloModuleProto_ProfileInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.HloModuleProto.ProfileInfo) */ {
 public:
  inline HloModuleProto_ProfileInfo() : HloModuleProto_ProfileInfo(nullptr) {}
  ~HloModuleProto_ProfileInfo() override;
  explicit PROTOBUF_CONSTEXPR HloModuleProto_ProfileInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline HloModuleProto_ProfileInfo& operator=(const HloModuleProto_ProfileInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloModuleProto_ProfileInfo& operator=(HloModuleProto_ProfileInfo&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloModuleProto_ProfileInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloModuleProto_ProfileInfo* internal_default_instance() {
    return reinterpret_cast<const HloModuleProto_ProfileInfo*>(
               &_HloModuleProto_ProfileInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(HloModuleProto_ProfileInfo& a, HloModuleProto_ProfileInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(HloModuleProto_ProfileInfo* 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(HloModuleProto_ProfileInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HloModuleProto_ProfileInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HloModuleProto_ProfileInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HloModuleProto_ProfileInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HloModuleProto_ProfileInfo& from) {
    HloModuleProto_ProfileInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(HloModuleProto_ProfileInfo* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kRelativeSpeedupFieldNumber = 2,
    kProfileTypeFieldNumber = 1,
    kProfileSourceFieldNumber = 3,
    kCompilationEventFieldNumber = 4,
  };
  // double relative_speedup = 2;
  void clear_relative_speedup();
  double relative_speedup() const;
  void set_relative_speedup(double value);
  private:
  double _internal_relative_speedup() const;
  void _internal_set_relative_speedup(double value);
  public:

  // .xla.HloModuleProto.ProfileType profile_type = 1;
  void clear_profile_type();
  ::xla::HloModuleProto_ProfileType profile_type() const;
  void set_profile_type(::xla::HloModuleProto_ProfileType value);
  private:
  ::xla::HloModuleProto_ProfileType _internal_profile_type() const;
  void _internal_set_profile_type(::xla::HloModuleProto_ProfileType value);
  public:

  // .xla.ProfileSource profile_source = 3;
  void clear_profile_source();
  ::xla::ProfileSource profile_source() const;
  void set_profile_source(::xla::ProfileSource value);
  private:
  ::xla::ProfileSource _internal_profile_source() const;
  void _internal_set_profile_source(::xla::ProfileSource value);
  public:

  // .xla.CompilationEvent compilation_event = 4;
  void clear_compilation_event();
  ::xla::CompilationEvent compilation_event() const;
  void set_compilation_event(::xla::CompilationEvent value);
  private:
  ::xla::CompilationEvent _internal_compilation_event() const;
  void _internal_set_compilation_event(::xla::CompilationEvent value);
  public:

  // @@protoc_insertion_point(class_scope:xla.HloModuleProto.ProfileInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    double relative_speedup_;
    int profile_type_;
    int profile_source_;
    int compilation_event_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline HloModuleProto& operator=(const HloModuleProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloModuleProto& operator=(HloModuleProto&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloModuleProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloModuleProto* internal_default_instance() {
    return reinterpret_cast<const HloModuleProto*>(
               &_HloModuleProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(HloModuleProto& a, HloModuleProto& b) {
    a.Swap(&b);
  }
  inline void Swap(HloModuleProto* 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(HloModuleProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HloModuleProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HloModuleProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HloModuleProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HloModuleProto& from) {
    HloModuleProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(HloModuleProto* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef HloModuleProto_ProfileInfo ProfileInfo;

  typedef HloModuleProto_ProfileType ProfileType;
  static constexpr ProfileType INVALID =
    HloModuleProto_ProfileType_INVALID;
  static constexpr ProfileType FLAG =
    HloModuleProto_ProfileType_FLAG;
  static constexpr ProfileType FUSION =
    HloModuleProto_ProfileType_FUSION;
  static constexpr ProfileType LAYOUT =
    HloModuleProto_ProfileType_LAYOUT;
  static constexpr ProfileType DOT =
    HloModuleProto_ProfileType_DOT;
  static inline bool ProfileType_IsValid(int value) {
    return HloModuleProto_ProfileType_IsValid(value);
  }
  static constexpr ProfileType ProfileType_MIN =
    HloModuleProto_ProfileType_ProfileType_MIN;
  static constexpr ProfileType ProfileType_MAX =
    HloModuleProto_ProfileType_ProfileType_MAX;
  static constexpr int ProfileType_ARRAYSIZE =
    HloModuleProto_ProfileType_ProfileType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ProfileType_descriptor() {
    return HloModuleProto_ProfileType_descriptor();
  }
  template<typename T>
  static inline const std::string& ProfileType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ProfileType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ProfileType_Name.");
    return HloModuleProto_ProfileType_Name(enum_t_value);
  }
  static inline bool ProfileType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ProfileType* value) {
    return HloModuleProto_ProfileType_Parse(name, value);
  }

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

  enum : int {
    kComputationsFieldNumber = 3,
    kCrossProgramPrefetchesFieldNumber = 10,
    kProfileInfoFieldNumber = 13,
    kSpmdParametersShardingsFieldNumber = 14,
    kNameFieldNumber = 1,
    kEntryComputationNameFieldNumber = 2,
    kHostProgramShapeFieldNumber = 4,
    kScheduleFieldNumber = 7,
    kInputOutputAliasFieldNumber = 8,
    kDynamicParameterBindingFieldNumber = 9,
    kSpmdOutputShardingFieldNumber = 12,
    kDeviceAssignmentFieldNumber = 15,
    kIdFieldNumber = 5,
    kEntryComputationIdFieldNumber = 6,
    kIsDynamicFieldNumber = 11,
    kUseAutoSpmdPartitioningFieldNumber = 16,
  };
  // repeated .xla.HloComputationProto computations = 3;
  int computations_size() const;
  private:
  int _internal_computations_size() const;
  public:
  void clear_computations();
  ::xla::HloComputationProto* mutable_computations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloComputationProto >*
      mutable_computations();
  private:
  const ::xla::HloComputationProto& _internal_computations(int index) const;
  ::xla::HloComputationProto* _internal_add_computations();
  public:
  const ::xla::HloComputationProto& computations(int index) const;
  ::xla::HloComputationProto* add_computations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloComputationProto >&
      computations() const;

  // repeated .xla.CrossProgramPrefetch cross_program_prefetches = 10;
  int cross_program_prefetches_size() const;
  private:
  int _internal_cross_program_prefetches_size() const;
  public:
  void clear_cross_program_prefetches();
  ::xla::CrossProgramPrefetch* mutable_cross_program_prefetches(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::CrossProgramPrefetch >*
      mutable_cross_program_prefetches();
  private:
  const ::xla::CrossProgramPrefetch& _internal_cross_program_prefetches(int index) const;
  ::xla::CrossProgramPrefetch* _internal_add_cross_program_prefetches();
  public:
  const ::xla::CrossProgramPrefetch& cross_program_prefetches(int index) const;
  ::xla::CrossProgramPrefetch* add_cross_program_prefetches();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::CrossProgramPrefetch >&
      cross_program_prefetches() const;

  // repeated .xla.HloModuleProto.ProfileInfo profile_info = 13;
  int profile_info_size() const;
  private:
  int _internal_profile_info_size() const;
  public:
  void clear_profile_info();
  ::xla::HloModuleProto_ProfileInfo* mutable_profile_info(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleProto_ProfileInfo >*
      mutable_profile_info();
  private:
  const ::xla::HloModuleProto_ProfileInfo& _internal_profile_info(int index) const;
  ::xla::HloModuleProto_ProfileInfo* _internal_add_profile_info();
  public:
  const ::xla::HloModuleProto_ProfileInfo& profile_info(int index) const;
  ::xla::HloModuleProto_ProfileInfo* add_profile_info();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleProto_ProfileInfo >&
      profile_info() const;

  // repeated .xla.OpSharding spmd_parameters_shardings = 14;
  int spmd_parameters_shardings_size() const;
  private:
  int _internal_spmd_parameters_shardings_size() const;
  public:
  void clear_spmd_parameters_shardings();
  ::xla::OpSharding* mutable_spmd_parameters_shardings(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::OpSharding >*
      mutable_spmd_parameters_shardings();
  private:
  const ::xla::OpSharding& _internal_spmd_parameters_shardings(int index) const;
  ::xla::OpSharding* _internal_add_spmd_parameters_shardings();
  public:
  const ::xla::OpSharding& spmd_parameters_shardings(int index) const;
  ::xla::OpSharding* add_spmd_parameters_shardings();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::OpSharding >&
      spmd_parameters_shardings() const;

  // string name = 1;
  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:

  // string entry_computation_name = 2;
  void clear_entry_computation_name();
  const std::string& entry_computation_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_entry_computation_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_entry_computation_name();
  PROTOBUF_NODISCARD std::string* release_entry_computation_name();
  void set_allocated_entry_computation_name(std::string* entry_computation_name);
  private:
  const std::string& _internal_entry_computation_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_entry_computation_name(const std::string& value);
  std::string* _internal_mutable_entry_computation_name();
  public:

  // .xla.ProgramShapeProto host_program_shape = 4;
  bool has_host_program_shape() const;
  private:
  bool _internal_has_host_program_shape() const;
  public:
  void clear_host_program_shape();
  const ::xla::ProgramShapeProto& host_program_shape() const;
  PROTOBUF_NODISCARD ::xla::ProgramShapeProto* release_host_program_shape();
  ::xla::ProgramShapeProto* mutable_host_program_shape();
  void set_allocated_host_program_shape(::xla::ProgramShapeProto* host_program_shape);
  private:
  const ::xla::ProgramShapeProto& _internal_host_program_shape() const;
  ::xla::ProgramShapeProto* _internal_mutable_host_program_shape();
  public:
  void unsafe_arena_set_allocated_host_program_shape(
      ::xla::ProgramShapeProto* host_program_shape);
  ::xla::ProgramShapeProto* unsafe_arena_release_host_program_shape();

  // .xla.HloScheduleProto schedule = 7;
  bool has_schedule() const;
  private:
  bool _internal_has_schedule() const;
  public:
  void clear_schedule();
  const ::xla::HloScheduleProto& schedule() const;
  PROTOBUF_NODISCARD ::xla::HloScheduleProto* release_schedule();
  ::xla::HloScheduleProto* mutable_schedule();
  void set_allocated_schedule(::xla::HloScheduleProto* schedule);
  private:
  const ::xla::HloScheduleProto& _internal_schedule() const;
  ::xla::HloScheduleProto* _internal_mutable_schedule();
  public:
  void unsafe_arena_set_allocated_schedule(
      ::xla::HloScheduleProto* schedule);
  ::xla::HloScheduleProto* unsafe_arena_release_schedule();

  // .xla.HloInputOutputAliasProto input_output_alias = 8;
  bool has_input_output_alias() const;
  private:
  bool _internal_has_input_output_alias() const;
  public:
  void clear_input_output_alias();
  const ::xla::HloInputOutputAliasProto& input_output_alias() const;
  PROTOBUF_NODISCARD ::xla::HloInputOutputAliasProto* release_input_output_alias();
  ::xla::HloInputOutputAliasProto* mutable_input_output_alias();
  void set_allocated_input_output_alias(::xla::HloInputOutputAliasProto* input_output_alias);
  private:
  const ::xla::HloInputOutputAliasProto& _internal_input_output_alias() const;
  ::xla::HloInputOutputAliasProto* _internal_mutable_input_output_alias();
  public:
  void unsafe_arena_set_allocated_input_output_alias(
      ::xla::HloInputOutputAliasProto* input_output_alias);
  ::xla::HloInputOutputAliasProto* unsafe_arena_release_input_output_alias();

  // .xla.DynamicParameterBindingProto dynamic_parameter_binding = 9;
  bool has_dynamic_parameter_binding() const;
  private:
  bool _internal_has_dynamic_parameter_binding() const;
  public:
  void clear_dynamic_parameter_binding();
  const ::xla::DynamicParameterBindingProto& dynamic_parameter_binding() const;
  PROTOBUF_NODISCARD ::xla::DynamicParameterBindingProto* release_dynamic_parameter_binding();
  ::xla::DynamicParameterBindingProto* mutable_dynamic_parameter_binding();
  void set_allocated_dynamic_parameter_binding(::xla::DynamicParameterBindingProto* dynamic_parameter_binding);
  private:
  const ::xla::DynamicParameterBindingProto& _internal_dynamic_parameter_binding() const;
  ::xla::DynamicParameterBindingProto* _internal_mutable_dynamic_parameter_binding();
  public:
  void unsafe_arena_set_allocated_dynamic_parameter_binding(
      ::xla::DynamicParameterBindingProto* dynamic_parameter_binding);
  ::xla::DynamicParameterBindingProto* unsafe_arena_release_dynamic_parameter_binding();

  // .xla.OpSharding spmd_output_sharding = 12;
  bool has_spmd_output_sharding() const;
  private:
  bool _internal_has_spmd_output_sharding() const;
  public:
  void clear_spmd_output_sharding();
  const ::xla::OpSharding& spmd_output_sharding() const;
  PROTOBUF_NODISCARD ::xla::OpSharding* release_spmd_output_sharding();
  ::xla::OpSharding* mutable_spmd_output_sharding();
  void set_allocated_spmd_output_sharding(::xla::OpSharding* spmd_output_sharding);
  private:
  const ::xla::OpSharding& _internal_spmd_output_sharding() const;
  ::xla::OpSharding* _internal_mutable_spmd_output_sharding();
  public:
  void unsafe_arena_set_allocated_spmd_output_sharding(
      ::xla::OpSharding* spmd_output_sharding);
  ::xla::OpSharding* unsafe_arena_release_spmd_output_sharding();

  // .xla.DeviceAssignmentProto device_assignment = 15;
  bool has_device_assignment() const;
  private:
  bool _internal_has_device_assignment() const;
  public:
  void clear_device_assignment();
  const ::xla::DeviceAssignmentProto& device_assignment() const;
  PROTOBUF_NODISCARD ::xla::DeviceAssignmentProto* release_device_assignment();
  ::xla::DeviceAssignmentProto* mutable_device_assignment();
  void set_allocated_device_assignment(::xla::DeviceAssignmentProto* device_assignment);
  private:
  const ::xla::DeviceAssignmentProto& _internal_device_assignment() const;
  ::xla::DeviceAssignmentProto* _internal_mutable_device_assignment();
  public:
  void unsafe_arena_set_allocated_device_assignment(
      ::xla::DeviceAssignmentProto* device_assignment);
  ::xla::DeviceAssignmentProto* unsafe_arena_release_device_assignment();

  // int64 id = 5;
  void clear_id();
  int64_t id() const;
  void set_id(int64_t value);
  private:
  int64_t _internal_id() const;
  void _internal_set_id(int64_t value);
  public:

  // int64 entry_computation_id = 6;
  void clear_entry_computation_id();
  int64_t entry_computation_id() const;
  void set_entry_computation_id(int64_t value);
  private:
  int64_t _internal_entry_computation_id() const;
  void _internal_set_entry_computation_id(int64_t value);
  public:

  // bool is_dynamic = 11;
  void clear_is_dynamic();
  bool is_dynamic() const;
  void set_is_dynamic(bool value);
  private:
  bool _internal_is_dynamic() const;
  void _internal_set_is_dynamic(bool value);
  public:

  // bool use_auto_spmd_partitioning = 16;
  void clear_use_auto_spmd_partitioning();
  bool use_auto_spmd_partitioning() const;
  void set_use_auto_spmd_partitioning(bool value);
  private:
  bool _internal_use_auto_spmd_partitioning() const;
  void _internal_set_use_auto_spmd_partitioning(bool value);
  public:

  // @@protoc_insertion_point(class_scope:xla.HloModuleProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloComputationProto > computations_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::CrossProgramPrefetch > cross_program_prefetches_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleProto_ProfileInfo > profile_info_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::OpSharding > spmd_parameters_shardings_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entry_computation_name_;
    ::xla::ProgramShapeProto* host_program_shape_;
    ::xla::HloScheduleProto* schedule_;
    ::xla::HloInputOutputAliasProto* input_output_alias_;
    ::xla::DynamicParameterBindingProto* dynamic_parameter_binding_;
    ::xla::OpSharding* spmd_output_sharding_;
    ::xla::DeviceAssignmentProto* device_assignment_;
    int64_t id_;
    int64_t entry_computation_id_;
    bool is_dynamic_;
    bool use_auto_spmd_partitioning_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

class LogicalBufferProto_Location final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.LogicalBufferProto.Location) */ {
 public:
  inline LogicalBufferProto_Location() : LogicalBufferProto_Location(nullptr) {}
  ~LogicalBufferProto_Location() override;
  explicit PROTOBUF_CONSTEXPR LogicalBufferProto_Location(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline LogicalBufferProto_Location& operator=(const LogicalBufferProto_Location& from) {
    CopyFrom(from);
    return *this;
  }
  inline LogicalBufferProto_Location& operator=(LogicalBufferProto_Location&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LogicalBufferProto_Location& default_instance() {
    return *internal_default_instance();
  }
  static inline const LogicalBufferProto_Location* internal_default_instance() {
    return reinterpret_cast<const LogicalBufferProto_Location*>(
               &_LogicalBufferProto_Location_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(LogicalBufferProto_Location& a, LogicalBufferProto_Location& b) {
    a.Swap(&b);
  }
  inline void Swap(LogicalBufferProto_Location* 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(LogicalBufferProto_Location* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LogicalBufferProto_Location* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LogicalBufferProto_Location>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LogicalBufferProto_Location& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LogicalBufferProto_Location& from) {
    LogicalBufferProto_Location::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(LogicalBufferProto_Location* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kShapeIndexFieldNumber = 3,
    kInstructionNameFieldNumber = 2,
    kInstructionIdFieldNumber = 4,
  };
  // repeated int64 shape_index = 3;
  int shape_index_size() const;
  private:
  int _internal_shape_index_size() const;
  public:
  void clear_shape_index();
  private:
  int64_t _internal_shape_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_shape_index() const;
  void _internal_add_shape_index(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_shape_index();
  public:
  int64_t shape_index(int index) const;
  void set_shape_index(int index, int64_t value);
  void add_shape_index(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      shape_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_shape_index();

  // string instruction_name = 2 [deprecated = true];
  PROTOBUF_DEPRECATED void clear_instruction_name();
  PROTOBUF_DEPRECATED const std::string& instruction_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  PROTOBUF_DEPRECATED void set_instruction_name(ArgT0&& arg0, ArgT... args);
  PROTOBUF_DEPRECATED std::string* mutable_instruction_name();
  PROTOBUF_NODISCARD PROTOBUF_DEPRECATED std::string* release_instruction_name();
  PROTOBUF_DEPRECATED void set_allocated_instruction_name(std::string* instruction_name);
  private:
  const std::string& _internal_instruction_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_instruction_name(const std::string& value);
  std::string* _internal_mutable_instruction_name();
  public:

  // int64 instruction_id = 4;
  void clear_instruction_id();
  int64_t instruction_id() const;
  void set_instruction_id(int64_t value);
  private:
  int64_t _internal_instruction_id() const;
  void _internal_set_instruction_id(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:xla.LogicalBufferProto.Location)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > shape_index_;
    mutable std::atomic<int> _shape_index_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr instruction_name_;
    int64_t instruction_id_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline LogicalBufferProto& operator=(const LogicalBufferProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline LogicalBufferProto& operator=(LogicalBufferProto&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LogicalBufferProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const LogicalBufferProto* internal_default_instance() {
    return reinterpret_cast<const LogicalBufferProto*>(
               &_LogicalBufferProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(LogicalBufferProto& a, LogicalBufferProto& b) {
    a.Swap(&b);
  }
  inline void Swap(LogicalBufferProto* 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(LogicalBufferProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LogicalBufferProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LogicalBufferProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LogicalBufferProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LogicalBufferProto& from) {
    LogicalBufferProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(LogicalBufferProto* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef LogicalBufferProto_Location Location;

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

  enum : int {
    kDefinedAtFieldNumber = 3,
    kIdFieldNumber = 1,
    kSizeFieldNumber = 2,
    kColorFieldNumber = 4,
  };
  // .xla.LogicalBufferProto.Location defined_at = 3;
  bool has_defined_at() const;
  private:
  bool _internal_has_defined_at() const;
  public:
  void clear_defined_at();
  const ::xla::LogicalBufferProto_Location& defined_at() const;
  PROTOBUF_NODISCARD ::xla::LogicalBufferProto_Location* release_defined_at();
  ::xla::LogicalBufferProto_Location* mutable_defined_at();
  void set_allocated_defined_at(::xla::LogicalBufferProto_Location* defined_at);
  private:
  const ::xla::LogicalBufferProto_Location& _internal_defined_at() const;
  ::xla::LogicalBufferProto_Location* _internal_mutable_defined_at();
  public:
  void unsafe_arena_set_allocated_defined_at(
      ::xla::LogicalBufferProto_Location* defined_at);
  ::xla::LogicalBufferProto_Location* unsafe_arena_release_defined_at();

  // int64 id = 1;
  void clear_id();
  int64_t id() const;
  void set_id(int64_t value);
  private:
  int64_t _internal_id() const;
  void _internal_set_id(int64_t value);
  public:

  // int64 size = 2;
  void clear_size();
  int64_t size() const;
  void set_size(int64_t value);
  private:
  int64_t _internal_size() const;
  void _internal_set_size(int64_t value);
  public:

  // int64 color = 4;
  void clear_color();
  int64_t color() const;
  void set_color(int64_t value);
  private:
  int64_t _internal_color() const;
  void _internal_set_color(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:xla.LogicalBufferProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::xla::LogicalBufferProto_Location* defined_at_;
    int64_t id_;
    int64_t size_;
    int64_t color_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

class BufferAllocationProto_Assigned final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.BufferAllocationProto.Assigned) */ {
 public:
  inline BufferAllocationProto_Assigned() : BufferAllocationProto_Assigned(nullptr) {}
  ~BufferAllocationProto_Assigned() override;
  explicit PROTOBUF_CONSTEXPR BufferAllocationProto_Assigned(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline BufferAllocationProto_Assigned& operator=(const BufferAllocationProto_Assigned& from) {
    CopyFrom(from);
    return *this;
  }
  inline BufferAllocationProto_Assigned& operator=(BufferAllocationProto_Assigned&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BufferAllocationProto_Assigned& default_instance() {
    return *internal_default_instance();
  }
  static inline const BufferAllocationProto_Assigned* internal_default_instance() {
    return reinterpret_cast<const BufferAllocationProto_Assigned*>(
               &_BufferAllocationProto_Assigned_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(BufferAllocationProto_Assigned& a, BufferAllocationProto_Assigned& b) {
    a.Swap(&b);
  }
  inline void Swap(BufferAllocationProto_Assigned* 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(BufferAllocationProto_Assigned* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BufferAllocationProto_Assigned* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BufferAllocationProto_Assigned>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BufferAllocationProto_Assigned& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BufferAllocationProto_Assigned& from) {
    BufferAllocationProto_Assigned::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(BufferAllocationProto_Assigned* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kLogicalBufferIdFieldNumber = 1,
    kOffsetFieldNumber = 2,
    kSizeFieldNumber = 3,
  };
  // int64 logical_buffer_id = 1;
  void clear_logical_buffer_id();
  int64_t logical_buffer_id() const;
  void set_logical_buffer_id(int64_t value);
  private:
  int64_t _internal_logical_buffer_id() const;
  void _internal_set_logical_buffer_id(int64_t value);
  public:

  // int64 offset = 2;
  void clear_offset();
  int64_t offset() const;
  void set_offset(int64_t value);
  private:
  int64_t _internal_offset() const;
  void _internal_set_offset(int64_t value);
  public:

  // int64 size = 3;
  void clear_size();
  int64_t size() const;
  void set_size(int64_t value);
  private:
  int64_t _internal_size() const;
  void _internal_set_size(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:xla.BufferAllocationProto.Assigned)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    int64_t logical_buffer_id_;
    int64_t offset_;
    int64_t size_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline BufferAllocationProto& operator=(const BufferAllocationProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline BufferAllocationProto& operator=(BufferAllocationProto&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BufferAllocationProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const BufferAllocationProto* internal_default_instance() {
    return reinterpret_cast<const BufferAllocationProto*>(
               &_BufferAllocationProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(BufferAllocationProto& a, BufferAllocationProto& b) {
    a.Swap(&b);
  }
  inline void Swap(BufferAllocationProto* 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(BufferAllocationProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BufferAllocationProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BufferAllocationProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BufferAllocationProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BufferAllocationProto& from) {
    BufferAllocationProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(BufferAllocationProto* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef BufferAllocationProto_Assigned Assigned;

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

  enum : int {
    kAssignedFieldNumber = 9,
    kParameterShapeIndexFieldNumber = 10,
    kIndexFieldNumber = 1,
    kSizeFieldNumber = 2,
    kParameterNumberFieldNumber = 6,
    kMaybeLiveOutFieldNumber = 7,
    kIsThreadLocalFieldNumber = 3,
    kIsTupleFieldNumber = 11,
    kIsEntryComputationParameterFieldNumber = 5,
    kIsConstantFieldNumber = 12,
    kColorFieldNumber = 8,
  };
  // repeated .xla.BufferAllocationProto.Assigned assigned = 9;
  int assigned_size() const;
  private:
  int _internal_assigned_size() const;
  public:
  void clear_assigned();
  ::xla::BufferAllocationProto_Assigned* mutable_assigned(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::BufferAllocationProto_Assigned >*
      mutable_assigned();
  private:
  const ::xla::BufferAllocationProto_Assigned& _internal_assigned(int index) const;
  ::xla::BufferAllocationProto_Assigned* _internal_add_assigned();
  public:
  const ::xla::BufferAllocationProto_Assigned& assigned(int index) const;
  ::xla::BufferAllocationProto_Assigned* add_assigned();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::BufferAllocationProto_Assigned >&
      assigned() const;

  // repeated int64 parameter_shape_index = 10;
  int parameter_shape_index_size() const;
  private:
  int _internal_parameter_shape_index_size() const;
  public:
  void clear_parameter_shape_index();
  private:
  int64_t _internal_parameter_shape_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_parameter_shape_index() const;
  void _internal_add_parameter_shape_index(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_parameter_shape_index();
  public:
  int64_t parameter_shape_index(int index) const;
  void set_parameter_shape_index(int index, int64_t value);
  void add_parameter_shape_index(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      parameter_shape_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_parameter_shape_index();

  // int64 index = 1;
  void clear_index();
  int64_t index() const;
  void set_index(int64_t value);
  private:
  int64_t _internal_index() const;
  void _internal_set_index(int64_t value);
  public:

  // int64 size = 2;
  void clear_size();
  int64_t size() const;
  void set_size(int64_t value);
  private:
  int64_t _internal_size() const;
  void _internal_set_size(int64_t value);
  public:

  // int64 parameter_number = 6;
  void clear_parameter_number();
  int64_t parameter_number() const;
  void set_parameter_number(int64_t value);
  private:
  int64_t _internal_parameter_number() const;
  void _internal_set_parameter_number(int64_t value);
  public:

  // bool maybe_live_out = 7;
  void clear_maybe_live_out();
  bool maybe_live_out() const;
  void set_maybe_live_out(bool value);
  private:
  bool _internal_maybe_live_out() const;
  void _internal_set_maybe_live_out(bool value);
  public:

  // bool is_thread_local = 3;
  void clear_is_thread_local();
  bool is_thread_local() const;
  void set_is_thread_local(bool value);
  private:
  bool _internal_is_thread_local() const;
  void _internal_set_is_thread_local(bool value);
  public:

  // bool is_tuple = 11;
  void clear_is_tuple();
  bool is_tuple() const;
  void set_is_tuple(bool value);
  private:
  bool _internal_is_tuple() const;
  void _internal_set_is_tuple(bool value);
  public:

  // bool is_entry_computation_parameter = 5;
  void clear_is_entry_computation_parameter();
  bool is_entry_computation_parameter() const;
  void set_is_entry_computation_parameter(bool value);
  private:
  bool _internal_is_entry_computation_parameter() const;
  void _internal_set_is_entry_computation_parameter(bool value);
  public:

  // bool is_constant = 12;
  void clear_is_constant();
  bool is_constant() const;
  void set_is_constant(bool value);
  private:
  bool _internal_is_constant() const;
  void _internal_set_is_constant(bool value);
  public:

  // int64 color = 8;
  void clear_color();
  int64_t color() const;
  void set_color(int64_t value);
  private:
  int64_t _internal_color() const;
  void _internal_set_color(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:xla.BufferAllocationProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::BufferAllocationProto_Assigned > assigned_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > parameter_shape_index_;
    mutable std::atomic<int> _parameter_shape_index_cached_byte_size_;
    int64_t index_;
    int64_t size_;
    int64_t parameter_number_;
    bool maybe_live_out_;
    bool is_thread_local_;
    bool is_tuple_;
    bool is_entry_computation_parameter_;
    bool is_constant_;
    int64_t color_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

class HeapSimulatorTrace_Event final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.HeapSimulatorTrace.Event) */ {
 public:
  inline HeapSimulatorTrace_Event() : HeapSimulatorTrace_Event(nullptr) {}
  ~HeapSimulatorTrace_Event() override;
  explicit PROTOBUF_CONSTEXPR HeapSimulatorTrace_Event(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline HeapSimulatorTrace_Event& operator=(const HeapSimulatorTrace_Event& from) {
    CopyFrom(from);
    return *this;
  }
  inline HeapSimulatorTrace_Event& operator=(HeapSimulatorTrace_Event&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HeapSimulatorTrace_Event& default_instance() {
    return *internal_default_instance();
  }
  static inline const HeapSimulatorTrace_Event* internal_default_instance() {
    return reinterpret_cast<const HeapSimulatorTrace_Event*>(
               &_HeapSimulatorTrace_Event_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(HeapSimulatorTrace_Event& a, HeapSimulatorTrace_Event& b) {
    a.Swap(&b);
  }
  inline void Swap(HeapSimulatorTrace_Event* 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(HeapSimulatorTrace_Event* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HeapSimulatorTrace_Event* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HeapSimulatorTrace_Event>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HeapSimulatorTrace_Event& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HeapSimulatorTrace_Event& from) {
    HeapSimulatorTrace_Event::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(HeapSimulatorTrace_Event* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef HeapSimulatorTrace_Event_Kind Kind;
  static constexpr Kind ALLOC =
    HeapSimulatorTrace_Event_Kind_ALLOC;
  static constexpr Kind FREE =
    HeapSimulatorTrace_Event_Kind_FREE;
  static constexpr Kind SHARE_WITH =
    HeapSimulatorTrace_Event_Kind_SHARE_WITH;
  static inline bool Kind_IsValid(int value) {
    return HeapSimulatorTrace_Event_Kind_IsValid(value);
  }
  static constexpr Kind Kind_MIN =
    HeapSimulatorTrace_Event_Kind_Kind_MIN;
  static constexpr Kind Kind_MAX =
    HeapSimulatorTrace_Event_Kind_Kind_MAX;
  static constexpr int Kind_ARRAYSIZE =
    HeapSimulatorTrace_Event_Kind_Kind_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Kind_descriptor() {
    return HeapSimulatorTrace_Event_Kind_descriptor();
  }
  template<typename T>
  static inline const std::string& Kind_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Kind>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Kind_Name.");
    return HeapSimulatorTrace_Event_Kind_Name(enum_t_value);
  }
  static inline bool Kind_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Kind* value) {
    return HeapSimulatorTrace_Event_Kind_Parse(name, value);
  }

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

  enum : int {
    kComputationNameFieldNumber = 3,
    kInstructionNameFieldNumber = 4,
    kBufferIdFieldNumber = 2,
    kShareWithCanonicalIdFieldNumber = 5,
    kKindFieldNumber = 1,
  };
  // string computation_name = 3;
  void clear_computation_name();
  const std::string& computation_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_computation_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_computation_name();
  PROTOBUF_NODISCARD std::string* release_computation_name();
  void set_allocated_computation_name(std::string* computation_name);
  private:
  const std::string& _internal_computation_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_computation_name(const std::string& value);
  std::string* _internal_mutable_computation_name();
  public:

  // string instruction_name = 4;
  void clear_instruction_name();
  const std::string& instruction_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_instruction_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_instruction_name();
  PROTOBUF_NODISCARD std::string* release_instruction_name();
  void set_allocated_instruction_name(std::string* instruction_name);
  private:
  const std::string& _internal_instruction_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_instruction_name(const std::string& value);
  std::string* _internal_mutable_instruction_name();
  public:

  // int64 buffer_id = 2;
  void clear_buffer_id();
  int64_t buffer_id() const;
  void set_buffer_id(int64_t value);
  private:
  int64_t _internal_buffer_id() const;
  void _internal_set_buffer_id(int64_t value);
  public:

  // int64 share_with_canonical_id = 5;
  void clear_share_with_canonical_id();
  int64_t share_with_canonical_id() const;
  void set_share_with_canonical_id(int64_t value);
  private:
  int64_t _internal_share_with_canonical_id() const;
  void _internal_set_share_with_canonical_id(int64_t value);
  public:

  // .xla.HeapSimulatorTrace.Event.Kind kind = 1;
  void clear_kind();
  ::xla::HeapSimulatorTrace_Event_Kind kind() const;
  void set_kind(::xla::HeapSimulatorTrace_Event_Kind value);
  private:
  ::xla::HeapSimulatorTrace_Event_Kind _internal_kind() const;
  void _internal_set_kind(::xla::HeapSimulatorTrace_Event_Kind value);
  public:

  // @@protoc_insertion_point(class_scope:xla.HeapSimulatorTrace.Event)
 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::ArenaStringPtr computation_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr instruction_name_;
    int64_t buffer_id_;
    int64_t share_with_canonical_id_;
    int kind_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline HeapSimulatorTrace& operator=(const HeapSimulatorTrace& from) {
    CopyFrom(from);
    return *this;
  }
  inline HeapSimulatorTrace& operator=(HeapSimulatorTrace&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HeapSimulatorTrace& default_instance() {
    return *internal_default_instance();
  }
  static inline const HeapSimulatorTrace* internal_default_instance() {
    return reinterpret_cast<const HeapSimulatorTrace*>(
               &_HeapSimulatorTrace_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(HeapSimulatorTrace& a, HeapSimulatorTrace& b) {
    a.Swap(&b);
  }
  inline void Swap(HeapSimulatorTrace* 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(HeapSimulatorTrace* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HeapSimulatorTrace* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HeapSimulatorTrace>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HeapSimulatorTrace& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HeapSimulatorTrace& from) {
    HeapSimulatorTrace::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(HeapSimulatorTrace* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef HeapSimulatorTrace_Event Event;

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

  enum : int {
    kEventsFieldNumber = 1,
    kBufferAllocationIndexFieldNumber = 3,
    kWholeModuleSimulationFieldNumber = 2,
  };
  // repeated .xla.HeapSimulatorTrace.Event events = 1;
  int events_size() const;
  private:
  int _internal_events_size() const;
  public:
  void clear_events();
  ::xla::HeapSimulatorTrace_Event* mutable_events(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HeapSimulatorTrace_Event >*
      mutable_events();
  private:
  const ::xla::HeapSimulatorTrace_Event& _internal_events(int index) const;
  ::xla::HeapSimulatorTrace_Event* _internal_add_events();
  public:
  const ::xla::HeapSimulatorTrace_Event& events(int index) const;
  ::xla::HeapSimulatorTrace_Event* add_events();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HeapSimulatorTrace_Event >&
      events() const;

  // int64 buffer_allocation_index = 3;
  void clear_buffer_allocation_index();
  int64_t buffer_allocation_index() const;
  void set_buffer_allocation_index(int64_t value);
  private:
  int64_t _internal_buffer_allocation_index() const;
  void _internal_set_buffer_allocation_index(int64_t value);
  public:

  // bool whole_module_simulation = 2;
  void clear_whole_module_simulation();
  bool whole_module_simulation() const;
  void set_whole_module_simulation(bool value);
  private:
  bool _internal_whole_module_simulation() const;
  void _internal_set_whole_module_simulation(bool value);
  public:

  // @@protoc_insertion_point(class_scope:xla.HeapSimulatorTrace)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HeapSimulatorTrace_Event > events_;
    int64_t buffer_allocation_index_;
    bool whole_module_simulation_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline HloModuleGroupProto& operator=(const HloModuleGroupProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloModuleGroupProto& operator=(HloModuleGroupProto&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloModuleGroupProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloModuleGroupProto* internal_default_instance() {
    return reinterpret_cast<const HloModuleGroupProto*>(
               &_HloModuleGroupProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  friend void swap(HloModuleGroupProto& a, HloModuleGroupProto& b) {
    a.Swap(&b);
  }
  inline void Swap(HloModuleGroupProto* 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(HloModuleGroupProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HloModuleGroupProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HloModuleGroupProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HloModuleGroupProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HloModuleGroupProto& from) {
    HloModuleGroupProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(HloModuleGroupProto* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kHloModulesFieldNumber = 2,
    kNameFieldNumber = 1,
  };
  // repeated .xla.HloModuleProto hlo_modules = 2;
  int hlo_modules_size() const;
  private:
  int _internal_hlo_modules_size() const;
  public:
  void clear_hlo_modules();
  ::xla::HloModuleProto* mutable_hlo_modules(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleProto >*
      mutable_hlo_modules();
  private:
  const ::xla::HloModuleProto& _internal_hlo_modules(int index) const;
  ::xla::HloModuleProto* _internal_add_hlo_modules();
  public:
  const ::xla::HloModuleProto& hlo_modules(int index) const;
  ::xla::HloModuleProto* add_hlo_modules();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleProto >&
      hlo_modules() const;

  // string name = 1;
  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:

  // @@protoc_insertion_point(class_scope:xla.HloModuleGroupProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleProto > hlo_modules_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

class BufferAssignmentProto_BufferAlias final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.BufferAssignmentProto.BufferAlias) */ {
 public:
  inline BufferAssignmentProto_BufferAlias() : BufferAssignmentProto_BufferAlias(nullptr) {}
  ~BufferAssignmentProto_BufferAlias() override;
  explicit PROTOBUF_CONSTEXPR BufferAssignmentProto_BufferAlias(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline BufferAssignmentProto_BufferAlias& operator=(const BufferAssignmentProto_BufferAlias& from) {
    CopyFrom(from);
    return *this;
  }
  inline BufferAssignmentProto_BufferAlias& operator=(BufferAssignmentProto_BufferAlias&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BufferAssignmentProto_BufferAlias& default_instance() {
    return *internal_default_instance();
  }
  static inline const BufferAssignmentProto_BufferAlias* internal_default_instance() {
    return reinterpret_cast<const BufferAssignmentProto_BufferAlias*>(
               &_BufferAssignmentProto_BufferAlias_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  friend void swap(BufferAssignmentProto_BufferAlias& a, BufferAssignmentProto_BufferAlias& b) {
    a.Swap(&b);
  }
  inline void Swap(BufferAssignmentProto_BufferAlias* 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(BufferAssignmentProto_BufferAlias* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BufferAssignmentProto_BufferAlias* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BufferAssignmentProto_BufferAlias>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BufferAssignmentProto_BufferAlias& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BufferAssignmentProto_BufferAlias& from) {
    BufferAssignmentProto_BufferAlias::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(BufferAssignmentProto_BufferAlias* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kLocationFieldNumber = 2,
    kSourceBufferIdFieldNumber = 1,
  };
  // .xla.LogicalBufferProto.Location location = 2;
  bool has_location() const;
  private:
  bool _internal_has_location() const;
  public:
  void clear_location();
  const ::xla::LogicalBufferProto_Location& location() const;
  PROTOBUF_NODISCARD ::xla::LogicalBufferProto_Location* release_location();
  ::xla::LogicalBufferProto_Location* mutable_location();
  void set_allocated_location(::xla::LogicalBufferProto_Location* location);
  private:
  const ::xla::LogicalBufferProto_Location& _internal_location() const;
  ::xla::LogicalBufferProto_Location* _internal_mutable_location();
  public:
  void unsafe_arena_set_allocated_location(
      ::xla::LogicalBufferProto_Location* location);
  ::xla::LogicalBufferProto_Location* unsafe_arena_release_location();

  // int64 source_buffer_id = 1;
  void clear_source_buffer_id();
  int64_t source_buffer_id() const;
  void set_source_buffer_id(int64_t value);
  private:
  int64_t _internal_source_buffer_id() const;
  void _internal_set_source_buffer_id(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:xla.BufferAssignmentProto.BufferAlias)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::xla::LogicalBufferProto_Location* location_;
    int64_t source_buffer_id_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline BufferAssignmentProto& operator=(const BufferAssignmentProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline BufferAssignmentProto& operator=(BufferAssignmentProto&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BufferAssignmentProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const BufferAssignmentProto* internal_default_instance() {
    return reinterpret_cast<const BufferAssignmentProto*>(
               &_BufferAssignmentProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  friend void swap(BufferAssignmentProto& a, BufferAssignmentProto& b) {
    a.Swap(&b);
  }
  inline void Swap(BufferAssignmentProto* 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(BufferAssignmentProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BufferAssignmentProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BufferAssignmentProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BufferAssignmentProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BufferAssignmentProto& from) {
    BufferAssignmentProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(BufferAssignmentProto* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef BufferAssignmentProto_BufferAlias BufferAlias;

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

  enum : int {
    kLogicalBuffersFieldNumber = 1,
    kBufferAliasesFieldNumber = 2,
    kBufferAllocationsFieldNumber = 3,
    kHeapSimulatorTracesFieldNumber = 4,
  };
  // repeated .xla.LogicalBufferProto logical_buffers = 1;
  int logical_buffers_size() const;
  private:
  int _internal_logical_buffers_size() const;
  public:
  void clear_logical_buffers();
  ::xla::LogicalBufferProto* mutable_logical_buffers(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LogicalBufferProto >*
      mutable_logical_buffers();
  private:
  const ::xla::LogicalBufferProto& _internal_logical_buffers(int index) const;
  ::xla::LogicalBufferProto* _internal_add_logical_buffers();
  public:
  const ::xla::LogicalBufferProto& logical_buffers(int index) const;
  ::xla::LogicalBufferProto* add_logical_buffers();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LogicalBufferProto >&
      logical_buffers() const;

  // repeated .xla.BufferAssignmentProto.BufferAlias buffer_aliases = 2;
  int buffer_aliases_size() const;
  private:
  int _internal_buffer_aliases_size() const;
  public:
  void clear_buffer_aliases();
  ::xla::BufferAssignmentProto_BufferAlias* mutable_buffer_aliases(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::BufferAssignmentProto_BufferAlias >*
      mutable_buffer_aliases();
  private:
  const ::xla::BufferAssignmentProto_BufferAlias& _internal_buffer_aliases(int index) const;
  ::xla::BufferAssignmentProto_BufferAlias* _internal_add_buffer_aliases();
  public:
  const ::xla::BufferAssignmentProto_BufferAlias& buffer_aliases(int index) const;
  ::xla::BufferAssignmentProto_BufferAlias* add_buffer_aliases();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::BufferAssignmentProto_BufferAlias >&
      buffer_aliases() const;

  // repeated .xla.BufferAllocationProto buffer_allocations = 3;
  int buffer_allocations_size() const;
  private:
  int _internal_buffer_allocations_size() const;
  public:
  void clear_buffer_allocations();
  ::xla::BufferAllocationProto* mutable_buffer_allocations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::BufferAllocationProto >*
      mutable_buffer_allocations();
  private:
  const ::xla::BufferAllocationProto& _internal_buffer_allocations(int index) const;
  ::xla::BufferAllocationProto* _internal_add_buffer_allocations();
  public:
  const ::xla::BufferAllocationProto& buffer_allocations(int index) const;
  ::xla::BufferAllocationProto* add_buffer_allocations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::BufferAllocationProto >&
      buffer_allocations() const;

  // repeated .xla.HeapSimulatorTrace heap_simulator_traces = 4;
  int heap_simulator_traces_size() const;
  private:
  int _internal_heap_simulator_traces_size() const;
  public:
  void clear_heap_simulator_traces();
  ::xla::HeapSimulatorTrace* mutable_heap_simulator_traces(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HeapSimulatorTrace >*
      mutable_heap_simulator_traces();
  private:
  const ::xla::HeapSimulatorTrace& _internal_heap_simulator_traces(int index) const;
  ::xla::HeapSimulatorTrace* _internal_add_heap_simulator_traces();
  public:
  const ::xla::HeapSimulatorTrace& heap_simulator_traces(int index) const;
  ::xla::HeapSimulatorTrace* add_heap_simulator_traces();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HeapSimulatorTrace >&
      heap_simulator_traces() const;

  // @@protoc_insertion_point(class_scope:xla.BufferAssignmentProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LogicalBufferProto > logical_buffers_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::BufferAssignmentProto_BufferAlias > buffer_aliases_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::BufferAllocationProto > buffer_allocations_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HeapSimulatorTrace > heap_simulator_traces_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline HloProto& operator=(const HloProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloProto& operator=(HloProto&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloProto* internal_default_instance() {
    return reinterpret_cast<const HloProto*>(
               &_HloProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  friend void swap(HloProto& a, HloProto& b) {
    a.Swap(&b);
  }
  inline void Swap(HloProto* 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(HloProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HloProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HloProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HloProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HloProto& from) {
    HloProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(HloProto* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kHloModuleFieldNumber = 1,
    kBufferAssignmentFieldNumber = 3,
  };
  // .xla.HloModuleProto hlo_module = 1;
  bool has_hlo_module() const;
  private:
  bool _internal_has_hlo_module() const;
  public:
  void clear_hlo_module();
  const ::xla::HloModuleProto& hlo_module() const;
  PROTOBUF_NODISCARD ::xla::HloModuleProto* release_hlo_module();
  ::xla::HloModuleProto* mutable_hlo_module();
  void set_allocated_hlo_module(::xla::HloModuleProto* hlo_module);
  private:
  const ::xla::HloModuleProto& _internal_hlo_module() const;
  ::xla::HloModuleProto* _internal_mutable_hlo_module();
  public:
  void unsafe_arena_set_allocated_hlo_module(
      ::xla::HloModuleProto* hlo_module);
  ::xla::HloModuleProto* unsafe_arena_release_hlo_module();

  // .xla.BufferAssignmentProto buffer_assignment = 3;
  bool has_buffer_assignment() const;
  private:
  bool _internal_has_buffer_assignment() const;
  public:
  void clear_buffer_assignment();
  const ::xla::BufferAssignmentProto& buffer_assignment() const;
  PROTOBUF_NODISCARD ::xla::BufferAssignmentProto* release_buffer_assignment();
  ::xla::BufferAssignmentProto* mutable_buffer_assignment();
  void set_allocated_buffer_assignment(::xla::BufferAssignmentProto* buffer_assignment);
  private:
  const ::xla::BufferAssignmentProto& _internal_buffer_assignment() const;
  ::xla::BufferAssignmentProto* _internal_mutable_buffer_assignment();
  public:
  void unsafe_arena_set_allocated_buffer_assignment(
      ::xla::BufferAssignmentProto* buffer_assignment);
  ::xla::BufferAssignmentProto* unsafe_arena_release_buffer_assignment();

  // @@protoc_insertion_point(class_scope:xla.HloProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::xla::HloModuleProto* hlo_module_;
    ::xla::BufferAssignmentProto* buffer_assignment_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline HloSnapshot& operator=(const HloSnapshot& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloSnapshot& operator=(HloSnapshot&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloSnapshot& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloSnapshot* internal_default_instance() {
    return reinterpret_cast<const HloSnapshot*>(
               &_HloSnapshot_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  friend void swap(HloSnapshot& a, HloSnapshot& b) {
    a.Swap(&b);
  }
  inline void Swap(HloSnapshot* 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(HloSnapshot* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HloSnapshot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HloSnapshot>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HloSnapshot& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HloSnapshot& from) {
    HloSnapshot::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(HloSnapshot* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kArgumentsFieldNumber = 2,
    kExecutionPlatformFieldNumber = 4,
    kHloFieldNumber = 1,
    kResultFieldNumber = 3,
  };
  // repeated .xla.LiteralProto arguments = 2;
  int arguments_size() const;
  private:
  int _internal_arguments_size() const;
  public:
  void clear_arguments();
  ::xla::LiteralProto* mutable_arguments(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LiteralProto >*
      mutable_arguments();
  private:
  const ::xla::LiteralProto& _internal_arguments(int index) const;
  ::xla::LiteralProto* _internal_add_arguments();
  public:
  const ::xla::LiteralProto& arguments(int index) const;
  ::xla::LiteralProto* add_arguments();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LiteralProto >&
      arguments() const;

  // string execution_platform = 4;
  void clear_execution_platform();
  const std::string& execution_platform() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_execution_platform(ArgT0&& arg0, ArgT... args);
  std::string* mutable_execution_platform();
  PROTOBUF_NODISCARD std::string* release_execution_platform();
  void set_allocated_execution_platform(std::string* execution_platform);
  private:
  const std::string& _internal_execution_platform() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_execution_platform(const std::string& value);
  std::string* _internal_mutable_execution_platform();
  public:

  // .xla.HloProto hlo = 1;
  bool has_hlo() const;
  private:
  bool _internal_has_hlo() const;
  public:
  void clear_hlo();
  const ::xla::HloProto& hlo() const;
  PROTOBUF_NODISCARD ::xla::HloProto* release_hlo();
  ::xla::HloProto* mutable_hlo();
  void set_allocated_hlo(::xla::HloProto* hlo);
  private:
  const ::xla::HloProto& _internal_hlo() const;
  ::xla::HloProto* _internal_mutable_hlo();
  public:
  void unsafe_arena_set_allocated_hlo(
      ::xla::HloProto* hlo);
  ::xla::HloProto* unsafe_arena_release_hlo();

  // .xla.LiteralProto result = 3;
  bool has_result() const;
  private:
  bool _internal_has_result() const;
  public:
  void clear_result();
  const ::xla::LiteralProto& result() const;
  PROTOBUF_NODISCARD ::xla::LiteralProto* release_result();
  ::xla::LiteralProto* mutable_result();
  void set_allocated_result(::xla::LiteralProto* result);
  private:
  const ::xla::LiteralProto& _internal_result() const;
  ::xla::LiteralProto* _internal_mutable_result();
  public:
  void unsafe_arena_set_allocated_result(
      ::xla::LiteralProto* result);
  ::xla::LiteralProto* unsafe_arena_release_result();

  // @@protoc_insertion_point(class_scope:xla.HloSnapshot)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LiteralProto > arguments_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr execution_platform_;
    ::xla::HloProto* hlo_;
    ::xla::LiteralProto* result_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline HloModuleMetadataProto& operator=(const HloModuleMetadataProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloModuleMetadataProto& operator=(HloModuleMetadataProto&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloModuleMetadataProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloModuleMetadataProto* internal_default_instance() {
    return reinterpret_cast<const HloModuleMetadataProto*>(
               &_HloModuleMetadataProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

  friend void swap(HloModuleMetadataProto& a, HloModuleMetadataProto& b) {
    a.Swap(&b);
  }
  inline void Swap(HloModuleMetadataProto* 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(HloModuleMetadataProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HloModuleMetadataProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HloModuleMetadataProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HloModuleMetadataProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HloModuleMetadataProto& from) {
    HloModuleMetadataProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(HloModuleMetadataProto* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kPartitionedModuleIdsFieldNumber = 4,
    kPassMetadataFieldNumber = 5,
    kModuleGroupNameFieldNumber = 2,
    kCanonicalModuleIdFieldNumber = 1,
    kOriginalModuleIdFieldNumber = 3,
  };
  // repeated int64 partitioned_module_ids = 4;
  int partitioned_module_ids_size() const;
  private:
  int _internal_partitioned_module_ids_size() const;
  public:
  void clear_partitioned_module_ids();
  private:
  int64_t _internal_partitioned_module_ids(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_partitioned_module_ids() const;
  void _internal_add_partitioned_module_ids(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_partitioned_module_ids();
  public:
  int64_t partitioned_module_ids(int index) const;
  void set_partitioned_module_ids(int index, int64_t value);
  void add_partitioned_module_ids(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      partitioned_module_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_partitioned_module_ids();

  // repeated .xla.HloPassMetadata pass_metadata = 5;
  int pass_metadata_size() const;
  private:
  int _internal_pass_metadata_size() const;
  public:
  void clear_pass_metadata();
  ::xla::HloPassMetadata* mutable_pass_metadata(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloPassMetadata >*
      mutable_pass_metadata();
  private:
  const ::xla::HloPassMetadata& _internal_pass_metadata(int index) const;
  ::xla::HloPassMetadata* _internal_add_pass_metadata();
  public:
  const ::xla::HloPassMetadata& pass_metadata(int index) const;
  ::xla::HloPassMetadata* add_pass_metadata();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloPassMetadata >&
      pass_metadata() const;

  // string module_group_name = 2;
  void clear_module_group_name();
  const std::string& module_group_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_module_group_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_module_group_name();
  PROTOBUF_NODISCARD std::string* release_module_group_name();
  void set_allocated_module_group_name(std::string* module_group_name);
  private:
  const std::string& _internal_module_group_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_module_group_name(const std::string& value);
  std::string* _internal_mutable_module_group_name();
  public:

  // int64 canonical_module_id = 1;
  void clear_canonical_module_id();
  int64_t canonical_module_id() const;
  void set_canonical_module_id(int64_t value);
  private:
  int64_t _internal_canonical_module_id() const;
  void _internal_set_canonical_module_id(int64_t value);
  public:

  // int64 original_module_id = 3;
  void clear_original_module_id();
  int64_t original_module_id() const;
  void set_original_module_id(int64_t value);
  private:
  int64_t _internal_original_module_id() const;
  void _internal_set_original_module_id(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:xla.HloModuleMetadataProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > partitioned_module_ids_;
    mutable std::atomic<int> _partitioned_module_ids_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloPassMetadata > pass_metadata_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr module_group_name_;
    int64_t canonical_module_id_;
    int64_t original_module_id_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline HloPassMetadata& operator=(const HloPassMetadata& from) {
    CopyFrom(from);
    return *this;
  }
  inline HloPassMetadata& operator=(HloPassMetadata&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HloPassMetadata& default_instance() {
    return *internal_default_instance();
  }
  static inline const HloPassMetadata* internal_default_instance() {
    return reinterpret_cast<const HloPassMetadata*>(
               &_HloPassMetadata_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    25;

  friend void swap(HloPassMetadata& a, HloPassMetadata& b) {
    a.Swap(&b);
  }
  inline void Swap(HloPassMetadata* 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(HloPassMetadata* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HloPassMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HloPassMetadata>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HloPassMetadata& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HloPassMetadata& from) {
    HloPassMetadata::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(HloPassMetadata* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDumpFilenamesFieldNumber = 4,
    kModuleGroupModuleIdsFieldNumber = 7,
    kPassNameFieldNumber = 2,
    kPipelineNameFieldNumber = 3,
    kPassIdFieldNumber = 1,
    kModuleIdFieldNumber = 6,
    kStartTimestampUsecFieldNumber = 8,
    kEndTimestampUsecFieldNumber = 9,
    kModuleChangedFieldNumber = 5,
  };
  // repeated string dump_filenames = 4;
  int dump_filenames_size() const;
  private:
  int _internal_dump_filenames_size() const;
  public:
  void clear_dump_filenames();
  const std::string& dump_filenames(int index) const;
  std::string* mutable_dump_filenames(int index);
  void set_dump_filenames(int index, const std::string& value);
  void set_dump_filenames(int index, std::string&& value);
  void set_dump_filenames(int index, const char* value);
  void set_dump_filenames(int index, const char* value, size_t size);
  std::string* add_dump_filenames();
  void add_dump_filenames(const std::string& value);
  void add_dump_filenames(std::string&& value);
  void add_dump_filenames(const char* value);
  void add_dump_filenames(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& dump_filenames() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_dump_filenames();
  private:
  const std::string& _internal_dump_filenames(int index) const;
  std::string* _internal_add_dump_filenames();
  public:

  // repeated int64 module_group_module_ids = 7;
  int module_group_module_ids_size() const;
  private:
  int _internal_module_group_module_ids_size() const;
  public:
  void clear_module_group_module_ids();
  private:
  int64_t _internal_module_group_module_ids(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_module_group_module_ids() const;
  void _internal_add_module_group_module_ids(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_module_group_module_ids();
  public:
  int64_t module_group_module_ids(int index) const;
  void set_module_group_module_ids(int index, int64_t value);
  void add_module_group_module_ids(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      module_group_module_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_module_group_module_ids();

  // string pass_name = 2;
  void clear_pass_name();
  const std::string& pass_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_pass_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_pass_name();
  PROTOBUF_NODISCARD std::string* release_pass_name();
  void set_allocated_pass_name(std::string* pass_name);
  private:
  const std::string& _internal_pass_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pass_name(const std::string& value);
  std::string* _internal_mutable_pass_name();
  public:

  // string pipeline_name = 3;
  void clear_pipeline_name();
  const std::string& pipeline_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_pipeline_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_pipeline_name();
  PROTOBUF_NODISCARD std::string* release_pipeline_name();
  void set_allocated_pipeline_name(std::string* pipeline_name);
  private:
  const std::string& _internal_pipeline_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pipeline_name(const std::string& value);
  std::string* _internal_mutable_pipeline_name();
  public:

  // int64 pass_id = 1;
  void clear_pass_id();
  int64_t pass_id() const;
  void set_pass_id(int64_t value);
  private:
  int64_t _internal_pass_id() const;
  void _internal_set_pass_id(int64_t value);
  public:

  // int64 module_id = 6;
  void clear_module_id();
  int64_t module_id() const;
  void set_module_id(int64_t value);
  private:
  int64_t _internal_module_id() const;
  void _internal_set_module_id(int64_t value);
  public:

  // int64 start_timestamp_usec = 8;
  void clear_start_timestamp_usec();
  int64_t start_timestamp_usec() const;
  void set_start_timestamp_usec(int64_t value);
  private:
  int64_t _internal_start_timestamp_usec() const;
  void _internal_set_start_timestamp_usec(int64_t value);
  public:

  // int64 end_timestamp_usec = 9;
  void clear_end_timestamp_usec();
  int64_t end_timestamp_usec() const;
  void set_end_timestamp_usec(int64_t value);
  private:
  int64_t _internal_end_timestamp_usec() const;
  void _internal_set_end_timestamp_usec(int64_t value);
  public:

  // bool module_changed = 5;
  void clear_module_changed();
  bool module_changed() const;
  void set_module_changed(bool value);
  private:
  bool _internal_module_changed() const;
  void _internal_set_module_changed(bool value);
  public:

  // @@protoc_insertion_point(class_scope:xla.HloPassMetadata)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> dump_filenames_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > module_group_module_ids_;
    mutable std::atomic<int> _module_group_module_ids_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pass_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pipeline_name_;
    int64_t pass_id_;
    int64_t module_id_;
    int64_t start_timestamp_usec_;
    int64_t end_timestamp_usec_;
    bool module_changed_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

class EntryFunctionAttributes_ShapeIndex final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.EntryFunctionAttributes.ShapeIndex) */ {
 public:
  inline EntryFunctionAttributes_ShapeIndex() : EntryFunctionAttributes_ShapeIndex(nullptr) {}
  ~EntryFunctionAttributes_ShapeIndex() override;
  explicit PROTOBUF_CONSTEXPR EntryFunctionAttributes_ShapeIndex(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline EntryFunctionAttributes_ShapeIndex& operator=(const EntryFunctionAttributes_ShapeIndex& from) {
    CopyFrom(from);
    return *this;
  }
  inline EntryFunctionAttributes_ShapeIndex& operator=(EntryFunctionAttributes_ShapeIndex&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const EntryFunctionAttributes_ShapeIndex& default_instance() {
    return *internal_default_instance();
  }
  static inline const EntryFunctionAttributes_ShapeIndex* internal_default_instance() {
    return reinterpret_cast<const EntryFunctionAttributes_ShapeIndex*>(
               &_EntryFunctionAttributes_ShapeIndex_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    26;

  friend void swap(EntryFunctionAttributes_ShapeIndex& a, EntryFunctionAttributes_ShapeIndex& b) {
    a.Swap(&b);
  }
  inline void Swap(EntryFunctionAttributes_ShapeIndex* 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(EntryFunctionAttributes_ShapeIndex* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  EntryFunctionAttributes_ShapeIndex* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<EntryFunctionAttributes_ShapeIndex>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const EntryFunctionAttributes_ShapeIndex& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const EntryFunctionAttributes_ShapeIndex& from) {
    EntryFunctionAttributes_ShapeIndex::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(EntryFunctionAttributes_ShapeIndex* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kIndicesFieldNumber = 1,
  };
  // repeated int64 indices = 1;
  int indices_size() const;
  private:
  int _internal_indices_size() const;
  public:
  void clear_indices();
  private:
  int64_t _internal_indices(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_indices() const;
  void _internal_add_indices(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_indices();
  public:
  int64_t indices(int index) const;
  void set_indices(int index, int64_t value);
  void add_indices(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      indices() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_indices();

  // @@protoc_insertion_point(class_scope:xla.EntryFunctionAttributes.ShapeIndex)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > indices_;
    mutable std::atomic<int> _indices_cached_byte_size_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

class EntryFunctionAttributes_BufferParameterAttributes final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.EntryFunctionAttributes.BufferParameterAttributes) */ {
 public:
  inline EntryFunctionAttributes_BufferParameterAttributes() : EntryFunctionAttributes_BufferParameterAttributes(nullptr) {}
  ~EntryFunctionAttributes_BufferParameterAttributes() override;
  explicit PROTOBUF_CONSTEXPR EntryFunctionAttributes_BufferParameterAttributes(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline EntryFunctionAttributes_BufferParameterAttributes& operator=(const EntryFunctionAttributes_BufferParameterAttributes& from) {
    CopyFrom(from);
    return *this;
  }
  inline EntryFunctionAttributes_BufferParameterAttributes& operator=(EntryFunctionAttributes_BufferParameterAttributes&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const EntryFunctionAttributes_BufferParameterAttributes& default_instance() {
    return *internal_default_instance();
  }
  static inline const EntryFunctionAttributes_BufferParameterAttributes* internal_default_instance() {
    return reinterpret_cast<const EntryFunctionAttributes_BufferParameterAttributes*>(
               &_EntryFunctionAttributes_BufferParameterAttributes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    27;

  friend void swap(EntryFunctionAttributes_BufferParameterAttributes& a, EntryFunctionAttributes_BufferParameterAttributes& b) {
    a.Swap(&b);
  }
  inline void Swap(EntryFunctionAttributes_BufferParameterAttributes* 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(EntryFunctionAttributes_BufferParameterAttributes* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  EntryFunctionAttributes_BufferParameterAttributes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<EntryFunctionAttributes_BufferParameterAttributes>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const EntryFunctionAttributes_BufferParameterAttributes& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const EntryFunctionAttributes_BufferParameterAttributes& from) {
    EntryFunctionAttributes_BufferParameterAttributes::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(EntryFunctionAttributes_BufferParameterAttributes* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kLmhloConstantNameFieldNumber = 3,
    kLmhloParamShapeIndexFieldNumber = 2,
    kLmhloOutputIndexFieldNumber = 5,
    kLmhloParamsFieldNumber = 1,
    kLmhloParamsPresentFieldNumber = 6,
    kLmhloMustAliasFieldNumber = 4,
  };
  // string lmhlo_constant_name = 3;
  void clear_lmhlo_constant_name();
  const std::string& lmhlo_constant_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_lmhlo_constant_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_lmhlo_constant_name();
  PROTOBUF_NODISCARD std::string* release_lmhlo_constant_name();
  void set_allocated_lmhlo_constant_name(std::string* lmhlo_constant_name);
  private:
  const std::string& _internal_lmhlo_constant_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_lmhlo_constant_name(const std::string& value);
  std::string* _internal_mutable_lmhlo_constant_name();
  public:

  // .xla.EntryFunctionAttributes.ShapeIndex lmhlo_param_shape_index = 2;
  bool has_lmhlo_param_shape_index() const;
  private:
  bool _internal_has_lmhlo_param_shape_index() const;
  public:
  void clear_lmhlo_param_shape_index();
  const ::xla::EntryFunctionAttributes_ShapeIndex& lmhlo_param_shape_index() const;
  PROTOBUF_NODISCARD ::xla::EntryFunctionAttributes_ShapeIndex* release_lmhlo_param_shape_index();
  ::xla::EntryFunctionAttributes_ShapeIndex* mutable_lmhlo_param_shape_index();
  void set_allocated_lmhlo_param_shape_index(::xla::EntryFunctionAttributes_ShapeIndex* lmhlo_param_shape_index);
  private:
  const ::xla::EntryFunctionAttributes_ShapeIndex& _internal_lmhlo_param_shape_index() const;
  ::xla::EntryFunctionAttributes_ShapeIndex* _internal_mutable_lmhlo_param_shape_index();
  public:
  void unsafe_arena_set_allocated_lmhlo_param_shape_index(
      ::xla::EntryFunctionAttributes_ShapeIndex* lmhlo_param_shape_index);
  ::xla::EntryFunctionAttributes_ShapeIndex* unsafe_arena_release_lmhlo_param_shape_index();

  // .xla.EntryFunctionAttributes.ShapeIndex lmhlo_output_index = 5;
  bool has_lmhlo_output_index() const;
  private:
  bool _internal_has_lmhlo_output_index() const;
  public:
  void clear_lmhlo_output_index();
  const ::xla::EntryFunctionAttributes_ShapeIndex& lmhlo_output_index() const;
  PROTOBUF_NODISCARD ::xla::EntryFunctionAttributes_ShapeIndex* release_lmhlo_output_index();
  ::xla::EntryFunctionAttributes_ShapeIndex* mutable_lmhlo_output_index();
  void set_allocated_lmhlo_output_index(::xla::EntryFunctionAttributes_ShapeIndex* lmhlo_output_index);
  private:
  const ::xla::EntryFunctionAttributes_ShapeIndex& _internal_lmhlo_output_index() const;
  ::xla::EntryFunctionAttributes_ShapeIndex* _internal_mutable_lmhlo_output_index();
  public:
  void unsafe_arena_set_allocated_lmhlo_output_index(
      ::xla::EntryFunctionAttributes_ShapeIndex* lmhlo_output_index);
  ::xla::EntryFunctionAttributes_ShapeIndex* unsafe_arena_release_lmhlo_output_index();

  // int64 lmhlo_params = 1;
  void clear_lmhlo_params();
  int64_t lmhlo_params() const;
  void set_lmhlo_params(int64_t value);
  private:
  int64_t _internal_lmhlo_params() const;
  void _internal_set_lmhlo_params(int64_t value);
  public:

  // bool lmhlo_params_present = 6;
  void clear_lmhlo_params_present();
  bool lmhlo_params_present() const;
  void set_lmhlo_params_present(bool value);
  private:
  bool _internal_lmhlo_params_present() const;
  void _internal_set_lmhlo_params_present(bool value);
  public:

  // bool lmhlo_must_alias = 4;
  void clear_lmhlo_must_alias();
  bool lmhlo_must_alias() const;
  void set_lmhlo_must_alias(bool value);
  private:
  bool _internal_lmhlo_must_alias() const;
  void _internal_set_lmhlo_must_alias(bool value);
  public:

  // @@protoc_insertion_point(class_scope:xla.EntryFunctionAttributes.BufferParameterAttributes)
 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::ArenaStringPtr lmhlo_constant_name_;
    ::xla::EntryFunctionAttributes_ShapeIndex* lmhlo_param_shape_index_;
    ::xla::EntryFunctionAttributes_ShapeIndex* lmhlo_output_index_;
    int64_t lmhlo_params_;
    bool lmhlo_params_present_;
    bool lmhlo_must_alias_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline EntryFunctionAttributes& operator=(const EntryFunctionAttributes& from) {
    CopyFrom(from);
    return *this;
  }
  inline EntryFunctionAttributes& operator=(EntryFunctionAttributes&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const EntryFunctionAttributes& default_instance() {
    return *internal_default_instance();
  }
  static inline const EntryFunctionAttributes* internal_default_instance() {
    return reinterpret_cast<const EntryFunctionAttributes*>(
               &_EntryFunctionAttributes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    28;

  friend void swap(EntryFunctionAttributes& a, EntryFunctionAttributes& b) {
    a.Swap(&b);
  }
  inline void Swap(EntryFunctionAttributes* 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(EntryFunctionAttributes* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  EntryFunctionAttributes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<EntryFunctionAttributes>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const EntryFunctionAttributes& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const EntryFunctionAttributes& from) {
    EntryFunctionAttributes::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(EntryFunctionAttributes* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef EntryFunctionAttributes_ShapeIndex ShapeIndex;
  typedef EntryFunctionAttributes_BufferParameterAttributes BufferParameterAttributes;

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

  enum : int {
    kBuffersFieldNumber = 1,
    kResultXlaShapeFieldNumber = 2,
  };
  // repeated .xla.EntryFunctionAttributes.BufferParameterAttributes buffers = 1;
  int buffers_size() const;
  private:
  int _internal_buffers_size() const;
  public:
  void clear_buffers();
  ::xla::EntryFunctionAttributes_BufferParameterAttributes* mutable_buffers(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::EntryFunctionAttributes_BufferParameterAttributes >*
      mutable_buffers();
  private:
  const ::xla::EntryFunctionAttributes_BufferParameterAttributes& _internal_buffers(int index) const;
  ::xla::EntryFunctionAttributes_BufferParameterAttributes* _internal_add_buffers();
  public:
  const ::xla::EntryFunctionAttributes_BufferParameterAttributes& buffers(int index) const;
  ::xla::EntryFunctionAttributes_BufferParameterAttributes* add_buffers();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::EntryFunctionAttributes_BufferParameterAttributes >&
      buffers() const;

  // string result_xla_shape = 2;
  void clear_result_xla_shape();
  const std::string& result_xla_shape() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_result_xla_shape(ArgT0&& arg0, ArgT... args);
  std::string* mutable_result_xla_shape();
  PROTOBUF_NODISCARD std::string* release_result_xla_shape();
  void set_allocated_result_xla_shape(std::string* result_xla_shape);
  private:
  const std::string& _internal_result_xla_shape() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_result_xla_shape(const std::string& value);
  std::string* _internal_mutable_result_xla_shape();
  public:

  // @@protoc_insertion_point(class_scope:xla.EntryFunctionAttributes)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::EntryFunctionAttributes_BufferParameterAttributes > buffers_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr result_xla_shape_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline XlaRuntimeExecutableProto& operator=(const XlaRuntimeExecutableProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline XlaRuntimeExecutableProto& operator=(XlaRuntimeExecutableProto&& 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;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const XlaRuntimeExecutableProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const XlaRuntimeExecutableProto* internal_default_instance() {
    return reinterpret_cast<const XlaRuntimeExecutableProto*>(
               &_XlaRuntimeExecutableProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    29;

  friend void swap(XlaRuntimeExecutableProto& a, XlaRuntimeExecutableProto& b) {
    a.Swap(&b);
  }
  inline void Swap(XlaRuntimeExecutableProto* 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(XlaRuntimeExecutableProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  XlaRuntimeExecutableProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<XlaRuntimeExecutableProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const XlaRuntimeExecutableProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const XlaRuntimeExecutableProto& from) {
    XlaRuntimeExecutableProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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 final;
  void InternalSwap(XlaRuntimeExecutableProto* other);

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

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kObjFileFieldNumber = 3,
    kMlirModuleFieldNumber = 4,
    kHloModuleProtoFieldNumber = 1,
  };
  // bytes obj_file = 3;
  void clear_obj_file();
  const std::string& obj_file() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_obj_file(ArgT0&& arg0, ArgT... args);
  std::string* mutable_obj_file();
  PROTOBUF_NODISCARD std::string* release_obj_file();
  void set_allocated_obj_file(std::string* obj_file);
  private:
  const std::string& _internal_obj_file() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_obj_file(const std::string& value);
  std::string* _internal_mutable_obj_file();
  public:

  // string mlir_module = 4;
  void clear_mlir_module();
  const std::string& mlir_module() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mlir_module(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mlir_module();
  PROTOBUF_NODISCARD std::string* release_mlir_module();
  void set_allocated_mlir_module(std::string* mlir_module);
  private:
  const std::string& _internal_mlir_module() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mlir_module(const std::string& value);
  std::string* _internal_mutable_mlir_module();
  public:

  // .xla.HloModuleProto hlo_module_proto = 1;
  bool has_hlo_module_proto() const;
  private:
  bool _internal_has_hlo_module_proto() const;
  public:
  void clear_hlo_module_proto();
  const ::xla::HloModuleProto& hlo_module_proto() const;
  PROTOBUF_NODISCARD ::xla::HloModuleProto* release_hlo_module_proto();
  ::xla::HloModuleProto* mutable_hlo_module_proto();
  void set_allocated_hlo_module_proto(::xla::HloModuleProto* hlo_module_proto);
  private:
  const ::xla::HloModuleProto& _internal_hlo_module_proto() const;
  ::xla::HloModuleProto* _internal_mutable_hlo_module_proto();
  public:
  void unsafe_arena_set_allocated_hlo_module_proto(
      ::xla::HloModuleProto* hlo_module_proto);
  ::xla::HloModuleProto* unsafe_arena_release_hlo_module_proto();

  // @@protoc_insertion_point(class_scope:xla.XlaRuntimeExecutableProto)
 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::ArenaStringPtr obj_file_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mlir_module_;
    ::xla::HloModuleProto* hlo_module_proto_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto;
};
// ===================================================================


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

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

// int64 start = 1;
inline void HloInstructionProto_SliceDimensions::clear_start() {
  _impl_.start_ = int64_t{0};
}
inline int64_t HloInstructionProto_SliceDimensions::_internal_start() const {
  return _impl_.start_;
}
inline int64_t HloInstructionProto_SliceDimensions::start() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.SliceDimensions.start)
  return _internal_start();
}
inline void HloInstructionProto_SliceDimensions::_internal_set_start(int64_t value) {
  
  _impl_.start_ = value;
}
inline void HloInstructionProto_SliceDimensions::set_start(int64_t value) {
  _internal_set_start(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.SliceDimensions.start)
}

// int64 limit = 2;
inline void HloInstructionProto_SliceDimensions::clear_limit() {
  _impl_.limit_ = int64_t{0};
}
inline int64_t HloInstructionProto_SliceDimensions::_internal_limit() const {
  return _impl_.limit_;
}
inline int64_t HloInstructionProto_SliceDimensions::limit() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.SliceDimensions.limit)
  return _internal_limit();
}
inline void HloInstructionProto_SliceDimensions::_internal_set_limit(int64_t value) {
  
  _impl_.limit_ = value;
}
inline void HloInstructionProto_SliceDimensions::set_limit(int64_t value) {
  _internal_set_limit(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.SliceDimensions.limit)
}

// int64 stride = 3;
inline void HloInstructionProto_SliceDimensions::clear_stride() {
  _impl_.stride_ = int64_t{0};
}
inline int64_t HloInstructionProto_SliceDimensions::_internal_stride() const {
  return _impl_.stride_;
}
inline int64_t HloInstructionProto_SliceDimensions::stride() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.SliceDimensions.stride)
  return _internal_stride();
}
inline void HloInstructionProto_SliceDimensions::_internal_set_stride(int64_t value) {
  
  _impl_.stride_ = value;
}
inline void HloInstructionProto_SliceDimensions::set_stride(int64_t value) {
  _internal_set_stride(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.SliceDimensions.stride)
}

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

// HloInstructionProto

// string name = 1;
inline void HloInstructionProto::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& HloInstructionProto::name() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloInstructionProto::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.name)
}
inline std::string* HloInstructionProto::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.name)
  return _s;
}
inline const std::string& HloInstructionProto::_internal_name() const {
  return _impl_.name_.Get();
}
inline void HloInstructionProto::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* HloInstructionProto::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* HloInstructionProto::release_name() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.name)
  return _impl_.name_.Release();
}
inline void HloInstructionProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _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:xla.HloInstructionProto.name)
}

// string opcode = 2;
inline void HloInstructionProto::clear_opcode() {
  _impl_.opcode_.ClearToEmpty();
}
inline const std::string& HloInstructionProto::opcode() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.opcode)
  return _internal_opcode();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloInstructionProto::set_opcode(ArgT0&& arg0, ArgT... args) {
 
 _impl_.opcode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.opcode)
}
inline std::string* HloInstructionProto::mutable_opcode() {
  std::string* _s = _internal_mutable_opcode();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.opcode)
  return _s;
}
inline const std::string& HloInstructionProto::_internal_opcode() const {
  return _impl_.opcode_.Get();
}
inline void HloInstructionProto::_internal_set_opcode(const std::string& value) {
  
  _impl_.opcode_.Set(value, GetArenaForAllocation());
}
inline std::string* HloInstructionProto::_internal_mutable_opcode() {
  
  return _impl_.opcode_.Mutable(GetArenaForAllocation());
}
inline std::string* HloInstructionProto::release_opcode() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.opcode)
  return _impl_.opcode_.Release();
}
inline void HloInstructionProto::set_allocated_opcode(std::string* opcode) {
  if (opcode != nullptr) {
    
  } else {
    
  }
  _impl_.opcode_.SetAllocated(opcode, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.opcode_.IsDefault()) {
    _impl_.opcode_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.opcode)
}

// .xla.ShapeProto shape = 3;
inline bool HloInstructionProto::_internal_has_shape() const {
  return this != internal_default_instance() && _impl_.shape_ != nullptr;
}
inline bool HloInstructionProto::has_shape() const {
  return _internal_has_shape();
}
inline const ::xla::ShapeProto& HloInstructionProto::_internal_shape() const {
  const ::xla::ShapeProto* p = _impl_.shape_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::ShapeProto&>(
      ::xla::_ShapeProto_default_instance_);
}
inline const ::xla::ShapeProto& HloInstructionProto::shape() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.shape)
  return _internal_shape();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_shape(
    ::xla::ShapeProto* shape) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
  }
  _impl_.shape_ = shape;
  if (shape) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.shape)
}
inline ::xla::ShapeProto* HloInstructionProto::release_shape() {
  
  ::xla::ShapeProto* temp = _impl_.shape_;
  _impl_.shape_ = 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 ::xla::ShapeProto* HloInstructionProto::unsafe_arena_release_shape() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.shape)
  
  ::xla::ShapeProto* temp = _impl_.shape_;
  _impl_.shape_ = nullptr;
  return temp;
}
inline ::xla::ShapeProto* HloInstructionProto::_internal_mutable_shape() {
  
  if (_impl_.shape_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::ShapeProto>(GetArenaForAllocation());
    _impl_.shape_ = p;
  }
  return _impl_.shape_;
}
inline ::xla::ShapeProto* HloInstructionProto::mutable_shape() {
  ::xla::ShapeProto* _msg = _internal_mutable_shape();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.shape)
  return _msg;
}
inline void HloInstructionProto::set_allocated_shape(::xla::ShapeProto* shape) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
  }
  if (shape) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape));
    if (message_arena != submessage_arena) {
      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, shape, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.shape_ = shape;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.shape)
}

// .xla.OpMetadata metadata = 7;
inline bool HloInstructionProto::_internal_has_metadata() const {
  return this != internal_default_instance() && _impl_.metadata_ != nullptr;
}
inline bool HloInstructionProto::has_metadata() const {
  return _internal_has_metadata();
}
inline const ::xla::OpMetadata& HloInstructionProto::_internal_metadata() const {
  const ::xla::OpMetadata* p = _impl_.metadata_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::OpMetadata&>(
      ::xla::_OpMetadata_default_instance_);
}
inline const ::xla::OpMetadata& HloInstructionProto::metadata() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.metadata)
  return _internal_metadata();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_metadata(
    ::xla::OpMetadata* metadata) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.metadata_);
  }
  _impl_.metadata_ = metadata;
  if (metadata) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.metadata)
}
inline ::xla::OpMetadata* HloInstructionProto::release_metadata() {
  
  ::xla::OpMetadata* temp = _impl_.metadata_;
  _impl_.metadata_ = 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 ::xla::OpMetadata* HloInstructionProto::unsafe_arena_release_metadata() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.metadata)
  
  ::xla::OpMetadata* temp = _impl_.metadata_;
  _impl_.metadata_ = nullptr;
  return temp;
}
inline ::xla::OpMetadata* HloInstructionProto::_internal_mutable_metadata() {
  
  if (_impl_.metadata_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::OpMetadata>(GetArenaForAllocation());
    _impl_.metadata_ = p;
  }
  return _impl_.metadata_;
}
inline ::xla::OpMetadata* HloInstructionProto::mutable_metadata() {
  ::xla::OpMetadata* _msg = _internal_mutable_metadata();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.metadata)
  return _msg;
}
inline void HloInstructionProto::set_allocated_metadata(::xla::OpMetadata* metadata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.metadata_);
  }
  if (metadata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(metadata));
    if (message_arena != submessage_arena) {
      metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, metadata, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.metadata_ = metadata;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.metadata)
}

// .xla.LiteralProto literal = 8;
inline bool HloInstructionProto::_internal_has_literal() const {
  return this != internal_default_instance() && _impl_.literal_ != nullptr;
}
inline bool HloInstructionProto::has_literal() const {
  return _internal_has_literal();
}
inline const ::xla::LiteralProto& HloInstructionProto::_internal_literal() const {
  const ::xla::LiteralProto* p = _impl_.literal_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::LiteralProto&>(
      ::xla::_LiteralProto_default_instance_);
}
inline const ::xla::LiteralProto& HloInstructionProto::literal() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.literal)
  return _internal_literal();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_literal(
    ::xla::LiteralProto* literal) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.literal_);
  }
  _impl_.literal_ = literal;
  if (literal) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.literal)
}
inline ::xla::LiteralProto* HloInstructionProto::release_literal() {
  
  ::xla::LiteralProto* temp = _impl_.literal_;
  _impl_.literal_ = 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 ::xla::LiteralProto* HloInstructionProto::unsafe_arena_release_literal() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.literal)
  
  ::xla::LiteralProto* temp = _impl_.literal_;
  _impl_.literal_ = nullptr;
  return temp;
}
inline ::xla::LiteralProto* HloInstructionProto::_internal_mutable_literal() {
  
  if (_impl_.literal_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::LiteralProto>(GetArenaForAllocation());
    _impl_.literal_ = p;
  }
  return _impl_.literal_;
}
inline ::xla::LiteralProto* HloInstructionProto::mutable_literal() {
  ::xla::LiteralProto* _msg = _internal_mutable_literal();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.literal)
  return _msg;
}
inline void HloInstructionProto::set_allocated_literal(::xla::LiteralProto* literal) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.literal_);
  }
  if (literal) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(literal));
    if (message_arena != submessage_arena) {
      literal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, literal, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.literal_ = literal;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.literal)
}

// int64 parameter_number = 9;
inline void HloInstructionProto::clear_parameter_number() {
  _impl_.parameter_number_ = int64_t{0};
}
inline int64_t HloInstructionProto::_internal_parameter_number() const {
  return _impl_.parameter_number_;
}
inline int64_t HloInstructionProto::parameter_number() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.parameter_number)
  return _internal_parameter_number();
}
inline void HloInstructionProto::_internal_set_parameter_number(int64_t value) {
  
  _impl_.parameter_number_ = value;
}
inline void HloInstructionProto::set_parameter_number(int64_t value) {
  _internal_set_parameter_number(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.parameter_number)
}

// string fusion_kind = 11;
inline void HloInstructionProto::clear_fusion_kind() {
  _impl_.fusion_kind_.ClearToEmpty();
}
inline const std::string& HloInstructionProto::fusion_kind() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.fusion_kind)
  return _internal_fusion_kind();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloInstructionProto::set_fusion_kind(ArgT0&& arg0, ArgT... args) {
 
 _impl_.fusion_kind_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.fusion_kind)
}
inline std::string* HloInstructionProto::mutable_fusion_kind() {
  std::string* _s = _internal_mutable_fusion_kind();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.fusion_kind)
  return _s;
}
inline const std::string& HloInstructionProto::_internal_fusion_kind() const {
  return _impl_.fusion_kind_.Get();
}
inline void HloInstructionProto::_internal_set_fusion_kind(const std::string& value) {
  
  _impl_.fusion_kind_.Set(value, GetArenaForAllocation());
}
inline std::string* HloInstructionProto::_internal_mutable_fusion_kind() {
  
  return _impl_.fusion_kind_.Mutable(GetArenaForAllocation());
}
inline std::string* HloInstructionProto::release_fusion_kind() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.fusion_kind)
  return _impl_.fusion_kind_.Release();
}
inline void HloInstructionProto::set_allocated_fusion_kind(std::string* fusion_kind) {
  if (fusion_kind != nullptr) {
    
  } else {
    
  }
  _impl_.fusion_kind_.SetAllocated(fusion_kind, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fusion_kind_.IsDefault()) {
    _impl_.fusion_kind_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.fusion_kind)
}

// int64 tuple_index = 13;
inline void HloInstructionProto::clear_tuple_index() {
  _impl_.tuple_index_ = int64_t{0};
}
inline int64_t HloInstructionProto::_internal_tuple_index() const {
  return _impl_.tuple_index_;
}
inline int64_t HloInstructionProto::tuple_index() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.tuple_index)
  return _internal_tuple_index();
}
inline void HloInstructionProto::_internal_set_tuple_index(int64_t value) {
  
  _impl_.tuple_index_ = value;
}
inline void HloInstructionProto::set_tuple_index(int64_t value) {
  _internal_set_tuple_index(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.tuple_index)
}

// repeated int64 dimensions = 14;
inline int HloInstructionProto::_internal_dimensions_size() const {
  return _impl_.dimensions_.size();
}
inline int HloInstructionProto::dimensions_size() const {
  return _internal_dimensions_size();
}
inline void HloInstructionProto::clear_dimensions() {
  _impl_.dimensions_.Clear();
}
inline int64_t HloInstructionProto::_internal_dimensions(int index) const {
  return _impl_.dimensions_.Get(index);
}
inline int64_t HloInstructionProto::dimensions(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.dimensions)
  return _internal_dimensions(index);
}
inline void HloInstructionProto::set_dimensions(int index, int64_t value) {
  _impl_.dimensions_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.dimensions)
}
inline void HloInstructionProto::_internal_add_dimensions(int64_t value) {
  _impl_.dimensions_.Add(value);
}
inline void HloInstructionProto::add_dimensions(int64_t value) {
  _internal_add_dimensions(value);
  // @@protoc_insertion_point(field_add:xla.HloInstructionProto.dimensions)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInstructionProto::_internal_dimensions() const {
  return _impl_.dimensions_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInstructionProto::dimensions() const {
  // @@protoc_insertion_point(field_list:xla.HloInstructionProto.dimensions)
  return _internal_dimensions();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInstructionProto::_internal_mutable_dimensions() {
  return &_impl_.dimensions_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInstructionProto::mutable_dimensions() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloInstructionProto.dimensions)
  return _internal_mutable_dimensions();
}

// .xla.Window window = 15;
inline bool HloInstructionProto::_internal_has_window() const {
  return this != internal_default_instance() && _impl_.window_ != nullptr;
}
inline bool HloInstructionProto::has_window() const {
  return _internal_has_window();
}
inline const ::xla::Window& HloInstructionProto::_internal_window() const {
  const ::xla::Window* p = _impl_.window_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::Window&>(
      ::xla::_Window_default_instance_);
}
inline const ::xla::Window& HloInstructionProto::window() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.window)
  return _internal_window();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_window(
    ::xla::Window* window) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.window_);
  }
  _impl_.window_ = window;
  if (window) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.window)
}
inline ::xla::Window* HloInstructionProto::release_window() {
  
  ::xla::Window* temp = _impl_.window_;
  _impl_.window_ = 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 ::xla::Window* HloInstructionProto::unsafe_arena_release_window() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.window)
  
  ::xla::Window* temp = _impl_.window_;
  _impl_.window_ = nullptr;
  return temp;
}
inline ::xla::Window* HloInstructionProto::_internal_mutable_window() {
  
  if (_impl_.window_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::Window>(GetArenaForAllocation());
    _impl_.window_ = p;
  }
  return _impl_.window_;
}
inline ::xla::Window* HloInstructionProto::mutable_window() {
  ::xla::Window* _msg = _internal_mutable_window();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.window)
  return _msg;
}
inline void HloInstructionProto::set_allocated_window(::xla::Window* window) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.window_);
  }
  if (window) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(window));
    if (message_arena != submessage_arena) {
      window = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, window, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.window_ = window;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.window)
}

// .xla.ConvolutionDimensionNumbers convolution_dimension_numbers = 16;
inline bool HloInstructionProto::_internal_has_convolution_dimension_numbers() const {
  return this != internal_default_instance() && _impl_.convolution_dimension_numbers_ != nullptr;
}
inline bool HloInstructionProto::has_convolution_dimension_numbers() const {
  return _internal_has_convolution_dimension_numbers();
}
inline const ::xla::ConvolutionDimensionNumbers& HloInstructionProto::_internal_convolution_dimension_numbers() const {
  const ::xla::ConvolutionDimensionNumbers* p = _impl_.convolution_dimension_numbers_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::ConvolutionDimensionNumbers&>(
      ::xla::_ConvolutionDimensionNumbers_default_instance_);
}
inline const ::xla::ConvolutionDimensionNumbers& HloInstructionProto::convolution_dimension_numbers() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.convolution_dimension_numbers)
  return _internal_convolution_dimension_numbers();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_convolution_dimension_numbers(
    ::xla::ConvolutionDimensionNumbers* convolution_dimension_numbers) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.convolution_dimension_numbers_);
  }
  _impl_.convolution_dimension_numbers_ = convolution_dimension_numbers;
  if (convolution_dimension_numbers) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.convolution_dimension_numbers)
}
inline ::xla::ConvolutionDimensionNumbers* HloInstructionProto::release_convolution_dimension_numbers() {
  
  ::xla::ConvolutionDimensionNumbers* temp = _impl_.convolution_dimension_numbers_;
  _impl_.convolution_dimension_numbers_ = 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 ::xla::ConvolutionDimensionNumbers* HloInstructionProto::unsafe_arena_release_convolution_dimension_numbers() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.convolution_dimension_numbers)
  
  ::xla::ConvolutionDimensionNumbers* temp = _impl_.convolution_dimension_numbers_;
  _impl_.convolution_dimension_numbers_ = nullptr;
  return temp;
}
inline ::xla::ConvolutionDimensionNumbers* HloInstructionProto::_internal_mutable_convolution_dimension_numbers() {
  
  if (_impl_.convolution_dimension_numbers_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::ConvolutionDimensionNumbers>(GetArenaForAllocation());
    _impl_.convolution_dimension_numbers_ = p;
  }
  return _impl_.convolution_dimension_numbers_;
}
inline ::xla::ConvolutionDimensionNumbers* HloInstructionProto::mutable_convolution_dimension_numbers() {
  ::xla::ConvolutionDimensionNumbers* _msg = _internal_mutable_convolution_dimension_numbers();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.convolution_dimension_numbers)
  return _msg;
}
inline void HloInstructionProto::set_allocated_convolution_dimension_numbers(::xla::ConvolutionDimensionNumbers* convolution_dimension_numbers) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.convolution_dimension_numbers_);
  }
  if (convolution_dimension_numbers) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(convolution_dimension_numbers));
    if (message_arena != submessage_arena) {
      convolution_dimension_numbers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, convolution_dimension_numbers, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.convolution_dimension_numbers_ = convolution_dimension_numbers;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.convolution_dimension_numbers)
}

// int64 feature_group_count = 50;
inline void HloInstructionProto::clear_feature_group_count() {
  _impl_.feature_group_count_ = int64_t{0};
}
inline int64_t HloInstructionProto::_internal_feature_group_count() const {
  return _impl_.feature_group_count_;
}
inline int64_t HloInstructionProto::feature_group_count() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.feature_group_count)
  return _internal_feature_group_count();
}
inline void HloInstructionProto::_internal_set_feature_group_count(int64_t value) {
  
  _impl_.feature_group_count_ = value;
}
inline void HloInstructionProto::set_feature_group_count(int64_t value) {
  _internal_set_feature_group_count(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.feature_group_count)
}

// int64 batch_group_count = 58;
inline void HloInstructionProto::clear_batch_group_count() {
  _impl_.batch_group_count_ = int64_t{0};
}
inline int64_t HloInstructionProto::_internal_batch_group_count() const {
  return _impl_.batch_group_count_;
}
inline int64_t HloInstructionProto::batch_group_count() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.batch_group_count)
  return _internal_batch_group_count();
}
inline void HloInstructionProto::_internal_set_batch_group_count(int64_t value) {
  
  _impl_.batch_group_count_ = value;
}
inline void HloInstructionProto::set_batch_group_count(int64_t value) {
  _internal_set_batch_group_count(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.batch_group_count)
}

// repeated .xla.HloInstructionProto.SliceDimensions slice_dimensions = 17;
inline int HloInstructionProto::_internal_slice_dimensions_size() const {
  return _impl_.slice_dimensions_.size();
}
inline int HloInstructionProto::slice_dimensions_size() const {
  return _internal_slice_dimensions_size();
}
inline void HloInstructionProto::clear_slice_dimensions() {
  _impl_.slice_dimensions_.Clear();
}
inline ::xla::HloInstructionProto_SliceDimensions* HloInstructionProto::mutable_slice_dimensions(int index) {
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.slice_dimensions)
  return _impl_.slice_dimensions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloInstructionProto_SliceDimensions >*
HloInstructionProto::mutable_slice_dimensions() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloInstructionProto.slice_dimensions)
  return &_impl_.slice_dimensions_;
}
inline const ::xla::HloInstructionProto_SliceDimensions& HloInstructionProto::_internal_slice_dimensions(int index) const {
  return _impl_.slice_dimensions_.Get(index);
}
inline const ::xla::HloInstructionProto_SliceDimensions& HloInstructionProto::slice_dimensions(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.slice_dimensions)
  return _internal_slice_dimensions(index);
}
inline ::xla::HloInstructionProto_SliceDimensions* HloInstructionProto::_internal_add_slice_dimensions() {
  return _impl_.slice_dimensions_.Add();
}
inline ::xla::HloInstructionProto_SliceDimensions* HloInstructionProto::add_slice_dimensions() {
  ::xla::HloInstructionProto_SliceDimensions* _add = _internal_add_slice_dimensions();
  // @@protoc_insertion_point(field_add:xla.HloInstructionProto.slice_dimensions)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloInstructionProto_SliceDimensions >&
HloInstructionProto::slice_dimensions() const {
  // @@protoc_insertion_point(field_list:xla.HloInstructionProto.slice_dimensions)
  return _impl_.slice_dimensions_;
}

// int32 exponent_bits = 18;
inline void HloInstructionProto::clear_exponent_bits() {
  _impl_.exponent_bits_ = 0;
}
inline int32_t HloInstructionProto::_internal_exponent_bits() const {
  return _impl_.exponent_bits_;
}
inline int32_t HloInstructionProto::exponent_bits() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.exponent_bits)
  return _internal_exponent_bits();
}
inline void HloInstructionProto::_internal_set_exponent_bits(int32_t value) {
  
  _impl_.exponent_bits_ = value;
}
inline void HloInstructionProto::set_exponent_bits(int32_t value) {
  _internal_set_exponent_bits(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.exponent_bits)
}

// int32 mantissa_bits = 19;
inline void HloInstructionProto::clear_mantissa_bits() {
  _impl_.mantissa_bits_ = 0;
}
inline int32_t HloInstructionProto::_internal_mantissa_bits() const {
  return _impl_.mantissa_bits_;
}
inline int32_t HloInstructionProto::mantissa_bits() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.mantissa_bits)
  return _internal_mantissa_bits();
}
inline void HloInstructionProto::_internal_set_mantissa_bits(int32_t value) {
  
  _impl_.mantissa_bits_ = value;
}
inline void HloInstructionProto::set_mantissa_bits(int32_t value) {
  _internal_set_mantissa_bits(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.mantissa_bits)
}

// repeated int64 dynamic_slice_sizes = 20;
inline int HloInstructionProto::_internal_dynamic_slice_sizes_size() const {
  return _impl_.dynamic_slice_sizes_.size();
}
inline int HloInstructionProto::dynamic_slice_sizes_size() const {
  return _internal_dynamic_slice_sizes_size();
}
inline void HloInstructionProto::clear_dynamic_slice_sizes() {
  _impl_.dynamic_slice_sizes_.Clear();
}
inline int64_t HloInstructionProto::_internal_dynamic_slice_sizes(int index) const {
  return _impl_.dynamic_slice_sizes_.Get(index);
}
inline int64_t HloInstructionProto::dynamic_slice_sizes(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.dynamic_slice_sizes)
  return _internal_dynamic_slice_sizes(index);
}
inline void HloInstructionProto::set_dynamic_slice_sizes(int index, int64_t value) {
  _impl_.dynamic_slice_sizes_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.dynamic_slice_sizes)
}
inline void HloInstructionProto::_internal_add_dynamic_slice_sizes(int64_t value) {
  _impl_.dynamic_slice_sizes_.Add(value);
}
inline void HloInstructionProto::add_dynamic_slice_sizes(int64_t value) {
  _internal_add_dynamic_slice_sizes(value);
  // @@protoc_insertion_point(field_add:xla.HloInstructionProto.dynamic_slice_sizes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInstructionProto::_internal_dynamic_slice_sizes() const {
  return _impl_.dynamic_slice_sizes_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInstructionProto::dynamic_slice_sizes() const {
  // @@protoc_insertion_point(field_list:xla.HloInstructionProto.dynamic_slice_sizes)
  return _internal_dynamic_slice_sizes();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInstructionProto::_internal_mutable_dynamic_slice_sizes() {
  return &_impl_.dynamic_slice_sizes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInstructionProto::mutable_dynamic_slice_sizes() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloInstructionProto.dynamic_slice_sizes)
  return _internal_mutable_dynamic_slice_sizes();
}

// .xla.PaddingConfig padding_config = 21;
inline bool HloInstructionProto::_internal_has_padding_config() const {
  return this != internal_default_instance() && _impl_.padding_config_ != nullptr;
}
inline bool HloInstructionProto::has_padding_config() const {
  return _internal_has_padding_config();
}
inline const ::xla::PaddingConfig& HloInstructionProto::_internal_padding_config() const {
  const ::xla::PaddingConfig* p = _impl_.padding_config_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::PaddingConfig&>(
      ::xla::_PaddingConfig_default_instance_);
}
inline const ::xla::PaddingConfig& HloInstructionProto::padding_config() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.padding_config)
  return _internal_padding_config();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_padding_config(
    ::xla::PaddingConfig* padding_config) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.padding_config_);
  }
  _impl_.padding_config_ = padding_config;
  if (padding_config) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.padding_config)
}
inline ::xla::PaddingConfig* HloInstructionProto::release_padding_config() {
  
  ::xla::PaddingConfig* temp = _impl_.padding_config_;
  _impl_.padding_config_ = 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 ::xla::PaddingConfig* HloInstructionProto::unsafe_arena_release_padding_config() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.padding_config)
  
  ::xla::PaddingConfig* temp = _impl_.padding_config_;
  _impl_.padding_config_ = nullptr;
  return temp;
}
inline ::xla::PaddingConfig* HloInstructionProto::_internal_mutable_padding_config() {
  
  if (_impl_.padding_config_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::PaddingConfig>(GetArenaForAllocation());
    _impl_.padding_config_ = p;
  }
  return _impl_.padding_config_;
}
inline ::xla::PaddingConfig* HloInstructionProto::mutable_padding_config() {
  ::xla::PaddingConfig* _msg = _internal_mutable_padding_config();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.padding_config)
  return _msg;
}
inline void HloInstructionProto::set_allocated_padding_config(::xla::PaddingConfig* padding_config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.padding_config_);
  }
  if (padding_config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(padding_config));
    if (message_arena != submessage_arena) {
      padding_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, padding_config, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.padding_config_ = padding_config;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.padding_config)
}

// bytes outfeed_config = 22;
inline void HloInstructionProto::clear_outfeed_config() {
  _impl_.outfeed_config_.ClearToEmpty();
}
inline const std::string& HloInstructionProto::outfeed_config() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.outfeed_config)
  return _internal_outfeed_config();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloInstructionProto::set_outfeed_config(ArgT0&& arg0, ArgT... args) {
 
 _impl_.outfeed_config_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.outfeed_config)
}
inline std::string* HloInstructionProto::mutable_outfeed_config() {
  std::string* _s = _internal_mutable_outfeed_config();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.outfeed_config)
  return _s;
}
inline const std::string& HloInstructionProto::_internal_outfeed_config() const {
  return _impl_.outfeed_config_.Get();
}
inline void HloInstructionProto::_internal_set_outfeed_config(const std::string& value) {
  
  _impl_.outfeed_config_.Set(value, GetArenaForAllocation());
}
inline std::string* HloInstructionProto::_internal_mutable_outfeed_config() {
  
  return _impl_.outfeed_config_.Mutable(GetArenaForAllocation());
}
inline std::string* HloInstructionProto::release_outfeed_config() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.outfeed_config)
  return _impl_.outfeed_config_.Release();
}
inline void HloInstructionProto::set_allocated_outfeed_config(std::string* outfeed_config) {
  if (outfeed_config != nullptr) {
    
  } else {
    
  }
  _impl_.outfeed_config_.SetAllocated(outfeed_config, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.outfeed_config_.IsDefault()) {
    _impl_.outfeed_config_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.outfeed_config)
}

// .xla.RandomDistribution distribution = 23;
inline void HloInstructionProto::clear_distribution() {
  _impl_.distribution_ = 0;
}
inline ::xla::RandomDistribution HloInstructionProto::_internal_distribution() const {
  return static_cast< ::xla::RandomDistribution >(_impl_.distribution_);
}
inline ::xla::RandomDistribution HloInstructionProto::distribution() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.distribution)
  return _internal_distribution();
}
inline void HloInstructionProto::_internal_set_distribution(::xla::RandomDistribution value) {
  
  _impl_.distribution_ = value;
}
inline void HloInstructionProto::set_distribution(::xla::RandomDistribution value) {
  _internal_set_distribution(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.distribution)
}

// float epsilon = 24;
inline void HloInstructionProto::clear_epsilon() {
  _impl_.epsilon_ = 0;
}
inline float HloInstructionProto::_internal_epsilon() const {
  return _impl_.epsilon_;
}
inline float HloInstructionProto::epsilon() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.epsilon)
  return _internal_epsilon();
}
inline void HloInstructionProto::_internal_set_epsilon(float value) {
  
  _impl_.epsilon_ = value;
}
inline void HloInstructionProto::set_epsilon(float value) {
  _internal_set_epsilon(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.epsilon)
}

// int64 feature_index = 25;
inline void HloInstructionProto::clear_feature_index() {
  _impl_.feature_index_ = int64_t{0};
}
inline int64_t HloInstructionProto::_internal_feature_index() const {
  return _impl_.feature_index_;
}
inline int64_t HloInstructionProto::feature_index() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.feature_index)
  return _internal_feature_index();
}
inline void HloInstructionProto::_internal_set_feature_index(int64_t value) {
  
  _impl_.feature_index_ = value;
}
inline void HloInstructionProto::set_feature_index(int64_t value) {
  _internal_set_feature_index(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.feature_index)
}

// int64 channel_id = 26;
inline void HloInstructionProto::clear_channel_id() {
  _impl_.channel_id_ = int64_t{0};
}
inline int64_t HloInstructionProto::_internal_channel_id() const {
  return _impl_.channel_id_;
}
inline int64_t HloInstructionProto::channel_id() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.channel_id)
  return _internal_channel_id();
}
inline void HloInstructionProto::_internal_set_channel_id(int64_t value) {
  
  _impl_.channel_id_ = value;
}
inline void HloInstructionProto::set_channel_id(int64_t value) {
  _internal_set_channel_id(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.channel_id)
}

// bytes infeed_config = 27;
inline void HloInstructionProto::clear_infeed_config() {
  _impl_.infeed_config_.ClearToEmpty();
}
inline const std::string& HloInstructionProto::infeed_config() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.infeed_config)
  return _internal_infeed_config();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloInstructionProto::set_infeed_config(ArgT0&& arg0, ArgT... args) {
 
 _impl_.infeed_config_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.infeed_config)
}
inline std::string* HloInstructionProto::mutable_infeed_config() {
  std::string* _s = _internal_mutable_infeed_config();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.infeed_config)
  return _s;
}
inline const std::string& HloInstructionProto::_internal_infeed_config() const {
  return _impl_.infeed_config_.Get();
}
inline void HloInstructionProto::_internal_set_infeed_config(const std::string& value) {
  
  _impl_.infeed_config_.Set(value, GetArenaForAllocation());
}
inline std::string* HloInstructionProto::_internal_mutable_infeed_config() {
  
  return _impl_.infeed_config_.Mutable(GetArenaForAllocation());
}
inline std::string* HloInstructionProto::release_infeed_config() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.infeed_config)
  return _impl_.infeed_config_.Release();
}
inline void HloInstructionProto::set_allocated_infeed_config(std::string* infeed_config) {
  if (infeed_config != nullptr) {
    
  } else {
    
  }
  _impl_.infeed_config_.SetAllocated(infeed_config, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.infeed_config_.IsDefault()) {
    _impl_.infeed_config_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.infeed_config)
}

// string custom_call_target = 28;
inline void HloInstructionProto::clear_custom_call_target() {
  _impl_.custom_call_target_.ClearToEmpty();
}
inline const std::string& HloInstructionProto::custom_call_target() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.custom_call_target)
  return _internal_custom_call_target();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloInstructionProto::set_custom_call_target(ArgT0&& arg0, ArgT... args) {
 
 _impl_.custom_call_target_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.custom_call_target)
}
inline std::string* HloInstructionProto::mutable_custom_call_target() {
  std::string* _s = _internal_mutable_custom_call_target();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.custom_call_target)
  return _s;
}
inline const std::string& HloInstructionProto::_internal_custom_call_target() const {
  return _impl_.custom_call_target_.Get();
}
inline void HloInstructionProto::_internal_set_custom_call_target(const std::string& value) {
  
  _impl_.custom_call_target_.Set(value, GetArenaForAllocation());
}
inline std::string* HloInstructionProto::_internal_mutable_custom_call_target() {
  
  return _impl_.custom_call_target_.Mutable(GetArenaForAllocation());
}
inline std::string* HloInstructionProto::release_custom_call_target() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.custom_call_target)
  return _impl_.custom_call_target_.Release();
}
inline void HloInstructionProto::set_allocated_custom_call_target(std::string* custom_call_target) {
  if (custom_call_target != nullptr) {
    
  } else {
    
  }
  _impl_.custom_call_target_.SetAllocated(custom_call_target, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.custom_call_target_.IsDefault()) {
    _impl_.custom_call_target_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.custom_call_target)
}

// .xla.ShapeProto outfeed_shape = 29;
inline bool HloInstructionProto::_internal_has_outfeed_shape() const {
  return this != internal_default_instance() && _impl_.outfeed_shape_ != nullptr;
}
inline bool HloInstructionProto::has_outfeed_shape() const {
  return _internal_has_outfeed_shape();
}
inline const ::xla::ShapeProto& HloInstructionProto::_internal_outfeed_shape() const {
  const ::xla::ShapeProto* p = _impl_.outfeed_shape_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::ShapeProto&>(
      ::xla::_ShapeProto_default_instance_);
}
inline const ::xla::ShapeProto& HloInstructionProto::outfeed_shape() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.outfeed_shape)
  return _internal_outfeed_shape();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_outfeed_shape(
    ::xla::ShapeProto* outfeed_shape) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.outfeed_shape_);
  }
  _impl_.outfeed_shape_ = outfeed_shape;
  if (outfeed_shape) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.outfeed_shape)
}
inline ::xla::ShapeProto* HloInstructionProto::release_outfeed_shape() {
  
  ::xla::ShapeProto* temp = _impl_.outfeed_shape_;
  _impl_.outfeed_shape_ = 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 ::xla::ShapeProto* HloInstructionProto::unsafe_arena_release_outfeed_shape() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.outfeed_shape)
  
  ::xla::ShapeProto* temp = _impl_.outfeed_shape_;
  _impl_.outfeed_shape_ = nullptr;
  return temp;
}
inline ::xla::ShapeProto* HloInstructionProto::_internal_mutable_outfeed_shape() {
  
  if (_impl_.outfeed_shape_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::ShapeProto>(GetArenaForAllocation());
    _impl_.outfeed_shape_ = p;
  }
  return _impl_.outfeed_shape_;
}
inline ::xla::ShapeProto* HloInstructionProto::mutable_outfeed_shape() {
  ::xla::ShapeProto* _msg = _internal_mutable_outfeed_shape();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.outfeed_shape)
  return _msg;
}
inline void HloInstructionProto::set_allocated_outfeed_shape(::xla::ShapeProto* outfeed_shape) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.outfeed_shape_);
  }
  if (outfeed_shape) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(outfeed_shape));
    if (message_arena != submessage_arena) {
      outfeed_shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, outfeed_shape, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.outfeed_shape_ = outfeed_shape;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.outfeed_shape)
}

// .xla.DotDimensionNumbers dot_dimension_numbers = 30;
inline bool HloInstructionProto::_internal_has_dot_dimension_numbers() const {
  return this != internal_default_instance() && _impl_.dot_dimension_numbers_ != nullptr;
}
inline bool HloInstructionProto::has_dot_dimension_numbers() const {
  return _internal_has_dot_dimension_numbers();
}
inline const ::xla::DotDimensionNumbers& HloInstructionProto::_internal_dot_dimension_numbers() const {
  const ::xla::DotDimensionNumbers* p = _impl_.dot_dimension_numbers_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::DotDimensionNumbers&>(
      ::xla::_DotDimensionNumbers_default_instance_);
}
inline const ::xla::DotDimensionNumbers& HloInstructionProto::dot_dimension_numbers() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.dot_dimension_numbers)
  return _internal_dot_dimension_numbers();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_dot_dimension_numbers(
    ::xla::DotDimensionNumbers* dot_dimension_numbers) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dot_dimension_numbers_);
  }
  _impl_.dot_dimension_numbers_ = dot_dimension_numbers;
  if (dot_dimension_numbers) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.dot_dimension_numbers)
}
inline ::xla::DotDimensionNumbers* HloInstructionProto::release_dot_dimension_numbers() {
  
  ::xla::DotDimensionNumbers* temp = _impl_.dot_dimension_numbers_;
  _impl_.dot_dimension_numbers_ = 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 ::xla::DotDimensionNumbers* HloInstructionProto::unsafe_arena_release_dot_dimension_numbers() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.dot_dimension_numbers)
  
  ::xla::DotDimensionNumbers* temp = _impl_.dot_dimension_numbers_;
  _impl_.dot_dimension_numbers_ = nullptr;
  return temp;
}
inline ::xla::DotDimensionNumbers* HloInstructionProto::_internal_mutable_dot_dimension_numbers() {
  
  if (_impl_.dot_dimension_numbers_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::DotDimensionNumbers>(GetArenaForAllocation());
    _impl_.dot_dimension_numbers_ = p;
  }
  return _impl_.dot_dimension_numbers_;
}
inline ::xla::DotDimensionNumbers* HloInstructionProto::mutable_dot_dimension_numbers() {
  ::xla::DotDimensionNumbers* _msg = _internal_mutable_dot_dimension_numbers();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.dot_dimension_numbers)
  return _msg;
}
inline void HloInstructionProto::set_allocated_dot_dimension_numbers(::xla::DotDimensionNumbers* dot_dimension_numbers) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dot_dimension_numbers_);
  }
  if (dot_dimension_numbers) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dot_dimension_numbers));
    if (message_arena != submessage_arena) {
      dot_dimension_numbers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dot_dimension_numbers, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.dot_dimension_numbers_ = dot_dimension_numbers;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.dot_dimension_numbers)
}

// .xla.FftType fft_type = 31;
inline void HloInstructionProto::clear_fft_type() {
  _impl_.fft_type_ = 0;
}
inline ::xla::FftType HloInstructionProto::_internal_fft_type() const {
  return static_cast< ::xla::FftType >(_impl_.fft_type_);
}
inline ::xla::FftType HloInstructionProto::fft_type() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.fft_type)
  return _internal_fft_type();
}
inline void HloInstructionProto::_internal_set_fft_type(::xla::FftType value) {
  
  _impl_.fft_type_ = value;
}
inline void HloInstructionProto::set_fft_type(::xla::FftType value) {
  _internal_set_fft_type(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.fft_type)
}

// repeated int64 fft_length = 32;
inline int HloInstructionProto::_internal_fft_length_size() const {
  return _impl_.fft_length_.size();
}
inline int HloInstructionProto::fft_length_size() const {
  return _internal_fft_length_size();
}
inline void HloInstructionProto::clear_fft_length() {
  _impl_.fft_length_.Clear();
}
inline int64_t HloInstructionProto::_internal_fft_length(int index) const {
  return _impl_.fft_length_.Get(index);
}
inline int64_t HloInstructionProto::fft_length(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.fft_length)
  return _internal_fft_length(index);
}
inline void HloInstructionProto::set_fft_length(int index, int64_t value) {
  _impl_.fft_length_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.fft_length)
}
inline void HloInstructionProto::_internal_add_fft_length(int64_t value) {
  _impl_.fft_length_.Add(value);
}
inline void HloInstructionProto::add_fft_length(int64_t value) {
  _internal_add_fft_length(value);
  // @@protoc_insertion_point(field_add:xla.HloInstructionProto.fft_length)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInstructionProto::_internal_fft_length() const {
  return _impl_.fft_length_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInstructionProto::fft_length() const {
  // @@protoc_insertion_point(field_list:xla.HloInstructionProto.fft_length)
  return _internal_fft_length();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInstructionProto::_internal_mutable_fft_length() {
  return &_impl_.fft_length_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInstructionProto::mutable_fft_length() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloInstructionProto.fft_length)
  return _internal_mutable_fft_length();
}

// string comparison_direction = 63;
inline void HloInstructionProto::clear_comparison_direction() {
  _impl_.comparison_direction_.ClearToEmpty();
}
inline const std::string& HloInstructionProto::comparison_direction() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.comparison_direction)
  return _internal_comparison_direction();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloInstructionProto::set_comparison_direction(ArgT0&& arg0, ArgT... args) {
 
 _impl_.comparison_direction_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.comparison_direction)
}
inline std::string* HloInstructionProto::mutable_comparison_direction() {
  std::string* _s = _internal_mutable_comparison_direction();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.comparison_direction)
  return _s;
}
inline const std::string& HloInstructionProto::_internal_comparison_direction() const {
  return _impl_.comparison_direction_.Get();
}
inline void HloInstructionProto::_internal_set_comparison_direction(const std::string& value) {
  
  _impl_.comparison_direction_.Set(value, GetArenaForAllocation());
}
inline std::string* HloInstructionProto::_internal_mutable_comparison_direction() {
  
  return _impl_.comparison_direction_.Mutable(GetArenaForAllocation());
}
inline std::string* HloInstructionProto::release_comparison_direction() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.comparison_direction)
  return _impl_.comparison_direction_.Release();
}
inline void HloInstructionProto::set_allocated_comparison_direction(std::string* comparison_direction) {
  if (comparison_direction != nullptr) {
    
  } else {
    
  }
  _impl_.comparison_direction_.SetAllocated(comparison_direction, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.comparison_direction_.IsDefault()) {
    _impl_.comparison_direction_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.comparison_direction)
}

// .xla.GatherDimensionNumbers gather_dimension_numbers = 33;
inline bool HloInstructionProto::_internal_has_gather_dimension_numbers() const {
  return this != internal_default_instance() && _impl_.gather_dimension_numbers_ != nullptr;
}
inline bool HloInstructionProto::has_gather_dimension_numbers() const {
  return _internal_has_gather_dimension_numbers();
}
inline const ::xla::GatherDimensionNumbers& HloInstructionProto::_internal_gather_dimension_numbers() const {
  const ::xla::GatherDimensionNumbers* p = _impl_.gather_dimension_numbers_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::GatherDimensionNumbers&>(
      ::xla::_GatherDimensionNumbers_default_instance_);
}
inline const ::xla::GatherDimensionNumbers& HloInstructionProto::gather_dimension_numbers() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.gather_dimension_numbers)
  return _internal_gather_dimension_numbers();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_gather_dimension_numbers(
    ::xla::GatherDimensionNumbers* gather_dimension_numbers) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.gather_dimension_numbers_);
  }
  _impl_.gather_dimension_numbers_ = gather_dimension_numbers;
  if (gather_dimension_numbers) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.gather_dimension_numbers)
}
inline ::xla::GatherDimensionNumbers* HloInstructionProto::release_gather_dimension_numbers() {
  
  ::xla::GatherDimensionNumbers* temp = _impl_.gather_dimension_numbers_;
  _impl_.gather_dimension_numbers_ = 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 ::xla::GatherDimensionNumbers* HloInstructionProto::unsafe_arena_release_gather_dimension_numbers() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.gather_dimension_numbers)
  
  ::xla::GatherDimensionNumbers* temp = _impl_.gather_dimension_numbers_;
  _impl_.gather_dimension_numbers_ = nullptr;
  return temp;
}
inline ::xla::GatherDimensionNumbers* HloInstructionProto::_internal_mutable_gather_dimension_numbers() {
  
  if (_impl_.gather_dimension_numbers_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::GatherDimensionNumbers>(GetArenaForAllocation());
    _impl_.gather_dimension_numbers_ = p;
  }
  return _impl_.gather_dimension_numbers_;
}
inline ::xla::GatherDimensionNumbers* HloInstructionProto::mutable_gather_dimension_numbers() {
  ::xla::GatherDimensionNumbers* _msg = _internal_mutable_gather_dimension_numbers();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.gather_dimension_numbers)
  return _msg;
}
inline void HloInstructionProto::set_allocated_gather_dimension_numbers(::xla::GatherDimensionNumbers* gather_dimension_numbers) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.gather_dimension_numbers_);
  }
  if (gather_dimension_numbers) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(gather_dimension_numbers));
    if (message_arena != submessage_arena) {
      gather_dimension_numbers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, gather_dimension_numbers, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.gather_dimension_numbers_ = gather_dimension_numbers;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.gather_dimension_numbers)
}

// repeated int64 gather_slice_sizes = 34;
inline int HloInstructionProto::_internal_gather_slice_sizes_size() const {
  return _impl_.gather_slice_sizes_.size();
}
inline int HloInstructionProto::gather_slice_sizes_size() const {
  return _internal_gather_slice_sizes_size();
}
inline void HloInstructionProto::clear_gather_slice_sizes() {
  _impl_.gather_slice_sizes_.Clear();
}
inline int64_t HloInstructionProto::_internal_gather_slice_sizes(int index) const {
  return _impl_.gather_slice_sizes_.Get(index);
}
inline int64_t HloInstructionProto::gather_slice_sizes(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.gather_slice_sizes)
  return _internal_gather_slice_sizes(index);
}
inline void HloInstructionProto::set_gather_slice_sizes(int index, int64_t value) {
  _impl_.gather_slice_sizes_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.gather_slice_sizes)
}
inline void HloInstructionProto::_internal_add_gather_slice_sizes(int64_t value) {
  _impl_.gather_slice_sizes_.Add(value);
}
inline void HloInstructionProto::add_gather_slice_sizes(int64_t value) {
  _internal_add_gather_slice_sizes(value);
  // @@protoc_insertion_point(field_add:xla.HloInstructionProto.gather_slice_sizes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInstructionProto::_internal_gather_slice_sizes() const {
  return _impl_.gather_slice_sizes_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInstructionProto::gather_slice_sizes() const {
  // @@protoc_insertion_point(field_list:xla.HloInstructionProto.gather_slice_sizes)
  return _internal_gather_slice_sizes();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInstructionProto::_internal_mutable_gather_slice_sizes() {
  return &_impl_.gather_slice_sizes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInstructionProto::mutable_gather_slice_sizes() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloInstructionProto.gather_slice_sizes)
  return _internal_mutable_gather_slice_sizes();
}

// int64 id = 35;
inline void HloInstructionProto::clear_id() {
  _impl_.id_ = int64_t{0};
}
inline int64_t HloInstructionProto::_internal_id() const {
  return _impl_.id_;
}
inline int64_t HloInstructionProto::id() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.id)
  return _internal_id();
}
inline void HloInstructionProto::_internal_set_id(int64_t value) {
  
  _impl_.id_ = value;
}
inline void HloInstructionProto::set_id(int64_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.id)
}

// repeated int64 operand_ids = 36;
inline int HloInstructionProto::_internal_operand_ids_size() const {
  return _impl_.operand_ids_.size();
}
inline int HloInstructionProto::operand_ids_size() const {
  return _internal_operand_ids_size();
}
inline void HloInstructionProto::clear_operand_ids() {
  _impl_.operand_ids_.Clear();
}
inline int64_t HloInstructionProto::_internal_operand_ids(int index) const {
  return _impl_.operand_ids_.Get(index);
}
inline int64_t HloInstructionProto::operand_ids(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.operand_ids)
  return _internal_operand_ids(index);
}
inline void HloInstructionProto::set_operand_ids(int index, int64_t value) {
  _impl_.operand_ids_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.operand_ids)
}
inline void HloInstructionProto::_internal_add_operand_ids(int64_t value) {
  _impl_.operand_ids_.Add(value);
}
inline void HloInstructionProto::add_operand_ids(int64_t value) {
  _internal_add_operand_ids(value);
  // @@protoc_insertion_point(field_add:xla.HloInstructionProto.operand_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInstructionProto::_internal_operand_ids() const {
  return _impl_.operand_ids_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInstructionProto::operand_ids() const {
  // @@protoc_insertion_point(field_list:xla.HloInstructionProto.operand_ids)
  return _internal_operand_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInstructionProto::_internal_mutable_operand_ids() {
  return &_impl_.operand_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInstructionProto::mutable_operand_ids() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloInstructionProto.operand_ids)
  return _internal_mutable_operand_ids();
}

// repeated int64 control_predecessor_ids = 37;
inline int HloInstructionProto::_internal_control_predecessor_ids_size() const {
  return _impl_.control_predecessor_ids_.size();
}
inline int HloInstructionProto::control_predecessor_ids_size() const {
  return _internal_control_predecessor_ids_size();
}
inline void HloInstructionProto::clear_control_predecessor_ids() {
  _impl_.control_predecessor_ids_.Clear();
}
inline int64_t HloInstructionProto::_internal_control_predecessor_ids(int index) const {
  return _impl_.control_predecessor_ids_.Get(index);
}
inline int64_t HloInstructionProto::control_predecessor_ids(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.control_predecessor_ids)
  return _internal_control_predecessor_ids(index);
}
inline void HloInstructionProto::set_control_predecessor_ids(int index, int64_t value) {
  _impl_.control_predecessor_ids_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.control_predecessor_ids)
}
inline void HloInstructionProto::_internal_add_control_predecessor_ids(int64_t value) {
  _impl_.control_predecessor_ids_.Add(value);
}
inline void HloInstructionProto::add_control_predecessor_ids(int64_t value) {
  _internal_add_control_predecessor_ids(value);
  // @@protoc_insertion_point(field_add:xla.HloInstructionProto.control_predecessor_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInstructionProto::_internal_control_predecessor_ids() const {
  return _impl_.control_predecessor_ids_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInstructionProto::control_predecessor_ids() const {
  // @@protoc_insertion_point(field_list:xla.HloInstructionProto.control_predecessor_ids)
  return _internal_control_predecessor_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInstructionProto::_internal_mutable_control_predecessor_ids() {
  return &_impl_.control_predecessor_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInstructionProto::mutable_control_predecessor_ids() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloInstructionProto.control_predecessor_ids)
  return _internal_mutable_control_predecessor_ids();
}

// repeated int64 called_computation_ids = 38;
inline int HloInstructionProto::_internal_called_computation_ids_size() const {
  return _impl_.called_computation_ids_.size();
}
inline int HloInstructionProto::called_computation_ids_size() const {
  return _internal_called_computation_ids_size();
}
inline void HloInstructionProto::clear_called_computation_ids() {
  _impl_.called_computation_ids_.Clear();
}
inline int64_t HloInstructionProto::_internal_called_computation_ids(int index) const {
  return _impl_.called_computation_ids_.Get(index);
}
inline int64_t HloInstructionProto::called_computation_ids(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.called_computation_ids)
  return _internal_called_computation_ids(index);
}
inline void HloInstructionProto::set_called_computation_ids(int index, int64_t value) {
  _impl_.called_computation_ids_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.called_computation_ids)
}
inline void HloInstructionProto::_internal_add_called_computation_ids(int64_t value) {
  _impl_.called_computation_ids_.Add(value);
}
inline void HloInstructionProto::add_called_computation_ids(int64_t value) {
  _internal_add_called_computation_ids(value);
  // @@protoc_insertion_point(field_add:xla.HloInstructionProto.called_computation_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInstructionProto::_internal_called_computation_ids() const {
  return _impl_.called_computation_ids_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInstructionProto::called_computation_ids() const {
  // @@protoc_insertion_point(field_list:xla.HloInstructionProto.called_computation_ids)
  return _internal_called_computation_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInstructionProto::_internal_mutable_called_computation_ids() {
  return &_impl_.called_computation_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInstructionProto::mutable_called_computation_ids() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloInstructionProto.called_computation_ids)
  return _internal_mutable_called_computation_ids();
}

// .xla.OpSharding sharding = 40;
inline bool HloInstructionProto::_internal_has_sharding() const {
  return this != internal_default_instance() && _impl_.sharding_ != nullptr;
}
inline bool HloInstructionProto::has_sharding() const {
  return _internal_has_sharding();
}
inline const ::xla::OpSharding& HloInstructionProto::_internal_sharding() const {
  const ::xla::OpSharding* p = _impl_.sharding_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::OpSharding&>(
      ::xla::_OpSharding_default_instance_);
}
inline const ::xla::OpSharding& HloInstructionProto::sharding() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.sharding)
  return _internal_sharding();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_sharding(
    ::xla::OpSharding* sharding) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sharding_);
  }
  _impl_.sharding_ = sharding;
  if (sharding) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.sharding)
}
inline ::xla::OpSharding* HloInstructionProto::release_sharding() {
  
  ::xla::OpSharding* temp = _impl_.sharding_;
  _impl_.sharding_ = 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 ::xla::OpSharding* HloInstructionProto::unsafe_arena_release_sharding() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.sharding)
  
  ::xla::OpSharding* temp = _impl_.sharding_;
  _impl_.sharding_ = nullptr;
  return temp;
}
inline ::xla::OpSharding* HloInstructionProto::_internal_mutable_sharding() {
  
  if (_impl_.sharding_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::OpSharding>(GetArenaForAllocation());
    _impl_.sharding_ = p;
  }
  return _impl_.sharding_;
}
inline ::xla::OpSharding* HloInstructionProto::mutable_sharding() {
  ::xla::OpSharding* _msg = _internal_mutable_sharding();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.sharding)
  return _msg;
}
inline void HloInstructionProto::set_allocated_sharding(::xla::OpSharding* sharding) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sharding_);
  }
  if (sharding) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sharding));
    if (message_arena != submessage_arena) {
      sharding = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sharding, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.sharding_ = sharding;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.sharding)
}

// bytes backend_config = 43;
inline void HloInstructionProto::clear_backend_config() {
  _impl_.backend_config_.ClearToEmpty();
}
inline const std::string& HloInstructionProto::backend_config() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.backend_config)
  return _internal_backend_config();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloInstructionProto::set_backend_config(ArgT0&& arg0, ArgT... args) {
 
 _impl_.backend_config_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.backend_config)
}
inline std::string* HloInstructionProto::mutable_backend_config() {
  std::string* _s = _internal_mutable_backend_config();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.backend_config)
  return _s;
}
inline const std::string& HloInstructionProto::_internal_backend_config() const {
  return _impl_.backend_config_.Get();
}
inline void HloInstructionProto::_internal_set_backend_config(const std::string& value) {
  
  _impl_.backend_config_.Set(value, GetArenaForAllocation());
}
inline std::string* HloInstructionProto::_internal_mutable_backend_config() {
  
  return _impl_.backend_config_.Mutable(GetArenaForAllocation());
}
inline std::string* HloInstructionProto::release_backend_config() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.backend_config)
  return _impl_.backend_config_.Release();
}
inline void HloInstructionProto::set_allocated_backend_config(std::string* backend_config) {
  if (backend_config != nullptr) {
    
  } else {
    
  }
  _impl_.backend_config_.SetAllocated(backend_config, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.backend_config_.IsDefault()) {
    _impl_.backend_config_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.backend_config)
}

// repeated .xla.ReplicaGroup replica_groups = 49;
inline int HloInstructionProto::_internal_replica_groups_size() const {
  return _impl_.replica_groups_.size();
}
inline int HloInstructionProto::replica_groups_size() const {
  return _internal_replica_groups_size();
}
inline ::xla::ReplicaGroup* HloInstructionProto::mutable_replica_groups(int index) {
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.replica_groups)
  return _impl_.replica_groups_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ReplicaGroup >*
HloInstructionProto::mutable_replica_groups() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloInstructionProto.replica_groups)
  return &_impl_.replica_groups_;
}
inline const ::xla::ReplicaGroup& HloInstructionProto::_internal_replica_groups(int index) const {
  return _impl_.replica_groups_.Get(index);
}
inline const ::xla::ReplicaGroup& HloInstructionProto::replica_groups(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.replica_groups)
  return _internal_replica_groups(index);
}
inline ::xla::ReplicaGroup* HloInstructionProto::_internal_add_replica_groups() {
  return _impl_.replica_groups_.Add();
}
inline ::xla::ReplicaGroup* HloInstructionProto::add_replica_groups() {
  ::xla::ReplicaGroup* _add = _internal_add_replica_groups();
  // @@protoc_insertion_point(field_add:xla.HloInstructionProto.replica_groups)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ReplicaGroup >&
HloInstructionProto::replica_groups() const {
  // @@protoc_insertion_point(field_list:xla.HloInstructionProto.replica_groups)
  return _impl_.replica_groups_;
}

// int64 all_reduce_id = 45 [deprecated = true];
inline void HloInstructionProto::clear_all_reduce_id() {
  _impl_.all_reduce_id_ = int64_t{0};
}
inline int64_t HloInstructionProto::_internal_all_reduce_id() const {
  return _impl_.all_reduce_id_;
}
inline int64_t HloInstructionProto::all_reduce_id() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.all_reduce_id)
  return _internal_all_reduce_id();
}
inline void HloInstructionProto::_internal_set_all_reduce_id(int64_t value) {
  
  _impl_.all_reduce_id_ = value;
}
inline void HloInstructionProto::set_all_reduce_id(int64_t value) {
  _internal_set_all_reduce_id(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.all_reduce_id)
}

// bool use_global_device_ids = 71;
inline void HloInstructionProto::clear_use_global_device_ids() {
  _impl_.use_global_device_ids_ = false;
}
inline bool HloInstructionProto::_internal_use_global_device_ids() const {
  return _impl_.use_global_device_ids_;
}
inline bool HloInstructionProto::use_global_device_ids() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.use_global_device_ids)
  return _internal_use_global_device_ids();
}
inline void HloInstructionProto::_internal_set_use_global_device_ids(bool value) {
  
  _impl_.use_global_device_ids_ = value;
}
inline void HloInstructionProto::set_use_global_device_ids(bool value) {
  _internal_set_use_global_device_ids(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.use_global_device_ids)
}

// bool is_host_transfer = 47;
inline void HloInstructionProto::clear_is_host_transfer() {
  _impl_.is_host_transfer_ = false;
}
inline bool HloInstructionProto::_internal_is_host_transfer() const {
  return _impl_.is_host_transfer_;
}
inline bool HloInstructionProto::is_host_transfer() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.is_host_transfer)
  return _internal_is_host_transfer();
}
inline void HloInstructionProto::_internal_set_is_host_transfer(bool value) {
  
  _impl_.is_host_transfer_ = value;
}
inline void HloInstructionProto::set_is_host_transfer(bool value) {
  _internal_set_is_host_transfer(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.is_host_transfer)
}

// bool is_stable = 60;
inline void HloInstructionProto::clear_is_stable() {
  _impl_.is_stable_ = false;
}
inline bool HloInstructionProto::_internal_is_stable() const {
  return _impl_.is_stable_;
}
inline bool HloInstructionProto::is_stable() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.is_stable)
  return _internal_is_stable();
}
inline void HloInstructionProto::_internal_set_is_stable(bool value) {
  
  _impl_.is_stable_ = value;
}
inline void HloInstructionProto::set_is_stable(bool value) {
  _internal_set_is_stable(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.is_stable)
}

// .xla.ScatterDimensionNumbers scatter_dimension_numbers = 48;
inline bool HloInstructionProto::_internal_has_scatter_dimension_numbers() const {
  return this != internal_default_instance() && _impl_.scatter_dimension_numbers_ != nullptr;
}
inline bool HloInstructionProto::has_scatter_dimension_numbers() const {
  return _internal_has_scatter_dimension_numbers();
}
inline const ::xla::ScatterDimensionNumbers& HloInstructionProto::_internal_scatter_dimension_numbers() const {
  const ::xla::ScatterDimensionNumbers* p = _impl_.scatter_dimension_numbers_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::ScatterDimensionNumbers&>(
      ::xla::_ScatterDimensionNumbers_default_instance_);
}
inline const ::xla::ScatterDimensionNumbers& HloInstructionProto::scatter_dimension_numbers() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.scatter_dimension_numbers)
  return _internal_scatter_dimension_numbers();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_scatter_dimension_numbers(
    ::xla::ScatterDimensionNumbers* scatter_dimension_numbers) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.scatter_dimension_numbers_);
  }
  _impl_.scatter_dimension_numbers_ = scatter_dimension_numbers;
  if (scatter_dimension_numbers) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.scatter_dimension_numbers)
}
inline ::xla::ScatterDimensionNumbers* HloInstructionProto::release_scatter_dimension_numbers() {
  
  ::xla::ScatterDimensionNumbers* temp = _impl_.scatter_dimension_numbers_;
  _impl_.scatter_dimension_numbers_ = 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 ::xla::ScatterDimensionNumbers* HloInstructionProto::unsafe_arena_release_scatter_dimension_numbers() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.scatter_dimension_numbers)
  
  ::xla::ScatterDimensionNumbers* temp = _impl_.scatter_dimension_numbers_;
  _impl_.scatter_dimension_numbers_ = nullptr;
  return temp;
}
inline ::xla::ScatterDimensionNumbers* HloInstructionProto::_internal_mutable_scatter_dimension_numbers() {
  
  if (_impl_.scatter_dimension_numbers_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::ScatterDimensionNumbers>(GetArenaForAllocation());
    _impl_.scatter_dimension_numbers_ = p;
  }
  return _impl_.scatter_dimension_numbers_;
}
inline ::xla::ScatterDimensionNumbers* HloInstructionProto::mutable_scatter_dimension_numbers() {
  ::xla::ScatterDimensionNumbers* _msg = _internal_mutable_scatter_dimension_numbers();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.scatter_dimension_numbers)
  return _msg;
}
inline void HloInstructionProto::set_allocated_scatter_dimension_numbers(::xla::ScatterDimensionNumbers* scatter_dimension_numbers) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.scatter_dimension_numbers_);
  }
  if (scatter_dimension_numbers) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scatter_dimension_numbers));
    if (message_arena != submessage_arena) {
      scatter_dimension_numbers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, scatter_dimension_numbers, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.scatter_dimension_numbers_ = scatter_dimension_numbers;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.scatter_dimension_numbers)
}

// .xla.PrecisionConfig precision_config = 51;
inline bool HloInstructionProto::_internal_has_precision_config() const {
  return this != internal_default_instance() && _impl_.precision_config_ != nullptr;
}
inline bool HloInstructionProto::has_precision_config() const {
  return _internal_has_precision_config();
}
inline const ::xla::PrecisionConfig& HloInstructionProto::_internal_precision_config() const {
  const ::xla::PrecisionConfig* p = _impl_.precision_config_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::PrecisionConfig&>(
      ::xla::_PrecisionConfig_default_instance_);
}
inline const ::xla::PrecisionConfig& HloInstructionProto::precision_config() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.precision_config)
  return _internal_precision_config();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_precision_config(
    ::xla::PrecisionConfig* precision_config) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.precision_config_);
  }
  _impl_.precision_config_ = precision_config;
  if (precision_config) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.precision_config)
}
inline ::xla::PrecisionConfig* HloInstructionProto::release_precision_config() {
  
  ::xla::PrecisionConfig* temp = _impl_.precision_config_;
  _impl_.precision_config_ = 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 ::xla::PrecisionConfig* HloInstructionProto::unsafe_arena_release_precision_config() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.precision_config)
  
  ::xla::PrecisionConfig* temp = _impl_.precision_config_;
  _impl_.precision_config_ = nullptr;
  return temp;
}
inline ::xla::PrecisionConfig* HloInstructionProto::_internal_mutable_precision_config() {
  
  if (_impl_.precision_config_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::PrecisionConfig>(GetArenaForAllocation());
    _impl_.precision_config_ = p;
  }
  return _impl_.precision_config_;
}
inline ::xla::PrecisionConfig* HloInstructionProto::mutable_precision_config() {
  ::xla::PrecisionConfig* _msg = _internal_mutable_precision_config();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.precision_config)
  return _msg;
}
inline void HloInstructionProto::set_allocated_precision_config(::xla::PrecisionConfig* precision_config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.precision_config_);
  }
  if (precision_config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(precision_config));
    if (message_arena != submessage_arena) {
      precision_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, precision_config, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.precision_config_ = precision_config;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.precision_config)
}

// repeated .xla.SourceTarget source_target_pairs = 52;
inline int HloInstructionProto::_internal_source_target_pairs_size() const {
  return _impl_.source_target_pairs_.size();
}
inline int HloInstructionProto::source_target_pairs_size() const {
  return _internal_source_target_pairs_size();
}
inline ::xla::SourceTarget* HloInstructionProto::mutable_source_target_pairs(int index) {
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.source_target_pairs)
  return _impl_.source_target_pairs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::SourceTarget >*
HloInstructionProto::mutable_source_target_pairs() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloInstructionProto.source_target_pairs)
  return &_impl_.source_target_pairs_;
}
inline const ::xla::SourceTarget& HloInstructionProto::_internal_source_target_pairs(int index) const {
  return _impl_.source_target_pairs_.Get(index);
}
inline const ::xla::SourceTarget& HloInstructionProto::source_target_pairs(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.source_target_pairs)
  return _internal_source_target_pairs(index);
}
inline ::xla::SourceTarget* HloInstructionProto::_internal_add_source_target_pairs() {
  return _impl_.source_target_pairs_.Add();
}
inline ::xla::SourceTarget* HloInstructionProto::add_source_target_pairs() {
  ::xla::SourceTarget* _add = _internal_add_source_target_pairs();
  // @@protoc_insertion_point(field_add:xla.HloInstructionProto.source_target_pairs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::SourceTarget >&
HloInstructionProto::source_target_pairs() const {
  // @@protoc_insertion_point(field_list:xla.HloInstructionProto.source_target_pairs)
  return _impl_.source_target_pairs_;
}

// .xla.OpSharding domain_entry_sharding = 54;
inline bool HloInstructionProto::_internal_has_domain_entry_sharding() const {
  return this != internal_default_instance() && _impl_.domain_entry_sharding_ != nullptr;
}
inline bool HloInstructionProto::has_domain_entry_sharding() const {
  return _internal_has_domain_entry_sharding();
}
inline const ::xla::OpSharding& HloInstructionProto::_internal_domain_entry_sharding() const {
  const ::xla::OpSharding* p = _impl_.domain_entry_sharding_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::OpSharding&>(
      ::xla::_OpSharding_default_instance_);
}
inline const ::xla::OpSharding& HloInstructionProto::domain_entry_sharding() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.domain_entry_sharding)
  return _internal_domain_entry_sharding();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_domain_entry_sharding(
    ::xla::OpSharding* domain_entry_sharding) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.domain_entry_sharding_);
  }
  _impl_.domain_entry_sharding_ = domain_entry_sharding;
  if (domain_entry_sharding) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.domain_entry_sharding)
}
inline ::xla::OpSharding* HloInstructionProto::release_domain_entry_sharding() {
  
  ::xla::OpSharding* temp = _impl_.domain_entry_sharding_;
  _impl_.domain_entry_sharding_ = 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 ::xla::OpSharding* HloInstructionProto::unsafe_arena_release_domain_entry_sharding() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.domain_entry_sharding)
  
  ::xla::OpSharding* temp = _impl_.domain_entry_sharding_;
  _impl_.domain_entry_sharding_ = nullptr;
  return temp;
}
inline ::xla::OpSharding* HloInstructionProto::_internal_mutable_domain_entry_sharding() {
  
  if (_impl_.domain_entry_sharding_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::OpSharding>(GetArenaForAllocation());
    _impl_.domain_entry_sharding_ = p;
  }
  return _impl_.domain_entry_sharding_;
}
inline ::xla::OpSharding* HloInstructionProto::mutable_domain_entry_sharding() {
  ::xla::OpSharding* _msg = _internal_mutable_domain_entry_sharding();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.domain_entry_sharding)
  return _msg;
}
inline void HloInstructionProto::set_allocated_domain_entry_sharding(::xla::OpSharding* domain_entry_sharding) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.domain_entry_sharding_);
  }
  if (domain_entry_sharding) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(domain_entry_sharding));
    if (message_arena != submessage_arena) {
      domain_entry_sharding = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, domain_entry_sharding, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.domain_entry_sharding_ = domain_entry_sharding;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.domain_entry_sharding)
}

// .xla.OpSharding domain_exit_sharding = 55;
inline bool HloInstructionProto::_internal_has_domain_exit_sharding() const {
  return this != internal_default_instance() && _impl_.domain_exit_sharding_ != nullptr;
}
inline bool HloInstructionProto::has_domain_exit_sharding() const {
  return _internal_has_domain_exit_sharding();
}
inline const ::xla::OpSharding& HloInstructionProto::_internal_domain_exit_sharding() const {
  const ::xla::OpSharding* p = _impl_.domain_exit_sharding_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::OpSharding&>(
      ::xla::_OpSharding_default_instance_);
}
inline const ::xla::OpSharding& HloInstructionProto::domain_exit_sharding() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.domain_exit_sharding)
  return _internal_domain_exit_sharding();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_domain_exit_sharding(
    ::xla::OpSharding* domain_exit_sharding) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.domain_exit_sharding_);
  }
  _impl_.domain_exit_sharding_ = domain_exit_sharding;
  if (domain_exit_sharding) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.domain_exit_sharding)
}
inline ::xla::OpSharding* HloInstructionProto::release_domain_exit_sharding() {
  
  ::xla::OpSharding* temp = _impl_.domain_exit_sharding_;
  _impl_.domain_exit_sharding_ = 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 ::xla::OpSharding* HloInstructionProto::unsafe_arena_release_domain_exit_sharding() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.domain_exit_sharding)
  
  ::xla::OpSharding* temp = _impl_.domain_exit_sharding_;
  _impl_.domain_exit_sharding_ = nullptr;
  return temp;
}
inline ::xla::OpSharding* HloInstructionProto::_internal_mutable_domain_exit_sharding() {
  
  if (_impl_.domain_exit_sharding_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::OpSharding>(GetArenaForAllocation());
    _impl_.domain_exit_sharding_ = p;
  }
  return _impl_.domain_exit_sharding_;
}
inline ::xla::OpSharding* HloInstructionProto::mutable_domain_exit_sharding() {
  ::xla::OpSharding* _msg = _internal_mutable_domain_exit_sharding();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.domain_exit_sharding)
  return _msg;
}
inline void HloInstructionProto::set_allocated_domain_exit_sharding(::xla::OpSharding* domain_exit_sharding) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.domain_exit_sharding_);
  }
  if (domain_exit_sharding) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(domain_exit_sharding));
    if (message_arena != submessage_arena) {
      domain_exit_sharding = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, domain_exit_sharding, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.domain_exit_sharding_ = domain_exit_sharding;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.domain_exit_sharding)
}

// bool constrain_layout = 56;
inline void HloInstructionProto::clear_constrain_layout() {
  _impl_.constrain_layout_ = false;
}
inline bool HloInstructionProto::_internal_constrain_layout() const {
  return _impl_.constrain_layout_;
}
inline bool HloInstructionProto::constrain_layout() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.constrain_layout)
  return _internal_constrain_layout();
}
inline void HloInstructionProto::_internal_set_constrain_layout(bool value) {
  
  _impl_.constrain_layout_ = value;
}
inline void HloInstructionProto::set_constrain_layout(bool value) {
  _internal_set_constrain_layout(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.constrain_layout)
}

// repeated .xla.ShapeProto operand_shapes_with_layout = 57;
inline int HloInstructionProto::_internal_operand_shapes_with_layout_size() const {
  return _impl_.operand_shapes_with_layout_.size();
}
inline int HloInstructionProto::operand_shapes_with_layout_size() const {
  return _internal_operand_shapes_with_layout_size();
}
inline ::xla::ShapeProto* HloInstructionProto::mutable_operand_shapes_with_layout(int index) {
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.operand_shapes_with_layout)
  return _impl_.operand_shapes_with_layout_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShapeProto >*
HloInstructionProto::mutable_operand_shapes_with_layout() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloInstructionProto.operand_shapes_with_layout)
  return &_impl_.operand_shapes_with_layout_;
}
inline const ::xla::ShapeProto& HloInstructionProto::_internal_operand_shapes_with_layout(int index) const {
  return _impl_.operand_shapes_with_layout_.Get(index);
}
inline const ::xla::ShapeProto& HloInstructionProto::operand_shapes_with_layout(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.operand_shapes_with_layout)
  return _internal_operand_shapes_with_layout(index);
}
inline ::xla::ShapeProto* HloInstructionProto::_internal_add_operand_shapes_with_layout() {
  return _impl_.operand_shapes_with_layout_.Add();
}
inline ::xla::ShapeProto* HloInstructionProto::add_operand_shapes_with_layout() {
  ::xla::ShapeProto* _add = _internal_add_operand_shapes_with_layout();
  // @@protoc_insertion_point(field_add:xla.HloInstructionProto.operand_shapes_with_layout)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShapeProto >&
HloInstructionProto::operand_shapes_with_layout() const {
  // @@protoc_insertion_point(field_list:xla.HloInstructionProto.operand_shapes_with_layout)
  return _impl_.operand_shapes_with_layout_;
}

// .xla.TriangularSolveOptions triangular_solve_options = 59;
inline bool HloInstructionProto::_internal_has_triangular_solve_options() const {
  return this != internal_default_instance() && _impl_.triangular_solve_options_ != nullptr;
}
inline bool HloInstructionProto::has_triangular_solve_options() const {
  return _internal_has_triangular_solve_options();
}
inline const ::xla::TriangularSolveOptions& HloInstructionProto::_internal_triangular_solve_options() const {
  const ::xla::TriangularSolveOptions* p = _impl_.triangular_solve_options_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::TriangularSolveOptions&>(
      ::xla::_TriangularSolveOptions_default_instance_);
}
inline const ::xla::TriangularSolveOptions& HloInstructionProto::triangular_solve_options() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.triangular_solve_options)
  return _internal_triangular_solve_options();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_triangular_solve_options(
    ::xla::TriangularSolveOptions* triangular_solve_options) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.triangular_solve_options_);
  }
  _impl_.triangular_solve_options_ = triangular_solve_options;
  if (triangular_solve_options) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.triangular_solve_options)
}
inline ::xla::TriangularSolveOptions* HloInstructionProto::release_triangular_solve_options() {
  
  ::xla::TriangularSolveOptions* temp = _impl_.triangular_solve_options_;
  _impl_.triangular_solve_options_ = 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 ::xla::TriangularSolveOptions* HloInstructionProto::unsafe_arena_release_triangular_solve_options() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.triangular_solve_options)
  
  ::xla::TriangularSolveOptions* temp = _impl_.triangular_solve_options_;
  _impl_.triangular_solve_options_ = nullptr;
  return temp;
}
inline ::xla::TriangularSolveOptions* HloInstructionProto::_internal_mutable_triangular_solve_options() {
  
  if (_impl_.triangular_solve_options_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::TriangularSolveOptions>(GetArenaForAllocation());
    _impl_.triangular_solve_options_ = p;
  }
  return _impl_.triangular_solve_options_;
}
inline ::xla::TriangularSolveOptions* HloInstructionProto::mutable_triangular_solve_options() {
  ::xla::TriangularSolveOptions* _msg = _internal_mutable_triangular_solve_options();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.triangular_solve_options)
  return _msg;
}
inline void HloInstructionProto::set_allocated_triangular_solve_options(::xla::TriangularSolveOptions* triangular_solve_options) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.triangular_solve_options_);
  }
  if (triangular_solve_options) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(triangular_solve_options));
    if (message_arena != submessage_arena) {
      triangular_solve_options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, triangular_solve_options, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.triangular_solve_options_ = triangular_solve_options;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.triangular_solve_options)
}

// .xla.CholeskyOptions cholesky_options = 62;
inline bool HloInstructionProto::_internal_has_cholesky_options() const {
  return this != internal_default_instance() && _impl_.cholesky_options_ != nullptr;
}
inline bool HloInstructionProto::has_cholesky_options() const {
  return _internal_has_cholesky_options();
}
inline const ::xla::CholeskyOptions& HloInstructionProto::_internal_cholesky_options() const {
  const ::xla::CholeskyOptions* p = _impl_.cholesky_options_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::CholeskyOptions&>(
      ::xla::_CholeskyOptions_default_instance_);
}
inline const ::xla::CholeskyOptions& HloInstructionProto::cholesky_options() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.cholesky_options)
  return _internal_cholesky_options();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_cholesky_options(
    ::xla::CholeskyOptions* cholesky_options) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cholesky_options_);
  }
  _impl_.cholesky_options_ = cholesky_options;
  if (cholesky_options) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.cholesky_options)
}
inline ::xla::CholeskyOptions* HloInstructionProto::release_cholesky_options() {
  
  ::xla::CholeskyOptions* temp = _impl_.cholesky_options_;
  _impl_.cholesky_options_ = 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 ::xla::CholeskyOptions* HloInstructionProto::unsafe_arena_release_cholesky_options() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.cholesky_options)
  
  ::xla::CholeskyOptions* temp = _impl_.cholesky_options_;
  _impl_.cholesky_options_ = nullptr;
  return temp;
}
inline ::xla::CholeskyOptions* HloInstructionProto::_internal_mutable_cholesky_options() {
  
  if (_impl_.cholesky_options_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::CholeskyOptions>(GetArenaForAllocation());
    _impl_.cholesky_options_ = p;
  }
  return _impl_.cholesky_options_;
}
inline ::xla::CholeskyOptions* HloInstructionProto::mutable_cholesky_options() {
  ::xla::CholeskyOptions* _msg = _internal_mutable_cholesky_options();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.cholesky_options)
  return _msg;
}
inline void HloInstructionProto::set_allocated_cholesky_options(::xla::CholeskyOptions* cholesky_options) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cholesky_options_);
  }
  if (cholesky_options) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cholesky_options));
    if (message_arena != submessage_arena) {
      cholesky_options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cholesky_options, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.cholesky_options_ = cholesky_options;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.cholesky_options)
}

// .xla.ParameterReplication parameter_replication = 61;
inline bool HloInstructionProto::_internal_has_parameter_replication() const {
  return this != internal_default_instance() && _impl_.parameter_replication_ != nullptr;
}
inline bool HloInstructionProto::has_parameter_replication() const {
  return _internal_has_parameter_replication();
}
inline const ::xla::ParameterReplication& HloInstructionProto::_internal_parameter_replication() const {
  const ::xla::ParameterReplication* p = _impl_.parameter_replication_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::ParameterReplication&>(
      ::xla::_ParameterReplication_default_instance_);
}
inline const ::xla::ParameterReplication& HloInstructionProto::parameter_replication() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.parameter_replication)
  return _internal_parameter_replication();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_parameter_replication(
    ::xla::ParameterReplication* parameter_replication) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.parameter_replication_);
  }
  _impl_.parameter_replication_ = parameter_replication;
  if (parameter_replication) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.parameter_replication)
}
inline ::xla::ParameterReplication* HloInstructionProto::release_parameter_replication() {
  
  ::xla::ParameterReplication* temp = _impl_.parameter_replication_;
  _impl_.parameter_replication_ = 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 ::xla::ParameterReplication* HloInstructionProto::unsafe_arena_release_parameter_replication() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.parameter_replication)
  
  ::xla::ParameterReplication* temp = _impl_.parameter_replication_;
  _impl_.parameter_replication_ = nullptr;
  return temp;
}
inline ::xla::ParameterReplication* HloInstructionProto::_internal_mutable_parameter_replication() {
  
  if (_impl_.parameter_replication_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::ParameterReplication>(GetArenaForAllocation());
    _impl_.parameter_replication_ = p;
  }
  return _impl_.parameter_replication_;
}
inline ::xla::ParameterReplication* HloInstructionProto::mutable_parameter_replication() {
  ::xla::ParameterReplication* _msg = _internal_mutable_parameter_replication();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.parameter_replication)
  return _msg;
}
inline void HloInstructionProto::set_allocated_parameter_replication(::xla::ParameterReplication* parameter_replication) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.parameter_replication_);
  }
  if (parameter_replication) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(parameter_replication));
    if (message_arena != submessage_arena) {
      parameter_replication = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, parameter_replication, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.parameter_replication_ = parameter_replication;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.parameter_replication)
}

// bool custom_call_has_side_effect = 65;
inline void HloInstructionProto::clear_custom_call_has_side_effect() {
  _impl_.custom_call_has_side_effect_ = false;
}
inline bool HloInstructionProto::_internal_custom_call_has_side_effect() const {
  return _impl_.custom_call_has_side_effect_;
}
inline bool HloInstructionProto::custom_call_has_side_effect() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.custom_call_has_side_effect)
  return _internal_custom_call_has_side_effect();
}
inline void HloInstructionProto::_internal_set_custom_call_has_side_effect(bool value) {
  
  _impl_.custom_call_has_side_effect_ = value;
}
inline void HloInstructionProto::set_custom_call_has_side_effect(bool value) {
  _internal_set_custom_call_has_side_effect(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.custom_call_has_side_effect)
}

// repeated .xla.OutputOperandAliasing output_operand_aliasing = 74;
inline int HloInstructionProto::_internal_output_operand_aliasing_size() const {
  return _impl_.output_operand_aliasing_.size();
}
inline int HloInstructionProto::output_operand_aliasing_size() const {
  return _internal_output_operand_aliasing_size();
}
inline ::xla::OutputOperandAliasing* HloInstructionProto::mutable_output_operand_aliasing(int index) {
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.output_operand_aliasing)
  return _impl_.output_operand_aliasing_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::OutputOperandAliasing >*
HloInstructionProto::mutable_output_operand_aliasing() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloInstructionProto.output_operand_aliasing)
  return &_impl_.output_operand_aliasing_;
}
inline const ::xla::OutputOperandAliasing& HloInstructionProto::_internal_output_operand_aliasing(int index) const {
  return _impl_.output_operand_aliasing_.Get(index);
}
inline const ::xla::OutputOperandAliasing& HloInstructionProto::output_operand_aliasing(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.output_operand_aliasing)
  return _internal_output_operand_aliasing(index);
}
inline ::xla::OutputOperandAliasing* HloInstructionProto::_internal_add_output_operand_aliasing() {
  return _impl_.output_operand_aliasing_.Add();
}
inline ::xla::OutputOperandAliasing* HloInstructionProto::add_output_operand_aliasing() {
  ::xla::OutputOperandAliasing* _add = _internal_add_output_operand_aliasing();
  // @@protoc_insertion_point(field_add:xla.HloInstructionProto.output_operand_aliasing)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::OutputOperandAliasing >&
HloInstructionProto::output_operand_aliasing() const {
  // @@protoc_insertion_point(field_list:xla.HloInstructionProto.output_operand_aliasing)
  return _impl_.output_operand_aliasing_;
}

// .xla.CustomCallSchedule custom_call_schedule = 76;
inline void HloInstructionProto::clear_custom_call_schedule() {
  _impl_.custom_call_schedule_ = 0;
}
inline ::xla::CustomCallSchedule HloInstructionProto::_internal_custom_call_schedule() const {
  return static_cast< ::xla::CustomCallSchedule >(_impl_.custom_call_schedule_);
}
inline ::xla::CustomCallSchedule HloInstructionProto::custom_call_schedule() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.custom_call_schedule)
  return _internal_custom_call_schedule();
}
inline void HloInstructionProto::_internal_set_custom_call_schedule(::xla::CustomCallSchedule value) {
  
  _impl_.custom_call_schedule_ = value;
}
inline void HloInstructionProto::set_custom_call_schedule(::xla::CustomCallSchedule value) {
  _internal_set_custom_call_schedule(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.custom_call_schedule)
}

// int64 delta = 66;
inline void HloInstructionProto::clear_delta() {
  _impl_.delta_ = int64_t{0};
}
inline int64_t HloInstructionProto::_internal_delta() const {
  return _impl_.delta_;
}
inline int64_t HloInstructionProto::delta() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.delta)
  return _internal_delta();
}
inline void HloInstructionProto::_internal_set_delta(int64_t value) {
  
  _impl_.delta_ = value;
}
inline void HloInstructionProto::set_delta(int64_t value) {
  _internal_set_delta(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.delta)
}

// bool indices_are_sorted = 67;
inline void HloInstructionProto::clear_indices_are_sorted() {
  _impl_.indices_are_sorted_ = false;
}
inline bool HloInstructionProto::_internal_indices_are_sorted() const {
  return _impl_.indices_are_sorted_;
}
inline bool HloInstructionProto::indices_are_sorted() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.indices_are_sorted)
  return _internal_indices_are_sorted();
}
inline void HloInstructionProto::_internal_set_indices_are_sorted(bool value) {
  
  _impl_.indices_are_sorted_ = value;
}
inline void HloInstructionProto::set_indices_are_sorted(bool value) {
  _internal_set_indices_are_sorted(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.indices_are_sorted)
}

// .xla.FrontendAttributes frontend_attributes = 68;
inline bool HloInstructionProto::_internal_has_frontend_attributes() const {
  return this != internal_default_instance() && _impl_.frontend_attributes_ != nullptr;
}
inline bool HloInstructionProto::has_frontend_attributes() const {
  return _internal_has_frontend_attributes();
}
inline const ::xla::FrontendAttributes& HloInstructionProto::_internal_frontend_attributes() const {
  const ::xla::FrontendAttributes* p = _impl_.frontend_attributes_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::FrontendAttributes&>(
      ::xla::_FrontendAttributes_default_instance_);
}
inline const ::xla::FrontendAttributes& HloInstructionProto::frontend_attributes() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.frontend_attributes)
  return _internal_frontend_attributes();
}
inline void HloInstructionProto::unsafe_arena_set_allocated_frontend_attributes(
    ::xla::FrontendAttributes* frontend_attributes) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.frontend_attributes_);
  }
  _impl_.frontend_attributes_ = frontend_attributes;
  if (frontend_attributes) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloInstructionProto.frontend_attributes)
}
inline ::xla::FrontendAttributes* HloInstructionProto::release_frontend_attributes() {
  
  ::xla::FrontendAttributes* temp = _impl_.frontend_attributes_;
  _impl_.frontend_attributes_ = 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 ::xla::FrontendAttributes* HloInstructionProto::unsafe_arena_release_frontend_attributes() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.frontend_attributes)
  
  ::xla::FrontendAttributes* temp = _impl_.frontend_attributes_;
  _impl_.frontend_attributes_ = nullptr;
  return temp;
}
inline ::xla::FrontendAttributes* HloInstructionProto::_internal_mutable_frontend_attributes() {
  
  if (_impl_.frontend_attributes_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::FrontendAttributes>(GetArenaForAllocation());
    _impl_.frontend_attributes_ = p;
  }
  return _impl_.frontend_attributes_;
}
inline ::xla::FrontendAttributes* HloInstructionProto::mutable_frontend_attributes() {
  ::xla::FrontendAttributes* _msg = _internal_mutable_frontend_attributes();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.frontend_attributes)
  return _msg;
}
inline void HloInstructionProto::set_allocated_frontend_attributes(::xla::FrontendAttributes* frontend_attributes) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.frontend_attributes_);
  }
  if (frontend_attributes) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(frontend_attributes));
    if (message_arena != submessage_arena) {
      frontend_attributes = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, frontend_attributes, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.frontend_attributes_ = frontend_attributes;
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.frontend_attributes)
}

// bool unique_indices = 69;
inline void HloInstructionProto::clear_unique_indices() {
  _impl_.unique_indices_ = false;
}
inline bool HloInstructionProto::_internal_unique_indices() const {
  return _impl_.unique_indices_;
}
inline bool HloInstructionProto::unique_indices() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.unique_indices)
  return _internal_unique_indices();
}
inline void HloInstructionProto::_internal_set_unique_indices(bool value) {
  
  _impl_.unique_indices_ = value;
}
inline void HloInstructionProto::set_unique_indices(bool value) {
  _internal_set_unique_indices(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.unique_indices)
}

// .xla.RandomAlgorithm rng_algorithm = 70;
inline void HloInstructionProto::clear_rng_algorithm() {
  _impl_.rng_algorithm_ = 0;
}
inline ::xla::RandomAlgorithm HloInstructionProto::_internal_rng_algorithm() const {
  return static_cast< ::xla::RandomAlgorithm >(_impl_.rng_algorithm_);
}
inline ::xla::RandomAlgorithm HloInstructionProto::rng_algorithm() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.rng_algorithm)
  return _internal_rng_algorithm();
}
inline void HloInstructionProto::_internal_set_rng_algorithm(::xla::RandomAlgorithm value) {
  
  _impl_.rng_algorithm_ = value;
}
inline void HloInstructionProto::set_rng_algorithm(::xla::RandomAlgorithm value) {
  _internal_set_rng_algorithm(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.rng_algorithm)
}

// string comparison_type = 72;
inline void HloInstructionProto::clear_comparison_type() {
  _impl_.comparison_type_.ClearToEmpty();
}
inline const std::string& HloInstructionProto::comparison_type() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.comparison_type)
  return _internal_comparison_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloInstructionProto::set_comparison_type(ArgT0&& arg0, ArgT... args) {
 
 _impl_.comparison_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.comparison_type)
}
inline std::string* HloInstructionProto::mutable_comparison_type() {
  std::string* _s = _internal_mutable_comparison_type();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.comparison_type)
  return _s;
}
inline const std::string& HloInstructionProto::_internal_comparison_type() const {
  return _impl_.comparison_type_.Get();
}
inline void HloInstructionProto::_internal_set_comparison_type(const std::string& value) {
  
  _impl_.comparison_type_.Set(value, GetArenaForAllocation());
}
inline std::string* HloInstructionProto::_internal_mutable_comparison_type() {
  
  return _impl_.comparison_type_.Mutable(GetArenaForAllocation());
}
inline std::string* HloInstructionProto::release_comparison_type() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.comparison_type)
  return _impl_.comparison_type_.Release();
}
inline void HloInstructionProto::set_allocated_comparison_type(std::string* comparison_type) {
  if (comparison_type != nullptr) {
    
  } else {
    
  }
  _impl_.comparison_type_.SetAllocated(comparison_type, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.comparison_type_.IsDefault()) {
    _impl_.comparison_type_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.comparison_type)
}

// bool is_cross_program_prefetch = 73 [deprecated = true];
inline void HloInstructionProto::clear_is_cross_program_prefetch() {
  _impl_.is_cross_program_prefetch_ = false;
}
inline bool HloInstructionProto::_internal_is_cross_program_prefetch() const {
  return _impl_.is_cross_program_prefetch_;
}
inline bool HloInstructionProto::is_cross_program_prefetch() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.is_cross_program_prefetch)
  return _internal_is_cross_program_prefetch();
}
inline void HloInstructionProto::_internal_set_is_cross_program_prefetch(bool value) {
  
  _impl_.is_cross_program_prefetch_ = value;
}
inline void HloInstructionProto::set_is_cross_program_prefetch(bool value) {
  _internal_set_is_cross_program_prefetch(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.is_cross_program_prefetch)
}

// int32 cross_program_prefetch_index = 80;
inline bool HloInstructionProto::_internal_has_cross_program_prefetch_index() const {
  return optional_cross_program_prefetch_index_case() == kCrossProgramPrefetchIndex;
}
inline bool HloInstructionProto::has_cross_program_prefetch_index() const {
  return _internal_has_cross_program_prefetch_index();
}
inline void HloInstructionProto::set_has_cross_program_prefetch_index() {
  _impl_._oneof_case_[0] = kCrossProgramPrefetchIndex;
}
inline void HloInstructionProto::clear_cross_program_prefetch_index() {
  if (_internal_has_cross_program_prefetch_index()) {
    _impl_.optional_cross_program_prefetch_index_.cross_program_prefetch_index_ = 0;
    clear_has_optional_cross_program_prefetch_index();
  }
}
inline int32_t HloInstructionProto::_internal_cross_program_prefetch_index() const {
  if (_internal_has_cross_program_prefetch_index()) {
    return _impl_.optional_cross_program_prefetch_index_.cross_program_prefetch_index_;
  }
  return 0;
}
inline void HloInstructionProto::_internal_set_cross_program_prefetch_index(int32_t value) {
  if (!_internal_has_cross_program_prefetch_index()) {
    clear_optional_cross_program_prefetch_index();
    set_has_cross_program_prefetch_index();
  }
  _impl_.optional_cross_program_prefetch_index_.cross_program_prefetch_index_ = value;
}
inline int32_t HloInstructionProto::cross_program_prefetch_index() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.cross_program_prefetch_index)
  return _internal_cross_program_prefetch_index();
}
inline void HloInstructionProto::set_cross_program_prefetch_index(int32_t value) {
  _internal_set_cross_program_prefetch_index(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.cross_program_prefetch_index)
}

// .xla.PaddingType padding_type = 75;
inline void HloInstructionProto::clear_padding_type() {
  _impl_.padding_type_ = 0;
}
inline ::xla::PaddingType HloInstructionProto::_internal_padding_type() const {
  return static_cast< ::xla::PaddingType >(_impl_.padding_type_);
}
inline ::xla::PaddingType HloInstructionProto::padding_type() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.padding_type)
  return _internal_padding_type();
}
inline void HloInstructionProto::_internal_set_padding_type(::xla::PaddingType value) {
  
  _impl_.padding_type_ = value;
}
inline void HloInstructionProto::set_padding_type(::xla::PaddingType value) {
  _internal_set_padding_type(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.padding_type)
}

// .xla.CustomCallApiVersion custom_call_api_version = 77;
inline void HloInstructionProto::clear_custom_call_api_version() {
  _impl_.custom_call_api_version_ = 0;
}
inline ::xla::CustomCallApiVersion HloInstructionProto::_internal_custom_call_api_version() const {
  return static_cast< ::xla::CustomCallApiVersion >(_impl_.custom_call_api_version_);
}
inline ::xla::CustomCallApiVersion HloInstructionProto::custom_call_api_version() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.custom_call_api_version)
  return _internal_custom_call_api_version();
}
inline void HloInstructionProto::_internal_set_custom_call_api_version(::xla::CustomCallApiVersion value) {
  
  _impl_.custom_call_api_version_ = value;
}
inline void HloInstructionProto::set_custom_call_api_version(::xla::CustomCallApiVersion value) {
  _internal_set_custom_call_api_version(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.custom_call_api_version)
}

// int64 async_group_id = 78;
inline void HloInstructionProto::clear_async_group_id() {
  _impl_.async_group_id_ = int64_t{0};
}
inline int64_t HloInstructionProto::_internal_async_group_id() const {
  return _impl_.async_group_id_;
}
inline int64_t HloInstructionProto::async_group_id() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.async_group_id)
  return _internal_async_group_id();
}
inline void HloInstructionProto::_internal_set_async_group_id(int64_t value) {
  
  _impl_.async_group_id_ = value;
}
inline void HloInstructionProto::set_async_group_id(int64_t value) {
  _internal_set_async_group_id(value);
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.async_group_id)
}

// string async_execution_thread = 79;
inline void HloInstructionProto::clear_async_execution_thread() {
  _impl_.async_execution_thread_.ClearToEmpty();
}
inline const std::string& HloInstructionProto::async_execution_thread() const {
  // @@protoc_insertion_point(field_get:xla.HloInstructionProto.async_execution_thread)
  return _internal_async_execution_thread();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloInstructionProto::set_async_execution_thread(ArgT0&& arg0, ArgT... args) {
 
 _impl_.async_execution_thread_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloInstructionProto.async_execution_thread)
}
inline std::string* HloInstructionProto::mutable_async_execution_thread() {
  std::string* _s = _internal_mutable_async_execution_thread();
  // @@protoc_insertion_point(field_mutable:xla.HloInstructionProto.async_execution_thread)
  return _s;
}
inline const std::string& HloInstructionProto::_internal_async_execution_thread() const {
  return _impl_.async_execution_thread_.Get();
}
inline void HloInstructionProto::_internal_set_async_execution_thread(const std::string& value) {
  
  _impl_.async_execution_thread_.Set(value, GetArenaForAllocation());
}
inline std::string* HloInstructionProto::_internal_mutable_async_execution_thread() {
  
  return _impl_.async_execution_thread_.Mutable(GetArenaForAllocation());
}
inline std::string* HloInstructionProto::release_async_execution_thread() {
  // @@protoc_insertion_point(field_release:xla.HloInstructionProto.async_execution_thread)
  return _impl_.async_execution_thread_.Release();
}
inline void HloInstructionProto::set_allocated_async_execution_thread(std::string* async_execution_thread) {
  if (async_execution_thread != nullptr) {
    
  } else {
    
  }
  _impl_.async_execution_thread_.SetAllocated(async_execution_thread, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.async_execution_thread_.IsDefault()) {
    _impl_.async_execution_thread_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloInstructionProto.async_execution_thread)
}

inline bool HloInstructionProto::has_optional_cross_program_prefetch_index() const {
  return optional_cross_program_prefetch_index_case() != OPTIONAL_CROSS_PROGRAM_PREFETCH_INDEX_NOT_SET;
}
inline void HloInstructionProto::clear_has_optional_cross_program_prefetch_index() {
  _impl_._oneof_case_[0] = OPTIONAL_CROSS_PROGRAM_PREFETCH_INDEX_NOT_SET;
}
inline HloInstructionProto::OptionalCrossProgramPrefetchIndexCase HloInstructionProto::optional_cross_program_prefetch_index_case() const {
  return HloInstructionProto::OptionalCrossProgramPrefetchIndexCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// HloComputationProto

// string name = 1;
inline void HloComputationProto::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& HloComputationProto::name() const {
  // @@protoc_insertion_point(field_get:xla.HloComputationProto.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloComputationProto::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloComputationProto.name)
}
inline std::string* HloComputationProto::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:xla.HloComputationProto.name)
  return _s;
}
inline const std::string& HloComputationProto::_internal_name() const {
  return _impl_.name_.Get();
}
inline void HloComputationProto::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* HloComputationProto::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* HloComputationProto::release_name() {
  // @@protoc_insertion_point(field_release:xla.HloComputationProto.name)
  return _impl_.name_.Release();
}
inline void HloComputationProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _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:xla.HloComputationProto.name)
}

// repeated .xla.HloInstructionProto instructions = 2;
inline int HloComputationProto::_internal_instructions_size() const {
  return _impl_.instructions_.size();
}
inline int HloComputationProto::instructions_size() const {
  return _internal_instructions_size();
}
inline void HloComputationProto::clear_instructions() {
  _impl_.instructions_.Clear();
}
inline ::xla::HloInstructionProto* HloComputationProto::mutable_instructions(int index) {
  // @@protoc_insertion_point(field_mutable:xla.HloComputationProto.instructions)
  return _impl_.instructions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloInstructionProto >*
HloComputationProto::mutable_instructions() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloComputationProto.instructions)
  return &_impl_.instructions_;
}
inline const ::xla::HloInstructionProto& HloComputationProto::_internal_instructions(int index) const {
  return _impl_.instructions_.Get(index);
}
inline const ::xla::HloInstructionProto& HloComputationProto::instructions(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloComputationProto.instructions)
  return _internal_instructions(index);
}
inline ::xla::HloInstructionProto* HloComputationProto::_internal_add_instructions() {
  return _impl_.instructions_.Add();
}
inline ::xla::HloInstructionProto* HloComputationProto::add_instructions() {
  ::xla::HloInstructionProto* _add = _internal_add_instructions();
  // @@protoc_insertion_point(field_add:xla.HloComputationProto.instructions)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloInstructionProto >&
HloComputationProto::instructions() const {
  // @@protoc_insertion_point(field_list:xla.HloComputationProto.instructions)
  return _impl_.instructions_;
}

// .xla.ProgramShapeProto program_shape = 4;
inline bool HloComputationProto::_internal_has_program_shape() const {
  return this != internal_default_instance() && _impl_.program_shape_ != nullptr;
}
inline bool HloComputationProto::has_program_shape() const {
  return _internal_has_program_shape();
}
inline const ::xla::ProgramShapeProto& HloComputationProto::_internal_program_shape() const {
  const ::xla::ProgramShapeProto* p = _impl_.program_shape_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::ProgramShapeProto&>(
      ::xla::_ProgramShapeProto_default_instance_);
}
inline const ::xla::ProgramShapeProto& HloComputationProto::program_shape() const {
  // @@protoc_insertion_point(field_get:xla.HloComputationProto.program_shape)
  return _internal_program_shape();
}
inline void HloComputationProto::unsafe_arena_set_allocated_program_shape(
    ::xla::ProgramShapeProto* program_shape) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.program_shape_);
  }
  _impl_.program_shape_ = program_shape;
  if (program_shape) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloComputationProto.program_shape)
}
inline ::xla::ProgramShapeProto* HloComputationProto::release_program_shape() {
  
  ::xla::ProgramShapeProto* temp = _impl_.program_shape_;
  _impl_.program_shape_ = 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 ::xla::ProgramShapeProto* HloComputationProto::unsafe_arena_release_program_shape() {
  // @@protoc_insertion_point(field_release:xla.HloComputationProto.program_shape)
  
  ::xla::ProgramShapeProto* temp = _impl_.program_shape_;
  _impl_.program_shape_ = nullptr;
  return temp;
}
inline ::xla::ProgramShapeProto* HloComputationProto::_internal_mutable_program_shape() {
  
  if (_impl_.program_shape_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::ProgramShapeProto>(GetArenaForAllocation());
    _impl_.program_shape_ = p;
  }
  return _impl_.program_shape_;
}
inline ::xla::ProgramShapeProto* HloComputationProto::mutable_program_shape() {
  ::xla::ProgramShapeProto* _msg = _internal_mutable_program_shape();
  // @@protoc_insertion_point(field_mutable:xla.HloComputationProto.program_shape)
  return _msg;
}
inline void HloComputationProto::set_allocated_program_shape(::xla::ProgramShapeProto* program_shape) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.program_shape_);
  }
  if (program_shape) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(program_shape));
    if (message_arena != submessage_arena) {
      program_shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, program_shape, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.program_shape_ = program_shape;
  // @@protoc_insertion_point(field_set_allocated:xla.HloComputationProto.program_shape)
}

// int64 id = 5;
inline void HloComputationProto::clear_id() {
  _impl_.id_ = int64_t{0};
}
inline int64_t HloComputationProto::_internal_id() const {
  return _impl_.id_;
}
inline int64_t HloComputationProto::id() const {
  // @@protoc_insertion_point(field_get:xla.HloComputationProto.id)
  return _internal_id();
}
inline void HloComputationProto::_internal_set_id(int64_t value) {
  
  _impl_.id_ = value;
}
inline void HloComputationProto::set_id(int64_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:xla.HloComputationProto.id)
}

// int64 root_id = 6;
inline void HloComputationProto::clear_root_id() {
  _impl_.root_id_ = int64_t{0};
}
inline int64_t HloComputationProto::_internal_root_id() const {
  return _impl_.root_id_;
}
inline int64_t HloComputationProto::root_id() const {
  // @@protoc_insertion_point(field_get:xla.HloComputationProto.root_id)
  return _internal_root_id();
}
inline void HloComputationProto::_internal_set_root_id(int64_t value) {
  
  _impl_.root_id_ = value;
}
inline void HloComputationProto::set_root_id(int64_t value) {
  _internal_set_root_id(value);
  // @@protoc_insertion_point(field_set:xla.HloComputationProto.root_id)
}

// bool is_fusion_computation = 7;
inline void HloComputationProto::clear_is_fusion_computation() {
  _impl_.is_fusion_computation_ = false;
}
inline bool HloComputationProto::_internal_is_fusion_computation() const {
  return _impl_.is_fusion_computation_;
}
inline bool HloComputationProto::is_fusion_computation() const {
  // @@protoc_insertion_point(field_get:xla.HloComputationProto.is_fusion_computation)
  return _internal_is_fusion_computation();
}
inline void HloComputationProto::_internal_set_is_fusion_computation(bool value) {
  
  _impl_.is_fusion_computation_ = value;
}
inline void HloComputationProto::set_is_fusion_computation(bool value) {
  _internal_set_is_fusion_computation(value);
  // @@protoc_insertion_point(field_set:xla.HloComputationProto.is_fusion_computation)
}

// string execution_thread = 8;
inline void HloComputationProto::clear_execution_thread() {
  _impl_.execution_thread_.ClearToEmpty();
}
inline const std::string& HloComputationProto::execution_thread() const {
  // @@protoc_insertion_point(field_get:xla.HloComputationProto.execution_thread)
  return _internal_execution_thread();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloComputationProto::set_execution_thread(ArgT0&& arg0, ArgT... args) {
 
 _impl_.execution_thread_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloComputationProto.execution_thread)
}
inline std::string* HloComputationProto::mutable_execution_thread() {
  std::string* _s = _internal_mutable_execution_thread();
  // @@protoc_insertion_point(field_mutable:xla.HloComputationProto.execution_thread)
  return _s;
}
inline const std::string& HloComputationProto::_internal_execution_thread() const {
  return _impl_.execution_thread_.Get();
}
inline void HloComputationProto::_internal_set_execution_thread(const std::string& value) {
  
  _impl_.execution_thread_.Set(value, GetArenaForAllocation());
}
inline std::string* HloComputationProto::_internal_mutable_execution_thread() {
  
  return _impl_.execution_thread_.Mutable(GetArenaForAllocation());
}
inline std::string* HloComputationProto::release_execution_thread() {
  // @@protoc_insertion_point(field_release:xla.HloComputationProto.execution_thread)
  return _impl_.execution_thread_.Release();
}
inline void HloComputationProto::set_allocated_execution_thread(std::string* execution_thread) {
  if (execution_thread != nullptr) {
    
  } else {
    
  }
  _impl_.execution_thread_.SetAllocated(execution_thread, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.execution_thread_.IsDefault()) {
    _impl_.execution_thread_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloComputationProto.execution_thread)
}

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

// HloScheduleProto_InstructionSequence

// repeated int64 instruction_ids = 1;
inline int HloScheduleProto_InstructionSequence::_internal_instruction_ids_size() const {
  return _impl_.instruction_ids_.size();
}
inline int HloScheduleProto_InstructionSequence::instruction_ids_size() const {
  return _internal_instruction_ids_size();
}
inline void HloScheduleProto_InstructionSequence::clear_instruction_ids() {
  _impl_.instruction_ids_.Clear();
}
inline int64_t HloScheduleProto_InstructionSequence::_internal_instruction_ids(int index) const {
  return _impl_.instruction_ids_.Get(index);
}
inline int64_t HloScheduleProto_InstructionSequence::instruction_ids(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloScheduleProto.InstructionSequence.instruction_ids)
  return _internal_instruction_ids(index);
}
inline void HloScheduleProto_InstructionSequence::set_instruction_ids(int index, int64_t value) {
  _impl_.instruction_ids_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloScheduleProto.InstructionSequence.instruction_ids)
}
inline void HloScheduleProto_InstructionSequence::_internal_add_instruction_ids(int64_t value) {
  _impl_.instruction_ids_.Add(value);
}
inline void HloScheduleProto_InstructionSequence::add_instruction_ids(int64_t value) {
  _internal_add_instruction_ids(value);
  // @@protoc_insertion_point(field_add:xla.HloScheduleProto.InstructionSequence.instruction_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloScheduleProto_InstructionSequence::_internal_instruction_ids() const {
  return _impl_.instruction_ids_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloScheduleProto_InstructionSequence::instruction_ids() const {
  // @@protoc_insertion_point(field_list:xla.HloScheduleProto.InstructionSequence.instruction_ids)
  return _internal_instruction_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloScheduleProto_InstructionSequence::_internal_mutable_instruction_ids() {
  return &_impl_.instruction_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloScheduleProto_InstructionSequence::mutable_instruction_ids() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloScheduleProto.InstructionSequence.instruction_ids)
  return _internal_mutable_instruction_ids();
}

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

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

// HloScheduleProto

// map<int64, .xla.HloScheduleProto.InstructionSequence> sequences = 1;
inline int HloScheduleProto::_internal_sequences_size() const {
  return _impl_.sequences_.size();
}
inline int HloScheduleProto::sequences_size() const {
  return _internal_sequences_size();
}
inline void HloScheduleProto::clear_sequences() {
  _impl_.sequences_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::xla::HloScheduleProto_InstructionSequence >&
HloScheduleProto::_internal_sequences() const {
  return _impl_.sequences_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::xla::HloScheduleProto_InstructionSequence >&
HloScheduleProto::sequences() const {
  // @@protoc_insertion_point(field_map:xla.HloScheduleProto.sequences)
  return _internal_sequences();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::xla::HloScheduleProto_InstructionSequence >*
HloScheduleProto::_internal_mutable_sequences() {
  return _impl_.sequences_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::xla::HloScheduleProto_InstructionSequence >*
HloScheduleProto::mutable_sequences() {
  // @@protoc_insertion_point(field_mutable_map:xla.HloScheduleProto.sequences)
  return _internal_mutable_sequences();
}

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

// HloInputOutputAliasProto_AliasEntryProto

// repeated int64 output_shape_index = 1;
inline int HloInputOutputAliasProto_AliasEntryProto::_internal_output_shape_index_size() const {
  return _impl_.output_shape_index_.size();
}
inline int HloInputOutputAliasProto_AliasEntryProto::output_shape_index_size() const {
  return _internal_output_shape_index_size();
}
inline void HloInputOutputAliasProto_AliasEntryProto::clear_output_shape_index() {
  _impl_.output_shape_index_.Clear();
}
inline int64_t HloInputOutputAliasProto_AliasEntryProto::_internal_output_shape_index(int index) const {
  return _impl_.output_shape_index_.Get(index);
}
inline int64_t HloInputOutputAliasProto_AliasEntryProto::output_shape_index(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloInputOutputAliasProto.AliasEntryProto.output_shape_index)
  return _internal_output_shape_index(index);
}
inline void HloInputOutputAliasProto_AliasEntryProto::set_output_shape_index(int index, int64_t value) {
  _impl_.output_shape_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloInputOutputAliasProto.AliasEntryProto.output_shape_index)
}
inline void HloInputOutputAliasProto_AliasEntryProto::_internal_add_output_shape_index(int64_t value) {
  _impl_.output_shape_index_.Add(value);
}
inline void HloInputOutputAliasProto_AliasEntryProto::add_output_shape_index(int64_t value) {
  _internal_add_output_shape_index(value);
  // @@protoc_insertion_point(field_add:xla.HloInputOutputAliasProto.AliasEntryProto.output_shape_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInputOutputAliasProto_AliasEntryProto::_internal_output_shape_index() const {
  return _impl_.output_shape_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInputOutputAliasProto_AliasEntryProto::output_shape_index() const {
  // @@protoc_insertion_point(field_list:xla.HloInputOutputAliasProto.AliasEntryProto.output_shape_index)
  return _internal_output_shape_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInputOutputAliasProto_AliasEntryProto::_internal_mutable_output_shape_index() {
  return &_impl_.output_shape_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInputOutputAliasProto_AliasEntryProto::mutable_output_shape_index() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloInputOutputAliasProto.AliasEntryProto.output_shape_index)
  return _internal_mutable_output_shape_index();
}

// int64 parameter_number = 2;
inline void HloInputOutputAliasProto_AliasEntryProto::clear_parameter_number() {
  _impl_.parameter_number_ = int64_t{0};
}
inline int64_t HloInputOutputAliasProto_AliasEntryProto::_internal_parameter_number() const {
  return _impl_.parameter_number_;
}
inline int64_t HloInputOutputAliasProto_AliasEntryProto::parameter_number() const {
  // @@protoc_insertion_point(field_get:xla.HloInputOutputAliasProto.AliasEntryProto.parameter_number)
  return _internal_parameter_number();
}
inline void HloInputOutputAliasProto_AliasEntryProto::_internal_set_parameter_number(int64_t value) {
  
  _impl_.parameter_number_ = value;
}
inline void HloInputOutputAliasProto_AliasEntryProto::set_parameter_number(int64_t value) {
  _internal_set_parameter_number(value);
  // @@protoc_insertion_point(field_set:xla.HloInputOutputAliasProto.AliasEntryProto.parameter_number)
}

// repeated int64 parameter_shape_index = 3;
inline int HloInputOutputAliasProto_AliasEntryProto::_internal_parameter_shape_index_size() const {
  return _impl_.parameter_shape_index_.size();
}
inline int HloInputOutputAliasProto_AliasEntryProto::parameter_shape_index_size() const {
  return _internal_parameter_shape_index_size();
}
inline void HloInputOutputAliasProto_AliasEntryProto::clear_parameter_shape_index() {
  _impl_.parameter_shape_index_.Clear();
}
inline int64_t HloInputOutputAliasProto_AliasEntryProto::_internal_parameter_shape_index(int index) const {
  return _impl_.parameter_shape_index_.Get(index);
}
inline int64_t HloInputOutputAliasProto_AliasEntryProto::parameter_shape_index(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloInputOutputAliasProto.AliasEntryProto.parameter_shape_index)
  return _internal_parameter_shape_index(index);
}
inline void HloInputOutputAliasProto_AliasEntryProto::set_parameter_shape_index(int index, int64_t value) {
  _impl_.parameter_shape_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloInputOutputAliasProto.AliasEntryProto.parameter_shape_index)
}
inline void HloInputOutputAliasProto_AliasEntryProto::_internal_add_parameter_shape_index(int64_t value) {
  _impl_.parameter_shape_index_.Add(value);
}
inline void HloInputOutputAliasProto_AliasEntryProto::add_parameter_shape_index(int64_t value) {
  _internal_add_parameter_shape_index(value);
  // @@protoc_insertion_point(field_add:xla.HloInputOutputAliasProto.AliasEntryProto.parameter_shape_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInputOutputAliasProto_AliasEntryProto::_internal_parameter_shape_index() const {
  return _impl_.parameter_shape_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloInputOutputAliasProto_AliasEntryProto::parameter_shape_index() const {
  // @@protoc_insertion_point(field_list:xla.HloInputOutputAliasProto.AliasEntryProto.parameter_shape_index)
  return _internal_parameter_shape_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInputOutputAliasProto_AliasEntryProto::_internal_mutable_parameter_shape_index() {
  return &_impl_.parameter_shape_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloInputOutputAliasProto_AliasEntryProto::mutable_parameter_shape_index() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloInputOutputAliasProto.AliasEntryProto.parameter_shape_index)
  return _internal_mutable_parameter_shape_index();
}

// .xla.Kind kind = 4;
inline void HloInputOutputAliasProto_AliasEntryProto::clear_kind() {
  _impl_.kind_ = 0;
}
inline ::xla::Kind HloInputOutputAliasProto_AliasEntryProto::_internal_kind() const {
  return static_cast< ::xla::Kind >(_impl_.kind_);
}
inline ::xla::Kind HloInputOutputAliasProto_AliasEntryProto::kind() const {
  // @@protoc_insertion_point(field_get:xla.HloInputOutputAliasProto.AliasEntryProto.kind)
  return _internal_kind();
}
inline void HloInputOutputAliasProto_AliasEntryProto::_internal_set_kind(::xla::Kind value) {
  
  _impl_.kind_ = value;
}
inline void HloInputOutputAliasProto_AliasEntryProto::set_kind(::xla::Kind value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:xla.HloInputOutputAliasProto.AliasEntryProto.kind)
}

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

// HloInputOutputAliasProto

// repeated .xla.HloInputOutputAliasProto.AliasEntryProto entries = 1;
inline int HloInputOutputAliasProto::_internal_entries_size() const {
  return _impl_.entries_.size();
}
inline int HloInputOutputAliasProto::entries_size() const {
  return _internal_entries_size();
}
inline void HloInputOutputAliasProto::clear_entries() {
  _impl_.entries_.Clear();
}
inline ::xla::HloInputOutputAliasProto_AliasEntryProto* HloInputOutputAliasProto::mutable_entries(int index) {
  // @@protoc_insertion_point(field_mutable:xla.HloInputOutputAliasProto.entries)
  return _impl_.entries_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloInputOutputAliasProto_AliasEntryProto >*
HloInputOutputAliasProto::mutable_entries() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloInputOutputAliasProto.entries)
  return &_impl_.entries_;
}
inline const ::xla::HloInputOutputAliasProto_AliasEntryProto& HloInputOutputAliasProto::_internal_entries(int index) const {
  return _impl_.entries_.Get(index);
}
inline const ::xla::HloInputOutputAliasProto_AliasEntryProto& HloInputOutputAliasProto::entries(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloInputOutputAliasProto.entries)
  return _internal_entries(index);
}
inline ::xla::HloInputOutputAliasProto_AliasEntryProto* HloInputOutputAliasProto::_internal_add_entries() {
  return _impl_.entries_.Add();
}
inline ::xla::HloInputOutputAliasProto_AliasEntryProto* HloInputOutputAliasProto::add_entries() {
  ::xla::HloInputOutputAliasProto_AliasEntryProto* _add = _internal_add_entries();
  // @@protoc_insertion_point(field_add:xla.HloInputOutputAliasProto.entries)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloInputOutputAliasProto_AliasEntryProto >&
HloInputOutputAliasProto::entries() const {
  // @@protoc_insertion_point(field_list:xla.HloInputOutputAliasProto.entries)
  return _impl_.entries_;
}

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

// DynamicParameterBindingProto_Binding

// int64 dynamic_param_num = 1;
inline void DynamicParameterBindingProto_Binding::clear_dynamic_param_num() {
  _impl_.dynamic_param_num_ = int64_t{0};
}
inline int64_t DynamicParameterBindingProto_Binding::_internal_dynamic_param_num() const {
  return _impl_.dynamic_param_num_;
}
inline int64_t DynamicParameterBindingProto_Binding::dynamic_param_num() const {
  // @@protoc_insertion_point(field_get:xla.DynamicParameterBindingProto.Binding.dynamic_param_num)
  return _internal_dynamic_param_num();
}
inline void DynamicParameterBindingProto_Binding::_internal_set_dynamic_param_num(int64_t value) {
  
  _impl_.dynamic_param_num_ = value;
}
inline void DynamicParameterBindingProto_Binding::set_dynamic_param_num(int64_t value) {
  _internal_set_dynamic_param_num(value);
  // @@protoc_insertion_point(field_set:xla.DynamicParameterBindingProto.Binding.dynamic_param_num)
}

// repeated int64 dynamic_param_index = 2;
inline int DynamicParameterBindingProto_Binding::_internal_dynamic_param_index_size() const {
  return _impl_.dynamic_param_index_.size();
}
inline int DynamicParameterBindingProto_Binding::dynamic_param_index_size() const {
  return _internal_dynamic_param_index_size();
}
inline void DynamicParameterBindingProto_Binding::clear_dynamic_param_index() {
  _impl_.dynamic_param_index_.Clear();
}
inline int64_t DynamicParameterBindingProto_Binding::_internal_dynamic_param_index(int index) const {
  return _impl_.dynamic_param_index_.Get(index);
}
inline int64_t DynamicParameterBindingProto_Binding::dynamic_param_index(int index) const {
  // @@protoc_insertion_point(field_get:xla.DynamicParameterBindingProto.Binding.dynamic_param_index)
  return _internal_dynamic_param_index(index);
}
inline void DynamicParameterBindingProto_Binding::set_dynamic_param_index(int index, int64_t value) {
  _impl_.dynamic_param_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.DynamicParameterBindingProto.Binding.dynamic_param_index)
}
inline void DynamicParameterBindingProto_Binding::_internal_add_dynamic_param_index(int64_t value) {
  _impl_.dynamic_param_index_.Add(value);
}
inline void DynamicParameterBindingProto_Binding::add_dynamic_param_index(int64_t value) {
  _internal_add_dynamic_param_index(value);
  // @@protoc_insertion_point(field_add:xla.DynamicParameterBindingProto.Binding.dynamic_param_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
DynamicParameterBindingProto_Binding::_internal_dynamic_param_index() const {
  return _impl_.dynamic_param_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
DynamicParameterBindingProto_Binding::dynamic_param_index() const {
  // @@protoc_insertion_point(field_list:xla.DynamicParameterBindingProto.Binding.dynamic_param_index)
  return _internal_dynamic_param_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
DynamicParameterBindingProto_Binding::_internal_mutable_dynamic_param_index() {
  return &_impl_.dynamic_param_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
DynamicParameterBindingProto_Binding::mutable_dynamic_param_index() {
  // @@protoc_insertion_point(field_mutable_list:xla.DynamicParameterBindingProto.Binding.dynamic_param_index)
  return _internal_mutable_dynamic_param_index();
}

// int64 target_param_num = 3;
inline void DynamicParameterBindingProto_Binding::clear_target_param_num() {
  _impl_.target_param_num_ = int64_t{0};
}
inline int64_t DynamicParameterBindingProto_Binding::_internal_target_param_num() const {
  return _impl_.target_param_num_;
}
inline int64_t DynamicParameterBindingProto_Binding::target_param_num() const {
  // @@protoc_insertion_point(field_get:xla.DynamicParameterBindingProto.Binding.target_param_num)
  return _internal_target_param_num();
}
inline void DynamicParameterBindingProto_Binding::_internal_set_target_param_num(int64_t value) {
  
  _impl_.target_param_num_ = value;
}
inline void DynamicParameterBindingProto_Binding::set_target_param_num(int64_t value) {
  _internal_set_target_param_num(value);
  // @@protoc_insertion_point(field_set:xla.DynamicParameterBindingProto.Binding.target_param_num)
}

// repeated int64 target_param_index = 4;
inline int DynamicParameterBindingProto_Binding::_internal_target_param_index_size() const {
  return _impl_.target_param_index_.size();
}
inline int DynamicParameterBindingProto_Binding::target_param_index_size() const {
  return _internal_target_param_index_size();
}
inline void DynamicParameterBindingProto_Binding::clear_target_param_index() {
  _impl_.target_param_index_.Clear();
}
inline int64_t DynamicParameterBindingProto_Binding::_internal_target_param_index(int index) const {
  return _impl_.target_param_index_.Get(index);
}
inline int64_t DynamicParameterBindingProto_Binding::target_param_index(int index) const {
  // @@protoc_insertion_point(field_get:xla.DynamicParameterBindingProto.Binding.target_param_index)
  return _internal_target_param_index(index);
}
inline void DynamicParameterBindingProto_Binding::set_target_param_index(int index, int64_t value) {
  _impl_.target_param_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.DynamicParameterBindingProto.Binding.target_param_index)
}
inline void DynamicParameterBindingProto_Binding::_internal_add_target_param_index(int64_t value) {
  _impl_.target_param_index_.Add(value);
}
inline void DynamicParameterBindingProto_Binding::add_target_param_index(int64_t value) {
  _internal_add_target_param_index(value);
  // @@protoc_insertion_point(field_add:xla.DynamicParameterBindingProto.Binding.target_param_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
DynamicParameterBindingProto_Binding::_internal_target_param_index() const {
  return _impl_.target_param_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
DynamicParameterBindingProto_Binding::target_param_index() const {
  // @@protoc_insertion_point(field_list:xla.DynamicParameterBindingProto.Binding.target_param_index)
  return _internal_target_param_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
DynamicParameterBindingProto_Binding::_internal_mutable_target_param_index() {
  return &_impl_.target_param_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
DynamicParameterBindingProto_Binding::mutable_target_param_index() {
  // @@protoc_insertion_point(field_mutable_list:xla.DynamicParameterBindingProto.Binding.target_param_index)
  return _internal_mutable_target_param_index();
}

// int64 target_param_dim_num = 5;
inline void DynamicParameterBindingProto_Binding::clear_target_param_dim_num() {
  _impl_.target_param_dim_num_ = int64_t{0};
}
inline int64_t DynamicParameterBindingProto_Binding::_internal_target_param_dim_num() const {
  return _impl_.target_param_dim_num_;
}
inline int64_t DynamicParameterBindingProto_Binding::target_param_dim_num() const {
  // @@protoc_insertion_point(field_get:xla.DynamicParameterBindingProto.Binding.target_param_dim_num)
  return _internal_target_param_dim_num();
}
inline void DynamicParameterBindingProto_Binding::_internal_set_target_param_dim_num(int64_t value) {
  
  _impl_.target_param_dim_num_ = value;
}
inline void DynamicParameterBindingProto_Binding::set_target_param_dim_num(int64_t value) {
  _internal_set_target_param_dim_num(value);
  // @@protoc_insertion_point(field_set:xla.DynamicParameterBindingProto.Binding.target_param_dim_num)
}

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

// DynamicParameterBindingProto

// repeated .xla.DynamicParameterBindingProto.Binding entries = 1;
inline int DynamicParameterBindingProto::_internal_entries_size() const {
  return _impl_.entries_.size();
}
inline int DynamicParameterBindingProto::entries_size() const {
  return _internal_entries_size();
}
inline void DynamicParameterBindingProto::clear_entries() {
  _impl_.entries_.Clear();
}
inline ::xla::DynamicParameterBindingProto_Binding* DynamicParameterBindingProto::mutable_entries(int index) {
  // @@protoc_insertion_point(field_mutable:xla.DynamicParameterBindingProto.entries)
  return _impl_.entries_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DynamicParameterBindingProto_Binding >*
DynamicParameterBindingProto::mutable_entries() {
  // @@protoc_insertion_point(field_mutable_list:xla.DynamicParameterBindingProto.entries)
  return &_impl_.entries_;
}
inline const ::xla::DynamicParameterBindingProto_Binding& DynamicParameterBindingProto::_internal_entries(int index) const {
  return _impl_.entries_.Get(index);
}
inline const ::xla::DynamicParameterBindingProto_Binding& DynamicParameterBindingProto::entries(int index) const {
  // @@protoc_insertion_point(field_get:xla.DynamicParameterBindingProto.entries)
  return _internal_entries(index);
}
inline ::xla::DynamicParameterBindingProto_Binding* DynamicParameterBindingProto::_internal_add_entries() {
  return _impl_.entries_.Add();
}
inline ::xla::DynamicParameterBindingProto_Binding* DynamicParameterBindingProto::add_entries() {
  ::xla::DynamicParameterBindingProto_Binding* _add = _internal_add_entries();
  // @@protoc_insertion_point(field_add:xla.DynamicParameterBindingProto.entries)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DynamicParameterBindingProto_Binding >&
DynamicParameterBindingProto::entries() const {
  // @@protoc_insertion_point(field_list:xla.DynamicParameterBindingProto.entries)
  return _impl_.entries_;
}

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

// CrossProgramPrefetch

// int64 parameter = 1;
inline void CrossProgramPrefetch::clear_parameter() {
  _impl_.parameter_ = int64_t{0};
}
inline int64_t CrossProgramPrefetch::_internal_parameter() const {
  return _impl_.parameter_;
}
inline int64_t CrossProgramPrefetch::parameter() const {
  // @@protoc_insertion_point(field_get:xla.CrossProgramPrefetch.parameter)
  return _internal_parameter();
}
inline void CrossProgramPrefetch::_internal_set_parameter(int64_t value) {
  
  _impl_.parameter_ = value;
}
inline void CrossProgramPrefetch::set_parameter(int64_t value) {
  _internal_set_parameter(value);
  // @@protoc_insertion_point(field_set:xla.CrossProgramPrefetch.parameter)
}

// repeated int64 index = 2;
inline int CrossProgramPrefetch::_internal_index_size() const {
  return _impl_.index_.size();
}
inline int CrossProgramPrefetch::index_size() const {
  return _internal_index_size();
}
inline void CrossProgramPrefetch::clear_index() {
  _impl_.index_.Clear();
}
inline int64_t CrossProgramPrefetch::_internal_index(int index) const {
  return _impl_.index_.Get(index);
}
inline int64_t CrossProgramPrefetch::index(int index) const {
  // @@protoc_insertion_point(field_get:xla.CrossProgramPrefetch.index)
  return _internal_index(index);
}
inline void CrossProgramPrefetch::set_index(int index, int64_t value) {
  _impl_.index_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.CrossProgramPrefetch.index)
}
inline void CrossProgramPrefetch::_internal_add_index(int64_t value) {
  _impl_.index_.Add(value);
}
inline void CrossProgramPrefetch::add_index(int64_t value) {
  _internal_add_index(value);
  // @@protoc_insertion_point(field_add:xla.CrossProgramPrefetch.index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
CrossProgramPrefetch::_internal_index() const {
  return _impl_.index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
CrossProgramPrefetch::index() const {
  // @@protoc_insertion_point(field_list:xla.CrossProgramPrefetch.index)
  return _internal_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
CrossProgramPrefetch::_internal_mutable_index() {
  return &_impl_.index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
CrossProgramPrefetch::mutable_index() {
  // @@protoc_insertion_point(field_mutable_list:xla.CrossProgramPrefetch.index)
  return _internal_mutable_index();
}

// int64 offset = 3;
inline void CrossProgramPrefetch::clear_offset() {
  _impl_.offset_ = int64_t{0};
}
inline int64_t CrossProgramPrefetch::_internal_offset() const {
  return _impl_.offset_;
}
inline int64_t CrossProgramPrefetch::offset() const {
  // @@protoc_insertion_point(field_get:xla.CrossProgramPrefetch.offset)
  return _internal_offset();
}
inline void CrossProgramPrefetch::_internal_set_offset(int64_t value) {
  
  _impl_.offset_ = value;
}
inline void CrossProgramPrefetch::set_offset(int64_t value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:xla.CrossProgramPrefetch.offset)
}

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

// HloModuleProto_ProfileInfo

// .xla.HloModuleProto.ProfileType profile_type = 1;
inline void HloModuleProto_ProfileInfo::clear_profile_type() {
  _impl_.profile_type_ = 0;
}
inline ::xla::HloModuleProto_ProfileType HloModuleProto_ProfileInfo::_internal_profile_type() const {
  return static_cast< ::xla::HloModuleProto_ProfileType >(_impl_.profile_type_);
}
inline ::xla::HloModuleProto_ProfileType HloModuleProto_ProfileInfo::profile_type() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.ProfileInfo.profile_type)
  return _internal_profile_type();
}
inline void HloModuleProto_ProfileInfo::_internal_set_profile_type(::xla::HloModuleProto_ProfileType value) {
  
  _impl_.profile_type_ = value;
}
inline void HloModuleProto_ProfileInfo::set_profile_type(::xla::HloModuleProto_ProfileType value) {
  _internal_set_profile_type(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleProto.ProfileInfo.profile_type)
}

// double relative_speedup = 2;
inline void HloModuleProto_ProfileInfo::clear_relative_speedup() {
  _impl_.relative_speedup_ = 0;
}
inline double HloModuleProto_ProfileInfo::_internal_relative_speedup() const {
  return _impl_.relative_speedup_;
}
inline double HloModuleProto_ProfileInfo::relative_speedup() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.ProfileInfo.relative_speedup)
  return _internal_relative_speedup();
}
inline void HloModuleProto_ProfileInfo::_internal_set_relative_speedup(double value) {
  
  _impl_.relative_speedup_ = value;
}
inline void HloModuleProto_ProfileInfo::set_relative_speedup(double value) {
  _internal_set_relative_speedup(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleProto.ProfileInfo.relative_speedup)
}

// .xla.ProfileSource profile_source = 3;
inline void HloModuleProto_ProfileInfo::clear_profile_source() {
  _impl_.profile_source_ = 0;
}
inline ::xla::ProfileSource HloModuleProto_ProfileInfo::_internal_profile_source() const {
  return static_cast< ::xla::ProfileSource >(_impl_.profile_source_);
}
inline ::xla::ProfileSource HloModuleProto_ProfileInfo::profile_source() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.ProfileInfo.profile_source)
  return _internal_profile_source();
}
inline void HloModuleProto_ProfileInfo::_internal_set_profile_source(::xla::ProfileSource value) {
  
  _impl_.profile_source_ = value;
}
inline void HloModuleProto_ProfileInfo::set_profile_source(::xla::ProfileSource value) {
  _internal_set_profile_source(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleProto.ProfileInfo.profile_source)
}

// .xla.CompilationEvent compilation_event = 4;
inline void HloModuleProto_ProfileInfo::clear_compilation_event() {
  _impl_.compilation_event_ = 0;
}
inline ::xla::CompilationEvent HloModuleProto_ProfileInfo::_internal_compilation_event() const {
  return static_cast< ::xla::CompilationEvent >(_impl_.compilation_event_);
}
inline ::xla::CompilationEvent HloModuleProto_ProfileInfo::compilation_event() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.ProfileInfo.compilation_event)
  return _internal_compilation_event();
}
inline void HloModuleProto_ProfileInfo::_internal_set_compilation_event(::xla::CompilationEvent value) {
  
  _impl_.compilation_event_ = value;
}
inline void HloModuleProto_ProfileInfo::set_compilation_event(::xla::CompilationEvent value) {
  _internal_set_compilation_event(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleProto.ProfileInfo.compilation_event)
}

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

// HloModuleProto

// string name = 1;
inline void HloModuleProto::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& HloModuleProto::name() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloModuleProto::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloModuleProto.name)
}
inline std::string* HloModuleProto::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleProto.name)
  return _s;
}
inline const std::string& HloModuleProto::_internal_name() const {
  return _impl_.name_.Get();
}
inline void HloModuleProto::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* HloModuleProto::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* HloModuleProto::release_name() {
  // @@protoc_insertion_point(field_release:xla.HloModuleProto.name)
  return _impl_.name_.Release();
}
inline void HloModuleProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _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:xla.HloModuleProto.name)
}

// string entry_computation_name = 2;
inline void HloModuleProto::clear_entry_computation_name() {
  _impl_.entry_computation_name_.ClearToEmpty();
}
inline const std::string& HloModuleProto::entry_computation_name() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.entry_computation_name)
  return _internal_entry_computation_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloModuleProto::set_entry_computation_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.entry_computation_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloModuleProto.entry_computation_name)
}
inline std::string* HloModuleProto::mutable_entry_computation_name() {
  std::string* _s = _internal_mutable_entry_computation_name();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleProto.entry_computation_name)
  return _s;
}
inline const std::string& HloModuleProto::_internal_entry_computation_name() const {
  return _impl_.entry_computation_name_.Get();
}
inline void HloModuleProto::_internal_set_entry_computation_name(const std::string& value) {
  
  _impl_.entry_computation_name_.Set(value, GetArenaForAllocation());
}
inline std::string* HloModuleProto::_internal_mutable_entry_computation_name() {
  
  return _impl_.entry_computation_name_.Mutable(GetArenaForAllocation());
}
inline std::string* HloModuleProto::release_entry_computation_name() {
  // @@protoc_insertion_point(field_release:xla.HloModuleProto.entry_computation_name)
  return _impl_.entry_computation_name_.Release();
}
inline void HloModuleProto::set_allocated_entry_computation_name(std::string* entry_computation_name) {
  if (entry_computation_name != nullptr) {
    
  } else {
    
  }
  _impl_.entry_computation_name_.SetAllocated(entry_computation_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.entry_computation_name_.IsDefault()) {
    _impl_.entry_computation_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleProto.entry_computation_name)
}

// int64 entry_computation_id = 6;
inline void HloModuleProto::clear_entry_computation_id() {
  _impl_.entry_computation_id_ = int64_t{0};
}
inline int64_t HloModuleProto::_internal_entry_computation_id() const {
  return _impl_.entry_computation_id_;
}
inline int64_t HloModuleProto::entry_computation_id() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.entry_computation_id)
  return _internal_entry_computation_id();
}
inline void HloModuleProto::_internal_set_entry_computation_id(int64_t value) {
  
  _impl_.entry_computation_id_ = value;
}
inline void HloModuleProto::set_entry_computation_id(int64_t value) {
  _internal_set_entry_computation_id(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleProto.entry_computation_id)
}

// repeated .xla.HloComputationProto computations = 3;
inline int HloModuleProto::_internal_computations_size() const {
  return _impl_.computations_.size();
}
inline int HloModuleProto::computations_size() const {
  return _internal_computations_size();
}
inline void HloModuleProto::clear_computations() {
  _impl_.computations_.Clear();
}
inline ::xla::HloComputationProto* HloModuleProto::mutable_computations(int index) {
  // @@protoc_insertion_point(field_mutable:xla.HloModuleProto.computations)
  return _impl_.computations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloComputationProto >*
HloModuleProto::mutable_computations() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleProto.computations)
  return &_impl_.computations_;
}
inline const ::xla::HloComputationProto& HloModuleProto::_internal_computations(int index) const {
  return _impl_.computations_.Get(index);
}
inline const ::xla::HloComputationProto& HloModuleProto::computations(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.computations)
  return _internal_computations(index);
}
inline ::xla::HloComputationProto* HloModuleProto::_internal_add_computations() {
  return _impl_.computations_.Add();
}
inline ::xla::HloComputationProto* HloModuleProto::add_computations() {
  ::xla::HloComputationProto* _add = _internal_add_computations();
  // @@protoc_insertion_point(field_add:xla.HloModuleProto.computations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloComputationProto >&
HloModuleProto::computations() const {
  // @@protoc_insertion_point(field_list:xla.HloModuleProto.computations)
  return _impl_.computations_;
}

// .xla.ProgramShapeProto host_program_shape = 4;
inline bool HloModuleProto::_internal_has_host_program_shape() const {
  return this != internal_default_instance() && _impl_.host_program_shape_ != nullptr;
}
inline bool HloModuleProto::has_host_program_shape() const {
  return _internal_has_host_program_shape();
}
inline const ::xla::ProgramShapeProto& HloModuleProto::_internal_host_program_shape() const {
  const ::xla::ProgramShapeProto* p = _impl_.host_program_shape_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::ProgramShapeProto&>(
      ::xla::_ProgramShapeProto_default_instance_);
}
inline const ::xla::ProgramShapeProto& HloModuleProto::host_program_shape() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.host_program_shape)
  return _internal_host_program_shape();
}
inline void HloModuleProto::unsafe_arena_set_allocated_host_program_shape(
    ::xla::ProgramShapeProto* host_program_shape) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.host_program_shape_);
  }
  _impl_.host_program_shape_ = host_program_shape;
  if (host_program_shape) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleProto.host_program_shape)
}
inline ::xla::ProgramShapeProto* HloModuleProto::release_host_program_shape() {
  
  ::xla::ProgramShapeProto* temp = _impl_.host_program_shape_;
  _impl_.host_program_shape_ = 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 ::xla::ProgramShapeProto* HloModuleProto::unsafe_arena_release_host_program_shape() {
  // @@protoc_insertion_point(field_release:xla.HloModuleProto.host_program_shape)
  
  ::xla::ProgramShapeProto* temp = _impl_.host_program_shape_;
  _impl_.host_program_shape_ = nullptr;
  return temp;
}
inline ::xla::ProgramShapeProto* HloModuleProto::_internal_mutable_host_program_shape() {
  
  if (_impl_.host_program_shape_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::ProgramShapeProto>(GetArenaForAllocation());
    _impl_.host_program_shape_ = p;
  }
  return _impl_.host_program_shape_;
}
inline ::xla::ProgramShapeProto* HloModuleProto::mutable_host_program_shape() {
  ::xla::ProgramShapeProto* _msg = _internal_mutable_host_program_shape();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleProto.host_program_shape)
  return _msg;
}
inline void HloModuleProto::set_allocated_host_program_shape(::xla::ProgramShapeProto* host_program_shape) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.host_program_shape_);
  }
  if (host_program_shape) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(host_program_shape));
    if (message_arena != submessage_arena) {
      host_program_shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, host_program_shape, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.host_program_shape_ = host_program_shape;
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleProto.host_program_shape)
}

// int64 id = 5;
inline void HloModuleProto::clear_id() {
  _impl_.id_ = int64_t{0};
}
inline int64_t HloModuleProto::_internal_id() const {
  return _impl_.id_;
}
inline int64_t HloModuleProto::id() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.id)
  return _internal_id();
}
inline void HloModuleProto::_internal_set_id(int64_t value) {
  
  _impl_.id_ = value;
}
inline void HloModuleProto::set_id(int64_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleProto.id)
}

// .xla.HloScheduleProto schedule = 7;
inline bool HloModuleProto::_internal_has_schedule() const {
  return this != internal_default_instance() && _impl_.schedule_ != nullptr;
}
inline bool HloModuleProto::has_schedule() const {
  return _internal_has_schedule();
}
inline void HloModuleProto::clear_schedule() {
  if (GetArenaForAllocation() == nullptr && _impl_.schedule_ != nullptr) {
    delete _impl_.schedule_;
  }
  _impl_.schedule_ = nullptr;
}
inline const ::xla::HloScheduleProto& HloModuleProto::_internal_schedule() const {
  const ::xla::HloScheduleProto* p = _impl_.schedule_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::HloScheduleProto&>(
      ::xla::_HloScheduleProto_default_instance_);
}
inline const ::xla::HloScheduleProto& HloModuleProto::schedule() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.schedule)
  return _internal_schedule();
}
inline void HloModuleProto::unsafe_arena_set_allocated_schedule(
    ::xla::HloScheduleProto* schedule) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.schedule_);
  }
  _impl_.schedule_ = schedule;
  if (schedule) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleProto.schedule)
}
inline ::xla::HloScheduleProto* HloModuleProto::release_schedule() {
  
  ::xla::HloScheduleProto* temp = _impl_.schedule_;
  _impl_.schedule_ = 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 ::xla::HloScheduleProto* HloModuleProto::unsafe_arena_release_schedule() {
  // @@protoc_insertion_point(field_release:xla.HloModuleProto.schedule)
  
  ::xla::HloScheduleProto* temp = _impl_.schedule_;
  _impl_.schedule_ = nullptr;
  return temp;
}
inline ::xla::HloScheduleProto* HloModuleProto::_internal_mutable_schedule() {
  
  if (_impl_.schedule_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::HloScheduleProto>(GetArenaForAllocation());
    _impl_.schedule_ = p;
  }
  return _impl_.schedule_;
}
inline ::xla::HloScheduleProto* HloModuleProto::mutable_schedule() {
  ::xla::HloScheduleProto* _msg = _internal_mutable_schedule();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleProto.schedule)
  return _msg;
}
inline void HloModuleProto::set_allocated_schedule(::xla::HloScheduleProto* schedule) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.schedule_;
  }
  if (schedule) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(schedule);
    if (message_arena != submessage_arena) {
      schedule = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, schedule, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.schedule_ = schedule;
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleProto.schedule)
}

// .xla.HloInputOutputAliasProto input_output_alias = 8;
inline bool HloModuleProto::_internal_has_input_output_alias() const {
  return this != internal_default_instance() && _impl_.input_output_alias_ != nullptr;
}
inline bool HloModuleProto::has_input_output_alias() const {
  return _internal_has_input_output_alias();
}
inline void HloModuleProto::clear_input_output_alias() {
  if (GetArenaForAllocation() == nullptr && _impl_.input_output_alias_ != nullptr) {
    delete _impl_.input_output_alias_;
  }
  _impl_.input_output_alias_ = nullptr;
}
inline const ::xla::HloInputOutputAliasProto& HloModuleProto::_internal_input_output_alias() const {
  const ::xla::HloInputOutputAliasProto* p = _impl_.input_output_alias_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::HloInputOutputAliasProto&>(
      ::xla::_HloInputOutputAliasProto_default_instance_);
}
inline const ::xla::HloInputOutputAliasProto& HloModuleProto::input_output_alias() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.input_output_alias)
  return _internal_input_output_alias();
}
inline void HloModuleProto::unsafe_arena_set_allocated_input_output_alias(
    ::xla::HloInputOutputAliasProto* input_output_alias) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.input_output_alias_);
  }
  _impl_.input_output_alias_ = input_output_alias;
  if (input_output_alias) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleProto.input_output_alias)
}
inline ::xla::HloInputOutputAliasProto* HloModuleProto::release_input_output_alias() {
  
  ::xla::HloInputOutputAliasProto* temp = _impl_.input_output_alias_;
  _impl_.input_output_alias_ = 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 ::xla::HloInputOutputAliasProto* HloModuleProto::unsafe_arena_release_input_output_alias() {
  // @@protoc_insertion_point(field_release:xla.HloModuleProto.input_output_alias)
  
  ::xla::HloInputOutputAliasProto* temp = _impl_.input_output_alias_;
  _impl_.input_output_alias_ = nullptr;
  return temp;
}
inline ::xla::HloInputOutputAliasProto* HloModuleProto::_internal_mutable_input_output_alias() {
  
  if (_impl_.input_output_alias_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::HloInputOutputAliasProto>(GetArenaForAllocation());
    _impl_.input_output_alias_ = p;
  }
  return _impl_.input_output_alias_;
}
inline ::xla::HloInputOutputAliasProto* HloModuleProto::mutable_input_output_alias() {
  ::xla::HloInputOutputAliasProto* _msg = _internal_mutable_input_output_alias();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleProto.input_output_alias)
  return _msg;
}
inline void HloModuleProto::set_allocated_input_output_alias(::xla::HloInputOutputAliasProto* input_output_alias) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.input_output_alias_;
  }
  if (input_output_alias) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(input_output_alias);
    if (message_arena != submessage_arena) {
      input_output_alias = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, input_output_alias, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.input_output_alias_ = input_output_alias;
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleProto.input_output_alias)
}

// .xla.DynamicParameterBindingProto dynamic_parameter_binding = 9;
inline bool HloModuleProto::_internal_has_dynamic_parameter_binding() const {
  return this != internal_default_instance() && _impl_.dynamic_parameter_binding_ != nullptr;
}
inline bool HloModuleProto::has_dynamic_parameter_binding() const {
  return _internal_has_dynamic_parameter_binding();
}
inline void HloModuleProto::clear_dynamic_parameter_binding() {
  if (GetArenaForAllocation() == nullptr && _impl_.dynamic_parameter_binding_ != nullptr) {
    delete _impl_.dynamic_parameter_binding_;
  }
  _impl_.dynamic_parameter_binding_ = nullptr;
}
inline const ::xla::DynamicParameterBindingProto& HloModuleProto::_internal_dynamic_parameter_binding() const {
  const ::xla::DynamicParameterBindingProto* p = _impl_.dynamic_parameter_binding_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::DynamicParameterBindingProto&>(
      ::xla::_DynamicParameterBindingProto_default_instance_);
}
inline const ::xla::DynamicParameterBindingProto& HloModuleProto::dynamic_parameter_binding() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.dynamic_parameter_binding)
  return _internal_dynamic_parameter_binding();
}
inline void HloModuleProto::unsafe_arena_set_allocated_dynamic_parameter_binding(
    ::xla::DynamicParameterBindingProto* dynamic_parameter_binding) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dynamic_parameter_binding_);
  }
  _impl_.dynamic_parameter_binding_ = dynamic_parameter_binding;
  if (dynamic_parameter_binding) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleProto.dynamic_parameter_binding)
}
inline ::xla::DynamicParameterBindingProto* HloModuleProto::release_dynamic_parameter_binding() {
  
  ::xla::DynamicParameterBindingProto* temp = _impl_.dynamic_parameter_binding_;
  _impl_.dynamic_parameter_binding_ = 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 ::xla::DynamicParameterBindingProto* HloModuleProto::unsafe_arena_release_dynamic_parameter_binding() {
  // @@protoc_insertion_point(field_release:xla.HloModuleProto.dynamic_parameter_binding)
  
  ::xla::DynamicParameterBindingProto* temp = _impl_.dynamic_parameter_binding_;
  _impl_.dynamic_parameter_binding_ = nullptr;
  return temp;
}
inline ::xla::DynamicParameterBindingProto* HloModuleProto::_internal_mutable_dynamic_parameter_binding() {
  
  if (_impl_.dynamic_parameter_binding_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::DynamicParameterBindingProto>(GetArenaForAllocation());
    _impl_.dynamic_parameter_binding_ = p;
  }
  return _impl_.dynamic_parameter_binding_;
}
inline ::xla::DynamicParameterBindingProto* HloModuleProto::mutable_dynamic_parameter_binding() {
  ::xla::DynamicParameterBindingProto* _msg = _internal_mutable_dynamic_parameter_binding();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleProto.dynamic_parameter_binding)
  return _msg;
}
inline void HloModuleProto::set_allocated_dynamic_parameter_binding(::xla::DynamicParameterBindingProto* dynamic_parameter_binding) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.dynamic_parameter_binding_;
  }
  if (dynamic_parameter_binding) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(dynamic_parameter_binding);
    if (message_arena != submessage_arena) {
      dynamic_parameter_binding = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dynamic_parameter_binding, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.dynamic_parameter_binding_ = dynamic_parameter_binding;
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleProto.dynamic_parameter_binding)
}

// repeated .xla.CrossProgramPrefetch cross_program_prefetches = 10;
inline int HloModuleProto::_internal_cross_program_prefetches_size() const {
  return _impl_.cross_program_prefetches_.size();
}
inline int HloModuleProto::cross_program_prefetches_size() const {
  return _internal_cross_program_prefetches_size();
}
inline void HloModuleProto::clear_cross_program_prefetches() {
  _impl_.cross_program_prefetches_.Clear();
}
inline ::xla::CrossProgramPrefetch* HloModuleProto::mutable_cross_program_prefetches(int index) {
  // @@protoc_insertion_point(field_mutable:xla.HloModuleProto.cross_program_prefetches)
  return _impl_.cross_program_prefetches_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::CrossProgramPrefetch >*
HloModuleProto::mutable_cross_program_prefetches() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleProto.cross_program_prefetches)
  return &_impl_.cross_program_prefetches_;
}
inline const ::xla::CrossProgramPrefetch& HloModuleProto::_internal_cross_program_prefetches(int index) const {
  return _impl_.cross_program_prefetches_.Get(index);
}
inline const ::xla::CrossProgramPrefetch& HloModuleProto::cross_program_prefetches(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.cross_program_prefetches)
  return _internal_cross_program_prefetches(index);
}
inline ::xla::CrossProgramPrefetch* HloModuleProto::_internal_add_cross_program_prefetches() {
  return _impl_.cross_program_prefetches_.Add();
}
inline ::xla::CrossProgramPrefetch* HloModuleProto::add_cross_program_prefetches() {
  ::xla::CrossProgramPrefetch* _add = _internal_add_cross_program_prefetches();
  // @@protoc_insertion_point(field_add:xla.HloModuleProto.cross_program_prefetches)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::CrossProgramPrefetch >&
HloModuleProto::cross_program_prefetches() const {
  // @@protoc_insertion_point(field_list:xla.HloModuleProto.cross_program_prefetches)
  return _impl_.cross_program_prefetches_;
}

// bool is_dynamic = 11;
inline void HloModuleProto::clear_is_dynamic() {
  _impl_.is_dynamic_ = false;
}
inline bool HloModuleProto::_internal_is_dynamic() const {
  return _impl_.is_dynamic_;
}
inline bool HloModuleProto::is_dynamic() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.is_dynamic)
  return _internal_is_dynamic();
}
inline void HloModuleProto::_internal_set_is_dynamic(bool value) {
  
  _impl_.is_dynamic_ = value;
}
inline void HloModuleProto::set_is_dynamic(bool value) {
  _internal_set_is_dynamic(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleProto.is_dynamic)
}

// .xla.OpSharding spmd_output_sharding = 12;
inline bool HloModuleProto::_internal_has_spmd_output_sharding() const {
  return this != internal_default_instance() && _impl_.spmd_output_sharding_ != nullptr;
}
inline bool HloModuleProto::has_spmd_output_sharding() const {
  return _internal_has_spmd_output_sharding();
}
inline const ::xla::OpSharding& HloModuleProto::_internal_spmd_output_sharding() const {
  const ::xla::OpSharding* p = _impl_.spmd_output_sharding_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::OpSharding&>(
      ::xla::_OpSharding_default_instance_);
}
inline const ::xla::OpSharding& HloModuleProto::spmd_output_sharding() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.spmd_output_sharding)
  return _internal_spmd_output_sharding();
}
inline void HloModuleProto::unsafe_arena_set_allocated_spmd_output_sharding(
    ::xla::OpSharding* spmd_output_sharding) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.spmd_output_sharding_);
  }
  _impl_.spmd_output_sharding_ = spmd_output_sharding;
  if (spmd_output_sharding) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleProto.spmd_output_sharding)
}
inline ::xla::OpSharding* HloModuleProto::release_spmd_output_sharding() {
  
  ::xla::OpSharding* temp = _impl_.spmd_output_sharding_;
  _impl_.spmd_output_sharding_ = 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 ::xla::OpSharding* HloModuleProto::unsafe_arena_release_spmd_output_sharding() {
  // @@protoc_insertion_point(field_release:xla.HloModuleProto.spmd_output_sharding)
  
  ::xla::OpSharding* temp = _impl_.spmd_output_sharding_;
  _impl_.spmd_output_sharding_ = nullptr;
  return temp;
}
inline ::xla::OpSharding* HloModuleProto::_internal_mutable_spmd_output_sharding() {
  
  if (_impl_.spmd_output_sharding_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::OpSharding>(GetArenaForAllocation());
    _impl_.spmd_output_sharding_ = p;
  }
  return _impl_.spmd_output_sharding_;
}
inline ::xla::OpSharding* HloModuleProto::mutable_spmd_output_sharding() {
  ::xla::OpSharding* _msg = _internal_mutable_spmd_output_sharding();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleProto.spmd_output_sharding)
  return _msg;
}
inline void HloModuleProto::set_allocated_spmd_output_sharding(::xla::OpSharding* spmd_output_sharding) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.spmd_output_sharding_);
  }
  if (spmd_output_sharding) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(spmd_output_sharding));
    if (message_arena != submessage_arena) {
      spmd_output_sharding = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, spmd_output_sharding, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.spmd_output_sharding_ = spmd_output_sharding;
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleProto.spmd_output_sharding)
}

// repeated .xla.OpSharding spmd_parameters_shardings = 14;
inline int HloModuleProto::_internal_spmd_parameters_shardings_size() const {
  return _impl_.spmd_parameters_shardings_.size();
}
inline int HloModuleProto::spmd_parameters_shardings_size() const {
  return _internal_spmd_parameters_shardings_size();
}
inline ::xla::OpSharding* HloModuleProto::mutable_spmd_parameters_shardings(int index) {
  // @@protoc_insertion_point(field_mutable:xla.HloModuleProto.spmd_parameters_shardings)
  return _impl_.spmd_parameters_shardings_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::OpSharding >*
HloModuleProto::mutable_spmd_parameters_shardings() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleProto.spmd_parameters_shardings)
  return &_impl_.spmd_parameters_shardings_;
}
inline const ::xla::OpSharding& HloModuleProto::_internal_spmd_parameters_shardings(int index) const {
  return _impl_.spmd_parameters_shardings_.Get(index);
}
inline const ::xla::OpSharding& HloModuleProto::spmd_parameters_shardings(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.spmd_parameters_shardings)
  return _internal_spmd_parameters_shardings(index);
}
inline ::xla::OpSharding* HloModuleProto::_internal_add_spmd_parameters_shardings() {
  return _impl_.spmd_parameters_shardings_.Add();
}
inline ::xla::OpSharding* HloModuleProto::add_spmd_parameters_shardings() {
  ::xla::OpSharding* _add = _internal_add_spmd_parameters_shardings();
  // @@protoc_insertion_point(field_add:xla.HloModuleProto.spmd_parameters_shardings)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::OpSharding >&
HloModuleProto::spmd_parameters_shardings() const {
  // @@protoc_insertion_point(field_list:xla.HloModuleProto.spmd_parameters_shardings)
  return _impl_.spmd_parameters_shardings_;
}

// bool use_auto_spmd_partitioning = 16;
inline void HloModuleProto::clear_use_auto_spmd_partitioning() {
  _impl_.use_auto_spmd_partitioning_ = false;
}
inline bool HloModuleProto::_internal_use_auto_spmd_partitioning() const {
  return _impl_.use_auto_spmd_partitioning_;
}
inline bool HloModuleProto::use_auto_spmd_partitioning() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.use_auto_spmd_partitioning)
  return _internal_use_auto_spmd_partitioning();
}
inline void HloModuleProto::_internal_set_use_auto_spmd_partitioning(bool value) {
  
  _impl_.use_auto_spmd_partitioning_ = value;
}
inline void HloModuleProto::set_use_auto_spmd_partitioning(bool value) {
  _internal_set_use_auto_spmd_partitioning(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleProto.use_auto_spmd_partitioning)
}

// repeated .xla.HloModuleProto.ProfileInfo profile_info = 13;
inline int HloModuleProto::_internal_profile_info_size() const {
  return _impl_.profile_info_.size();
}
inline int HloModuleProto::profile_info_size() const {
  return _internal_profile_info_size();
}
inline void HloModuleProto::clear_profile_info() {
  _impl_.profile_info_.Clear();
}
inline ::xla::HloModuleProto_ProfileInfo* HloModuleProto::mutable_profile_info(int index) {
  // @@protoc_insertion_point(field_mutable:xla.HloModuleProto.profile_info)
  return _impl_.profile_info_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleProto_ProfileInfo >*
HloModuleProto::mutable_profile_info() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleProto.profile_info)
  return &_impl_.profile_info_;
}
inline const ::xla::HloModuleProto_ProfileInfo& HloModuleProto::_internal_profile_info(int index) const {
  return _impl_.profile_info_.Get(index);
}
inline const ::xla::HloModuleProto_ProfileInfo& HloModuleProto::profile_info(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.profile_info)
  return _internal_profile_info(index);
}
inline ::xla::HloModuleProto_ProfileInfo* HloModuleProto::_internal_add_profile_info() {
  return _impl_.profile_info_.Add();
}
inline ::xla::HloModuleProto_ProfileInfo* HloModuleProto::add_profile_info() {
  ::xla::HloModuleProto_ProfileInfo* _add = _internal_add_profile_info();
  // @@protoc_insertion_point(field_add:xla.HloModuleProto.profile_info)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleProto_ProfileInfo >&
HloModuleProto::profile_info() const {
  // @@protoc_insertion_point(field_list:xla.HloModuleProto.profile_info)
  return _impl_.profile_info_;
}

// .xla.DeviceAssignmentProto device_assignment = 15;
inline bool HloModuleProto::_internal_has_device_assignment() const {
  return this != internal_default_instance() && _impl_.device_assignment_ != nullptr;
}
inline bool HloModuleProto::has_device_assignment() const {
  return _internal_has_device_assignment();
}
inline const ::xla::DeviceAssignmentProto& HloModuleProto::_internal_device_assignment() const {
  const ::xla::DeviceAssignmentProto* p = _impl_.device_assignment_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::DeviceAssignmentProto&>(
      ::xla::_DeviceAssignmentProto_default_instance_);
}
inline const ::xla::DeviceAssignmentProto& HloModuleProto::device_assignment() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleProto.device_assignment)
  return _internal_device_assignment();
}
inline void HloModuleProto::unsafe_arena_set_allocated_device_assignment(
    ::xla::DeviceAssignmentProto* device_assignment) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.device_assignment_);
  }
  _impl_.device_assignment_ = device_assignment;
  if (device_assignment) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleProto.device_assignment)
}
inline ::xla::DeviceAssignmentProto* HloModuleProto::release_device_assignment() {
  
  ::xla::DeviceAssignmentProto* temp = _impl_.device_assignment_;
  _impl_.device_assignment_ = 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 ::xla::DeviceAssignmentProto* HloModuleProto::unsafe_arena_release_device_assignment() {
  // @@protoc_insertion_point(field_release:xla.HloModuleProto.device_assignment)
  
  ::xla::DeviceAssignmentProto* temp = _impl_.device_assignment_;
  _impl_.device_assignment_ = nullptr;
  return temp;
}
inline ::xla::DeviceAssignmentProto* HloModuleProto::_internal_mutable_device_assignment() {
  
  if (_impl_.device_assignment_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::DeviceAssignmentProto>(GetArenaForAllocation());
    _impl_.device_assignment_ = p;
  }
  return _impl_.device_assignment_;
}
inline ::xla::DeviceAssignmentProto* HloModuleProto::mutable_device_assignment() {
  ::xla::DeviceAssignmentProto* _msg = _internal_mutable_device_assignment();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleProto.device_assignment)
  return _msg;
}
inline void HloModuleProto::set_allocated_device_assignment(::xla::DeviceAssignmentProto* device_assignment) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.device_assignment_);
  }
  if (device_assignment) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_assignment));
    if (message_arena != submessage_arena) {
      device_assignment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, device_assignment, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.device_assignment_ = device_assignment;
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleProto.device_assignment)
}

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

// LogicalBufferProto_Location

// string instruction_name = 2 [deprecated = true];
inline void LogicalBufferProto_Location::clear_instruction_name() {
  _impl_.instruction_name_.ClearToEmpty();
}
inline const std::string& LogicalBufferProto_Location::instruction_name() const {
  // @@protoc_insertion_point(field_get:xla.LogicalBufferProto.Location.instruction_name)
  return _internal_instruction_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LogicalBufferProto_Location::set_instruction_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.instruction_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.LogicalBufferProto.Location.instruction_name)
}
inline std::string* LogicalBufferProto_Location::mutable_instruction_name() {
  std::string* _s = _internal_mutable_instruction_name();
  // @@protoc_insertion_point(field_mutable:xla.LogicalBufferProto.Location.instruction_name)
  return _s;
}
inline const std::string& LogicalBufferProto_Location::_internal_instruction_name() const {
  return _impl_.instruction_name_.Get();
}
inline void LogicalBufferProto_Location::_internal_set_instruction_name(const std::string& value) {
  
  _impl_.instruction_name_.Set(value, GetArenaForAllocation());
}
inline std::string* LogicalBufferProto_Location::_internal_mutable_instruction_name() {
  
  return _impl_.instruction_name_.Mutable(GetArenaForAllocation());
}
inline std::string* LogicalBufferProto_Location::release_instruction_name() {
  // @@protoc_insertion_point(field_release:xla.LogicalBufferProto.Location.instruction_name)
  return _impl_.instruction_name_.Release();
}
inline void LogicalBufferProto_Location::set_allocated_instruction_name(std::string* instruction_name) {
  if (instruction_name != nullptr) {
    
  } else {
    
  }
  _impl_.instruction_name_.SetAllocated(instruction_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.instruction_name_.IsDefault()) {
    _impl_.instruction_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.LogicalBufferProto.Location.instruction_name)
}

// int64 instruction_id = 4;
inline void LogicalBufferProto_Location::clear_instruction_id() {
  _impl_.instruction_id_ = int64_t{0};
}
inline int64_t LogicalBufferProto_Location::_internal_instruction_id() const {
  return _impl_.instruction_id_;
}
inline int64_t LogicalBufferProto_Location::instruction_id() const {
  // @@protoc_insertion_point(field_get:xla.LogicalBufferProto.Location.instruction_id)
  return _internal_instruction_id();
}
inline void LogicalBufferProto_Location::_internal_set_instruction_id(int64_t value) {
  
  _impl_.instruction_id_ = value;
}
inline void LogicalBufferProto_Location::set_instruction_id(int64_t value) {
  _internal_set_instruction_id(value);
  // @@protoc_insertion_point(field_set:xla.LogicalBufferProto.Location.instruction_id)
}

// repeated int64 shape_index = 3;
inline int LogicalBufferProto_Location::_internal_shape_index_size() const {
  return _impl_.shape_index_.size();
}
inline int LogicalBufferProto_Location::shape_index_size() const {
  return _internal_shape_index_size();
}
inline void LogicalBufferProto_Location::clear_shape_index() {
  _impl_.shape_index_.Clear();
}
inline int64_t LogicalBufferProto_Location::_internal_shape_index(int index) const {
  return _impl_.shape_index_.Get(index);
}
inline int64_t LogicalBufferProto_Location::shape_index(int index) const {
  // @@protoc_insertion_point(field_get:xla.LogicalBufferProto.Location.shape_index)
  return _internal_shape_index(index);
}
inline void LogicalBufferProto_Location::set_shape_index(int index, int64_t value) {
  _impl_.shape_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.LogicalBufferProto.Location.shape_index)
}
inline void LogicalBufferProto_Location::_internal_add_shape_index(int64_t value) {
  _impl_.shape_index_.Add(value);
}
inline void LogicalBufferProto_Location::add_shape_index(int64_t value) {
  _internal_add_shape_index(value);
  // @@protoc_insertion_point(field_add:xla.LogicalBufferProto.Location.shape_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
LogicalBufferProto_Location::_internal_shape_index() const {
  return _impl_.shape_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
LogicalBufferProto_Location::shape_index() const {
  // @@protoc_insertion_point(field_list:xla.LogicalBufferProto.Location.shape_index)
  return _internal_shape_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
LogicalBufferProto_Location::_internal_mutable_shape_index() {
  return &_impl_.shape_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
LogicalBufferProto_Location::mutable_shape_index() {
  // @@protoc_insertion_point(field_mutable_list:xla.LogicalBufferProto.Location.shape_index)
  return _internal_mutable_shape_index();
}

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

// LogicalBufferProto

// int64 id = 1;
inline void LogicalBufferProto::clear_id() {
  _impl_.id_ = int64_t{0};
}
inline int64_t LogicalBufferProto::_internal_id() const {
  return _impl_.id_;
}
inline int64_t LogicalBufferProto::id() const {
  // @@protoc_insertion_point(field_get:xla.LogicalBufferProto.id)
  return _internal_id();
}
inline void LogicalBufferProto::_internal_set_id(int64_t value) {
  
  _impl_.id_ = value;
}
inline void LogicalBufferProto::set_id(int64_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:xla.LogicalBufferProto.id)
}

// int64 size = 2;
inline void LogicalBufferProto::clear_size() {
  _impl_.size_ = int64_t{0};
}
inline int64_t LogicalBufferProto::_internal_size() const {
  return _impl_.size_;
}
inline int64_t LogicalBufferProto::size() const {
  // @@protoc_insertion_point(field_get:xla.LogicalBufferProto.size)
  return _internal_size();
}
inline void LogicalBufferProto::_internal_set_size(int64_t value) {
  
  _impl_.size_ = value;
}
inline void LogicalBufferProto::set_size(int64_t value) {
  _internal_set_size(value);
  // @@protoc_insertion_point(field_set:xla.LogicalBufferProto.size)
}

// .xla.LogicalBufferProto.Location defined_at = 3;
inline bool LogicalBufferProto::_internal_has_defined_at() const {
  return this != internal_default_instance() && _impl_.defined_at_ != nullptr;
}
inline bool LogicalBufferProto::has_defined_at() const {
  return _internal_has_defined_at();
}
inline void LogicalBufferProto::clear_defined_at() {
  if (GetArenaForAllocation() == nullptr && _impl_.defined_at_ != nullptr) {
    delete _impl_.defined_at_;
  }
  _impl_.defined_at_ = nullptr;
}
inline const ::xla::LogicalBufferProto_Location& LogicalBufferProto::_internal_defined_at() const {
  const ::xla::LogicalBufferProto_Location* p = _impl_.defined_at_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::LogicalBufferProto_Location&>(
      ::xla::_LogicalBufferProto_Location_default_instance_);
}
inline const ::xla::LogicalBufferProto_Location& LogicalBufferProto::defined_at() const {
  // @@protoc_insertion_point(field_get:xla.LogicalBufferProto.defined_at)
  return _internal_defined_at();
}
inline void LogicalBufferProto::unsafe_arena_set_allocated_defined_at(
    ::xla::LogicalBufferProto_Location* defined_at) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.defined_at_);
  }
  _impl_.defined_at_ = defined_at;
  if (defined_at) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.LogicalBufferProto.defined_at)
}
inline ::xla::LogicalBufferProto_Location* LogicalBufferProto::release_defined_at() {
  
  ::xla::LogicalBufferProto_Location* temp = _impl_.defined_at_;
  _impl_.defined_at_ = 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 ::xla::LogicalBufferProto_Location* LogicalBufferProto::unsafe_arena_release_defined_at() {
  // @@protoc_insertion_point(field_release:xla.LogicalBufferProto.defined_at)
  
  ::xla::LogicalBufferProto_Location* temp = _impl_.defined_at_;
  _impl_.defined_at_ = nullptr;
  return temp;
}
inline ::xla::LogicalBufferProto_Location* LogicalBufferProto::_internal_mutable_defined_at() {
  
  if (_impl_.defined_at_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::LogicalBufferProto_Location>(GetArenaForAllocation());
    _impl_.defined_at_ = p;
  }
  return _impl_.defined_at_;
}
inline ::xla::LogicalBufferProto_Location* LogicalBufferProto::mutable_defined_at() {
  ::xla::LogicalBufferProto_Location* _msg = _internal_mutable_defined_at();
  // @@protoc_insertion_point(field_mutable:xla.LogicalBufferProto.defined_at)
  return _msg;
}
inline void LogicalBufferProto::set_allocated_defined_at(::xla::LogicalBufferProto_Location* defined_at) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.defined_at_;
  }
  if (defined_at) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(defined_at);
    if (message_arena != submessage_arena) {
      defined_at = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, defined_at, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.defined_at_ = defined_at;
  // @@protoc_insertion_point(field_set_allocated:xla.LogicalBufferProto.defined_at)
}

// int64 color = 4;
inline void LogicalBufferProto::clear_color() {
  _impl_.color_ = int64_t{0};
}
inline int64_t LogicalBufferProto::_internal_color() const {
  return _impl_.color_;
}
inline int64_t LogicalBufferProto::color() const {
  // @@protoc_insertion_point(field_get:xla.LogicalBufferProto.color)
  return _internal_color();
}
inline void LogicalBufferProto::_internal_set_color(int64_t value) {
  
  _impl_.color_ = value;
}
inline void LogicalBufferProto::set_color(int64_t value) {
  _internal_set_color(value);
  // @@protoc_insertion_point(field_set:xla.LogicalBufferProto.color)
}

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

// BufferAllocationProto_Assigned

// int64 logical_buffer_id = 1;
inline void BufferAllocationProto_Assigned::clear_logical_buffer_id() {
  _impl_.logical_buffer_id_ = int64_t{0};
}
inline int64_t BufferAllocationProto_Assigned::_internal_logical_buffer_id() const {
  return _impl_.logical_buffer_id_;
}
inline int64_t BufferAllocationProto_Assigned::logical_buffer_id() const {
  // @@protoc_insertion_point(field_get:xla.BufferAllocationProto.Assigned.logical_buffer_id)
  return _internal_logical_buffer_id();
}
inline void BufferAllocationProto_Assigned::_internal_set_logical_buffer_id(int64_t value) {
  
  _impl_.logical_buffer_id_ = value;
}
inline void BufferAllocationProto_Assigned::set_logical_buffer_id(int64_t value) {
  _internal_set_logical_buffer_id(value);
  // @@protoc_insertion_point(field_set:xla.BufferAllocationProto.Assigned.logical_buffer_id)
}

// int64 offset = 2;
inline void BufferAllocationProto_Assigned::clear_offset() {
  _impl_.offset_ = int64_t{0};
}
inline int64_t BufferAllocationProto_Assigned::_internal_offset() const {
  return _impl_.offset_;
}
inline int64_t BufferAllocationProto_Assigned::offset() const {
  // @@protoc_insertion_point(field_get:xla.BufferAllocationProto.Assigned.offset)
  return _internal_offset();
}
inline void BufferAllocationProto_Assigned::_internal_set_offset(int64_t value) {
  
  _impl_.offset_ = value;
}
inline void BufferAllocationProto_Assigned::set_offset(int64_t value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:xla.BufferAllocationProto.Assigned.offset)
}

// int64 size = 3;
inline void BufferAllocationProto_Assigned::clear_size() {
  _impl_.size_ = int64_t{0};
}
inline int64_t BufferAllocationProto_Assigned::_internal_size() const {
  return _impl_.size_;
}
inline int64_t BufferAllocationProto_Assigned::size() const {
  // @@protoc_insertion_point(field_get:xla.BufferAllocationProto.Assigned.size)
  return _internal_size();
}
inline void BufferAllocationProto_Assigned::_internal_set_size(int64_t value) {
  
  _impl_.size_ = value;
}
inline void BufferAllocationProto_Assigned::set_size(int64_t value) {
  _internal_set_size(value);
  // @@protoc_insertion_point(field_set:xla.BufferAllocationProto.Assigned.size)
}

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

// BufferAllocationProto

// int64 index = 1;
inline void BufferAllocationProto::clear_index() {
  _impl_.index_ = int64_t{0};
}
inline int64_t BufferAllocationProto::_internal_index() const {
  return _impl_.index_;
}
inline int64_t BufferAllocationProto::index() const {
  // @@protoc_insertion_point(field_get:xla.BufferAllocationProto.index)
  return _internal_index();
}
inline void BufferAllocationProto::_internal_set_index(int64_t value) {
  
  _impl_.index_ = value;
}
inline void BufferAllocationProto::set_index(int64_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:xla.BufferAllocationProto.index)
}

// int64 size = 2;
inline void BufferAllocationProto::clear_size() {
  _impl_.size_ = int64_t{0};
}
inline int64_t BufferAllocationProto::_internal_size() const {
  return _impl_.size_;
}
inline int64_t BufferAllocationProto::size() const {
  // @@protoc_insertion_point(field_get:xla.BufferAllocationProto.size)
  return _internal_size();
}
inline void BufferAllocationProto::_internal_set_size(int64_t value) {
  
  _impl_.size_ = value;
}
inline void BufferAllocationProto::set_size(int64_t value) {
  _internal_set_size(value);
  // @@protoc_insertion_point(field_set:xla.BufferAllocationProto.size)
}

// bool is_thread_local = 3;
inline void BufferAllocationProto::clear_is_thread_local() {
  _impl_.is_thread_local_ = false;
}
inline bool BufferAllocationProto::_internal_is_thread_local() const {
  return _impl_.is_thread_local_;
}
inline bool BufferAllocationProto::is_thread_local() const {
  // @@protoc_insertion_point(field_get:xla.BufferAllocationProto.is_thread_local)
  return _internal_is_thread_local();
}
inline void BufferAllocationProto::_internal_set_is_thread_local(bool value) {
  
  _impl_.is_thread_local_ = value;
}
inline void BufferAllocationProto::set_is_thread_local(bool value) {
  _internal_set_is_thread_local(value);
  // @@protoc_insertion_point(field_set:xla.BufferAllocationProto.is_thread_local)
}

// bool is_tuple = 11;
inline void BufferAllocationProto::clear_is_tuple() {
  _impl_.is_tuple_ = false;
}
inline bool BufferAllocationProto::_internal_is_tuple() const {
  return _impl_.is_tuple_;
}
inline bool BufferAllocationProto::is_tuple() const {
  // @@protoc_insertion_point(field_get:xla.BufferAllocationProto.is_tuple)
  return _internal_is_tuple();
}
inline void BufferAllocationProto::_internal_set_is_tuple(bool value) {
  
  _impl_.is_tuple_ = value;
}
inline void BufferAllocationProto::set_is_tuple(bool value) {
  _internal_set_is_tuple(value);
  // @@protoc_insertion_point(field_set:xla.BufferAllocationProto.is_tuple)
}

// bool is_entry_computation_parameter = 5;
inline void BufferAllocationProto::clear_is_entry_computation_parameter() {
  _impl_.is_entry_computation_parameter_ = false;
}
inline bool BufferAllocationProto::_internal_is_entry_computation_parameter() const {
  return _impl_.is_entry_computation_parameter_;
}
inline bool BufferAllocationProto::is_entry_computation_parameter() const {
  // @@protoc_insertion_point(field_get:xla.BufferAllocationProto.is_entry_computation_parameter)
  return _internal_is_entry_computation_parameter();
}
inline void BufferAllocationProto::_internal_set_is_entry_computation_parameter(bool value) {
  
  _impl_.is_entry_computation_parameter_ = value;
}
inline void BufferAllocationProto::set_is_entry_computation_parameter(bool value) {
  _internal_set_is_entry_computation_parameter(value);
  // @@protoc_insertion_point(field_set:xla.BufferAllocationProto.is_entry_computation_parameter)
}

// bool is_constant = 12;
inline void BufferAllocationProto::clear_is_constant() {
  _impl_.is_constant_ = false;
}
inline bool BufferAllocationProto::_internal_is_constant() const {
  return _impl_.is_constant_;
}
inline bool BufferAllocationProto::is_constant() const {
  // @@protoc_insertion_point(field_get:xla.BufferAllocationProto.is_constant)
  return _internal_is_constant();
}
inline void BufferAllocationProto::_internal_set_is_constant(bool value) {
  
  _impl_.is_constant_ = value;
}
inline void BufferAllocationProto::set_is_constant(bool value) {
  _internal_set_is_constant(value);
  // @@protoc_insertion_point(field_set:xla.BufferAllocationProto.is_constant)
}

// int64 parameter_number = 6;
inline void BufferAllocationProto::clear_parameter_number() {
  _impl_.parameter_number_ = int64_t{0};
}
inline int64_t BufferAllocationProto::_internal_parameter_number() const {
  return _impl_.parameter_number_;
}
inline int64_t BufferAllocationProto::parameter_number() const {
  // @@protoc_insertion_point(field_get:xla.BufferAllocationProto.parameter_number)
  return _internal_parameter_number();
}
inline void BufferAllocationProto::_internal_set_parameter_number(int64_t value) {
  
  _impl_.parameter_number_ = value;
}
inline void BufferAllocationProto::set_parameter_number(int64_t value) {
  _internal_set_parameter_number(value);
  // @@protoc_insertion_point(field_set:xla.BufferAllocationProto.parameter_number)
}

// repeated int64 parameter_shape_index = 10;
inline int BufferAllocationProto::_internal_parameter_shape_index_size() const {
  return _impl_.parameter_shape_index_.size();
}
inline int BufferAllocationProto::parameter_shape_index_size() const {
  return _internal_parameter_shape_index_size();
}
inline void BufferAllocationProto::clear_parameter_shape_index() {
  _impl_.parameter_shape_index_.Clear();
}
inline int64_t BufferAllocationProto::_internal_parameter_shape_index(int index) const {
  return _impl_.parameter_shape_index_.Get(index);
}
inline int64_t BufferAllocationProto::parameter_shape_index(int index) const {
  // @@protoc_insertion_point(field_get:xla.BufferAllocationProto.parameter_shape_index)
  return _internal_parameter_shape_index(index);
}
inline void BufferAllocationProto::set_parameter_shape_index(int index, int64_t value) {
  _impl_.parameter_shape_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.BufferAllocationProto.parameter_shape_index)
}
inline void BufferAllocationProto::_internal_add_parameter_shape_index(int64_t value) {
  _impl_.parameter_shape_index_.Add(value);
}
inline void BufferAllocationProto::add_parameter_shape_index(int64_t value) {
  _internal_add_parameter_shape_index(value);
  // @@protoc_insertion_point(field_add:xla.BufferAllocationProto.parameter_shape_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
BufferAllocationProto::_internal_parameter_shape_index() const {
  return _impl_.parameter_shape_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
BufferAllocationProto::parameter_shape_index() const {
  // @@protoc_insertion_point(field_list:xla.BufferAllocationProto.parameter_shape_index)
  return _internal_parameter_shape_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
BufferAllocationProto::_internal_mutable_parameter_shape_index() {
  return &_impl_.parameter_shape_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
BufferAllocationProto::mutable_parameter_shape_index() {
  // @@protoc_insertion_point(field_mutable_list:xla.BufferAllocationProto.parameter_shape_index)
  return _internal_mutable_parameter_shape_index();
}

// bool maybe_live_out = 7;
inline void BufferAllocationProto::clear_maybe_live_out() {
  _impl_.maybe_live_out_ = false;
}
inline bool BufferAllocationProto::_internal_maybe_live_out() const {
  return _impl_.maybe_live_out_;
}
inline bool BufferAllocationProto::maybe_live_out() const {
  // @@protoc_insertion_point(field_get:xla.BufferAllocationProto.maybe_live_out)
  return _internal_maybe_live_out();
}
inline void BufferAllocationProto::_internal_set_maybe_live_out(bool value) {
  
  _impl_.maybe_live_out_ = value;
}
inline void BufferAllocationProto::set_maybe_live_out(bool value) {
  _internal_set_maybe_live_out(value);
  // @@protoc_insertion_point(field_set:xla.BufferAllocationProto.maybe_live_out)
}

// int64 color = 8;
inline void BufferAllocationProto::clear_color() {
  _impl_.color_ = int64_t{0};
}
inline int64_t BufferAllocationProto::_internal_color() const {
  return _impl_.color_;
}
inline int64_t BufferAllocationProto::color() const {
  // @@protoc_insertion_point(field_get:xla.BufferAllocationProto.color)
  return _internal_color();
}
inline void BufferAllocationProto::_internal_set_color(int64_t value) {
  
  _impl_.color_ = value;
}
inline void BufferAllocationProto::set_color(int64_t value) {
  _internal_set_color(value);
  // @@protoc_insertion_point(field_set:xla.BufferAllocationProto.color)
}

// repeated .xla.BufferAllocationProto.Assigned assigned = 9;
inline int BufferAllocationProto::_internal_assigned_size() const {
  return _impl_.assigned_.size();
}
inline int BufferAllocationProto::assigned_size() const {
  return _internal_assigned_size();
}
inline void BufferAllocationProto::clear_assigned() {
  _impl_.assigned_.Clear();
}
inline ::xla::BufferAllocationProto_Assigned* BufferAllocationProto::mutable_assigned(int index) {
  // @@protoc_insertion_point(field_mutable:xla.BufferAllocationProto.assigned)
  return _impl_.assigned_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::BufferAllocationProto_Assigned >*
BufferAllocationProto::mutable_assigned() {
  // @@protoc_insertion_point(field_mutable_list:xla.BufferAllocationProto.assigned)
  return &_impl_.assigned_;
}
inline const ::xla::BufferAllocationProto_Assigned& BufferAllocationProto::_internal_assigned(int index) const {
  return _impl_.assigned_.Get(index);
}
inline const ::xla::BufferAllocationProto_Assigned& BufferAllocationProto::assigned(int index) const {
  // @@protoc_insertion_point(field_get:xla.BufferAllocationProto.assigned)
  return _internal_assigned(index);
}
inline ::xla::BufferAllocationProto_Assigned* BufferAllocationProto::_internal_add_assigned() {
  return _impl_.assigned_.Add();
}
inline ::xla::BufferAllocationProto_Assigned* BufferAllocationProto::add_assigned() {
  ::xla::BufferAllocationProto_Assigned* _add = _internal_add_assigned();
  // @@protoc_insertion_point(field_add:xla.BufferAllocationProto.assigned)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::BufferAllocationProto_Assigned >&
BufferAllocationProto::assigned() const {
  // @@protoc_insertion_point(field_list:xla.BufferAllocationProto.assigned)
  return _impl_.assigned_;
}

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

// HeapSimulatorTrace_Event

// .xla.HeapSimulatorTrace.Event.Kind kind = 1;
inline void HeapSimulatorTrace_Event::clear_kind() {
  _impl_.kind_ = 0;
}
inline ::xla::HeapSimulatorTrace_Event_Kind HeapSimulatorTrace_Event::_internal_kind() const {
  return static_cast< ::xla::HeapSimulatorTrace_Event_Kind >(_impl_.kind_);
}
inline ::xla::HeapSimulatorTrace_Event_Kind HeapSimulatorTrace_Event::kind() const {
  // @@protoc_insertion_point(field_get:xla.HeapSimulatorTrace.Event.kind)
  return _internal_kind();
}
inline void HeapSimulatorTrace_Event::_internal_set_kind(::xla::HeapSimulatorTrace_Event_Kind value) {
  
  _impl_.kind_ = value;
}
inline void HeapSimulatorTrace_Event::set_kind(::xla::HeapSimulatorTrace_Event_Kind value) {
  _internal_set_kind(value);
  // @@protoc_insertion_point(field_set:xla.HeapSimulatorTrace.Event.kind)
}

// int64 buffer_id = 2;
inline void HeapSimulatorTrace_Event::clear_buffer_id() {
  _impl_.buffer_id_ = int64_t{0};
}
inline int64_t HeapSimulatorTrace_Event::_internal_buffer_id() const {
  return _impl_.buffer_id_;
}
inline int64_t HeapSimulatorTrace_Event::buffer_id() const {
  // @@protoc_insertion_point(field_get:xla.HeapSimulatorTrace.Event.buffer_id)
  return _internal_buffer_id();
}
inline void HeapSimulatorTrace_Event::_internal_set_buffer_id(int64_t value) {
  
  _impl_.buffer_id_ = value;
}
inline void HeapSimulatorTrace_Event::set_buffer_id(int64_t value) {
  _internal_set_buffer_id(value);
  // @@protoc_insertion_point(field_set:xla.HeapSimulatorTrace.Event.buffer_id)
}

// string computation_name = 3;
inline void HeapSimulatorTrace_Event::clear_computation_name() {
  _impl_.computation_name_.ClearToEmpty();
}
inline const std::string& HeapSimulatorTrace_Event::computation_name() const {
  // @@protoc_insertion_point(field_get:xla.HeapSimulatorTrace.Event.computation_name)
  return _internal_computation_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HeapSimulatorTrace_Event::set_computation_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.computation_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HeapSimulatorTrace.Event.computation_name)
}
inline std::string* HeapSimulatorTrace_Event::mutable_computation_name() {
  std::string* _s = _internal_mutable_computation_name();
  // @@protoc_insertion_point(field_mutable:xla.HeapSimulatorTrace.Event.computation_name)
  return _s;
}
inline const std::string& HeapSimulatorTrace_Event::_internal_computation_name() const {
  return _impl_.computation_name_.Get();
}
inline void HeapSimulatorTrace_Event::_internal_set_computation_name(const std::string& value) {
  
  _impl_.computation_name_.Set(value, GetArenaForAllocation());
}
inline std::string* HeapSimulatorTrace_Event::_internal_mutable_computation_name() {
  
  return _impl_.computation_name_.Mutable(GetArenaForAllocation());
}
inline std::string* HeapSimulatorTrace_Event::release_computation_name() {
  // @@protoc_insertion_point(field_release:xla.HeapSimulatorTrace.Event.computation_name)
  return _impl_.computation_name_.Release();
}
inline void HeapSimulatorTrace_Event::set_allocated_computation_name(std::string* computation_name) {
  if (computation_name != nullptr) {
    
  } else {
    
  }
  _impl_.computation_name_.SetAllocated(computation_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.computation_name_.IsDefault()) {
    _impl_.computation_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HeapSimulatorTrace.Event.computation_name)
}

// string instruction_name = 4;
inline void HeapSimulatorTrace_Event::clear_instruction_name() {
  _impl_.instruction_name_.ClearToEmpty();
}
inline const std::string& HeapSimulatorTrace_Event::instruction_name() const {
  // @@protoc_insertion_point(field_get:xla.HeapSimulatorTrace.Event.instruction_name)
  return _internal_instruction_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HeapSimulatorTrace_Event::set_instruction_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.instruction_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HeapSimulatorTrace.Event.instruction_name)
}
inline std::string* HeapSimulatorTrace_Event::mutable_instruction_name() {
  std::string* _s = _internal_mutable_instruction_name();
  // @@protoc_insertion_point(field_mutable:xla.HeapSimulatorTrace.Event.instruction_name)
  return _s;
}
inline const std::string& HeapSimulatorTrace_Event::_internal_instruction_name() const {
  return _impl_.instruction_name_.Get();
}
inline void HeapSimulatorTrace_Event::_internal_set_instruction_name(const std::string& value) {
  
  _impl_.instruction_name_.Set(value, GetArenaForAllocation());
}
inline std::string* HeapSimulatorTrace_Event::_internal_mutable_instruction_name() {
  
  return _impl_.instruction_name_.Mutable(GetArenaForAllocation());
}
inline std::string* HeapSimulatorTrace_Event::release_instruction_name() {
  // @@protoc_insertion_point(field_release:xla.HeapSimulatorTrace.Event.instruction_name)
  return _impl_.instruction_name_.Release();
}
inline void HeapSimulatorTrace_Event::set_allocated_instruction_name(std::string* instruction_name) {
  if (instruction_name != nullptr) {
    
  } else {
    
  }
  _impl_.instruction_name_.SetAllocated(instruction_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.instruction_name_.IsDefault()) {
    _impl_.instruction_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HeapSimulatorTrace.Event.instruction_name)
}

// int64 share_with_canonical_id = 5;
inline void HeapSimulatorTrace_Event::clear_share_with_canonical_id() {
  _impl_.share_with_canonical_id_ = int64_t{0};
}
inline int64_t HeapSimulatorTrace_Event::_internal_share_with_canonical_id() const {
  return _impl_.share_with_canonical_id_;
}
inline int64_t HeapSimulatorTrace_Event::share_with_canonical_id() const {
  // @@protoc_insertion_point(field_get:xla.HeapSimulatorTrace.Event.share_with_canonical_id)
  return _internal_share_with_canonical_id();
}
inline void HeapSimulatorTrace_Event::_internal_set_share_with_canonical_id(int64_t value) {
  
  _impl_.share_with_canonical_id_ = value;
}
inline void HeapSimulatorTrace_Event::set_share_with_canonical_id(int64_t value) {
  _internal_set_share_with_canonical_id(value);
  // @@protoc_insertion_point(field_set:xla.HeapSimulatorTrace.Event.share_with_canonical_id)
}

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

// HeapSimulatorTrace

// repeated .xla.HeapSimulatorTrace.Event events = 1;
inline int HeapSimulatorTrace::_internal_events_size() const {
  return _impl_.events_.size();
}
inline int HeapSimulatorTrace::events_size() const {
  return _internal_events_size();
}
inline void HeapSimulatorTrace::clear_events() {
  _impl_.events_.Clear();
}
inline ::xla::HeapSimulatorTrace_Event* HeapSimulatorTrace::mutable_events(int index) {
  // @@protoc_insertion_point(field_mutable:xla.HeapSimulatorTrace.events)
  return _impl_.events_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HeapSimulatorTrace_Event >*
HeapSimulatorTrace::mutable_events() {
  // @@protoc_insertion_point(field_mutable_list:xla.HeapSimulatorTrace.events)
  return &_impl_.events_;
}
inline const ::xla::HeapSimulatorTrace_Event& HeapSimulatorTrace::_internal_events(int index) const {
  return _impl_.events_.Get(index);
}
inline const ::xla::HeapSimulatorTrace_Event& HeapSimulatorTrace::events(int index) const {
  // @@protoc_insertion_point(field_get:xla.HeapSimulatorTrace.events)
  return _internal_events(index);
}
inline ::xla::HeapSimulatorTrace_Event* HeapSimulatorTrace::_internal_add_events() {
  return _impl_.events_.Add();
}
inline ::xla::HeapSimulatorTrace_Event* HeapSimulatorTrace::add_events() {
  ::xla::HeapSimulatorTrace_Event* _add = _internal_add_events();
  // @@protoc_insertion_point(field_add:xla.HeapSimulatorTrace.events)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HeapSimulatorTrace_Event >&
HeapSimulatorTrace::events() const {
  // @@protoc_insertion_point(field_list:xla.HeapSimulatorTrace.events)
  return _impl_.events_;
}

// bool whole_module_simulation = 2;
inline void HeapSimulatorTrace::clear_whole_module_simulation() {
  _impl_.whole_module_simulation_ = false;
}
inline bool HeapSimulatorTrace::_internal_whole_module_simulation() const {
  return _impl_.whole_module_simulation_;
}
inline bool HeapSimulatorTrace::whole_module_simulation() const {
  // @@protoc_insertion_point(field_get:xla.HeapSimulatorTrace.whole_module_simulation)
  return _internal_whole_module_simulation();
}
inline void HeapSimulatorTrace::_internal_set_whole_module_simulation(bool value) {
  
  _impl_.whole_module_simulation_ = value;
}
inline void HeapSimulatorTrace::set_whole_module_simulation(bool value) {
  _internal_set_whole_module_simulation(value);
  // @@protoc_insertion_point(field_set:xla.HeapSimulatorTrace.whole_module_simulation)
}

// int64 buffer_allocation_index = 3;
inline void HeapSimulatorTrace::clear_buffer_allocation_index() {
  _impl_.buffer_allocation_index_ = int64_t{0};
}
inline int64_t HeapSimulatorTrace::_internal_buffer_allocation_index() const {
  return _impl_.buffer_allocation_index_;
}
inline int64_t HeapSimulatorTrace::buffer_allocation_index() const {
  // @@protoc_insertion_point(field_get:xla.HeapSimulatorTrace.buffer_allocation_index)
  return _internal_buffer_allocation_index();
}
inline void HeapSimulatorTrace::_internal_set_buffer_allocation_index(int64_t value) {
  
  _impl_.buffer_allocation_index_ = value;
}
inline void HeapSimulatorTrace::set_buffer_allocation_index(int64_t value) {
  _internal_set_buffer_allocation_index(value);
  // @@protoc_insertion_point(field_set:xla.HeapSimulatorTrace.buffer_allocation_index)
}

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

// HloModuleGroupProto

// string name = 1;
inline void HloModuleGroupProto::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& HloModuleGroupProto::name() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleGroupProto.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloModuleGroupProto::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloModuleGroupProto.name)
}
inline std::string* HloModuleGroupProto::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleGroupProto.name)
  return _s;
}
inline const std::string& HloModuleGroupProto::_internal_name() const {
  return _impl_.name_.Get();
}
inline void HloModuleGroupProto::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* HloModuleGroupProto::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* HloModuleGroupProto::release_name() {
  // @@protoc_insertion_point(field_release:xla.HloModuleGroupProto.name)
  return _impl_.name_.Release();
}
inline void HloModuleGroupProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _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:xla.HloModuleGroupProto.name)
}

// repeated .xla.HloModuleProto hlo_modules = 2;
inline int HloModuleGroupProto::_internal_hlo_modules_size() const {
  return _impl_.hlo_modules_.size();
}
inline int HloModuleGroupProto::hlo_modules_size() const {
  return _internal_hlo_modules_size();
}
inline void HloModuleGroupProto::clear_hlo_modules() {
  _impl_.hlo_modules_.Clear();
}
inline ::xla::HloModuleProto* HloModuleGroupProto::mutable_hlo_modules(int index) {
  // @@protoc_insertion_point(field_mutable:xla.HloModuleGroupProto.hlo_modules)
  return _impl_.hlo_modules_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleProto >*
HloModuleGroupProto::mutable_hlo_modules() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleGroupProto.hlo_modules)
  return &_impl_.hlo_modules_;
}
inline const ::xla::HloModuleProto& HloModuleGroupProto::_internal_hlo_modules(int index) const {
  return _impl_.hlo_modules_.Get(index);
}
inline const ::xla::HloModuleProto& HloModuleGroupProto::hlo_modules(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloModuleGroupProto.hlo_modules)
  return _internal_hlo_modules(index);
}
inline ::xla::HloModuleProto* HloModuleGroupProto::_internal_add_hlo_modules() {
  return _impl_.hlo_modules_.Add();
}
inline ::xla::HloModuleProto* HloModuleGroupProto::add_hlo_modules() {
  ::xla::HloModuleProto* _add = _internal_add_hlo_modules();
  // @@protoc_insertion_point(field_add:xla.HloModuleGroupProto.hlo_modules)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleProto >&
HloModuleGroupProto::hlo_modules() const {
  // @@protoc_insertion_point(field_list:xla.HloModuleGroupProto.hlo_modules)
  return _impl_.hlo_modules_;
}

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

// BufferAssignmentProto_BufferAlias

// int64 source_buffer_id = 1;
inline void BufferAssignmentProto_BufferAlias::clear_source_buffer_id() {
  _impl_.source_buffer_id_ = int64_t{0};
}
inline int64_t BufferAssignmentProto_BufferAlias::_internal_source_buffer_id() const {
  return _impl_.source_buffer_id_;
}
inline int64_t BufferAssignmentProto_BufferAlias::source_buffer_id() const {
  // @@protoc_insertion_point(field_get:xla.BufferAssignmentProto.BufferAlias.source_buffer_id)
  return _internal_source_buffer_id();
}
inline void BufferAssignmentProto_BufferAlias::_internal_set_source_buffer_id(int64_t value) {
  
  _impl_.source_buffer_id_ = value;
}
inline void BufferAssignmentProto_BufferAlias::set_source_buffer_id(int64_t value) {
  _internal_set_source_buffer_id(value);
  // @@protoc_insertion_point(field_set:xla.BufferAssignmentProto.BufferAlias.source_buffer_id)
}

// .xla.LogicalBufferProto.Location location = 2;
inline bool BufferAssignmentProto_BufferAlias::_internal_has_location() const {
  return this != internal_default_instance() && _impl_.location_ != nullptr;
}
inline bool BufferAssignmentProto_BufferAlias::has_location() const {
  return _internal_has_location();
}
inline void BufferAssignmentProto_BufferAlias::clear_location() {
  if (GetArenaForAllocation() == nullptr && _impl_.location_ != nullptr) {
    delete _impl_.location_;
  }
  _impl_.location_ = nullptr;
}
inline const ::xla::LogicalBufferProto_Location& BufferAssignmentProto_BufferAlias::_internal_location() const {
  const ::xla::LogicalBufferProto_Location* p = _impl_.location_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::LogicalBufferProto_Location&>(
      ::xla::_LogicalBufferProto_Location_default_instance_);
}
inline const ::xla::LogicalBufferProto_Location& BufferAssignmentProto_BufferAlias::location() const {
  // @@protoc_insertion_point(field_get:xla.BufferAssignmentProto.BufferAlias.location)
  return _internal_location();
}
inline void BufferAssignmentProto_BufferAlias::unsafe_arena_set_allocated_location(
    ::xla::LogicalBufferProto_Location* location) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.location_);
  }
  _impl_.location_ = location;
  if (location) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.BufferAssignmentProto.BufferAlias.location)
}
inline ::xla::LogicalBufferProto_Location* BufferAssignmentProto_BufferAlias::release_location() {
  
  ::xla::LogicalBufferProto_Location* temp = _impl_.location_;
  _impl_.location_ = 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 ::xla::LogicalBufferProto_Location* BufferAssignmentProto_BufferAlias::unsafe_arena_release_location() {
  // @@protoc_insertion_point(field_release:xla.BufferAssignmentProto.BufferAlias.location)
  
  ::xla::LogicalBufferProto_Location* temp = _impl_.location_;
  _impl_.location_ = nullptr;
  return temp;
}
inline ::xla::LogicalBufferProto_Location* BufferAssignmentProto_BufferAlias::_internal_mutable_location() {
  
  if (_impl_.location_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::LogicalBufferProto_Location>(GetArenaForAllocation());
    _impl_.location_ = p;
  }
  return _impl_.location_;
}
inline ::xla::LogicalBufferProto_Location* BufferAssignmentProto_BufferAlias::mutable_location() {
  ::xla::LogicalBufferProto_Location* _msg = _internal_mutable_location();
  // @@protoc_insertion_point(field_mutable:xla.BufferAssignmentProto.BufferAlias.location)
  return _msg;
}
inline void BufferAssignmentProto_BufferAlias::set_allocated_location(::xla::LogicalBufferProto_Location* location) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.location_;
  }
  if (location) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(location);
    if (message_arena != submessage_arena) {
      location = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, location, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.location_ = location;
  // @@protoc_insertion_point(field_set_allocated:xla.BufferAssignmentProto.BufferAlias.location)
}

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

// BufferAssignmentProto

// repeated .xla.LogicalBufferProto logical_buffers = 1;
inline int BufferAssignmentProto::_internal_logical_buffers_size() const {
  return _impl_.logical_buffers_.size();
}
inline int BufferAssignmentProto::logical_buffers_size() const {
  return _internal_logical_buffers_size();
}
inline void BufferAssignmentProto::clear_logical_buffers() {
  _impl_.logical_buffers_.Clear();
}
inline ::xla::LogicalBufferProto* BufferAssignmentProto::mutable_logical_buffers(int index) {
  // @@protoc_insertion_point(field_mutable:xla.BufferAssignmentProto.logical_buffers)
  return _impl_.logical_buffers_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LogicalBufferProto >*
BufferAssignmentProto::mutable_logical_buffers() {
  // @@protoc_insertion_point(field_mutable_list:xla.BufferAssignmentProto.logical_buffers)
  return &_impl_.logical_buffers_;
}
inline const ::xla::LogicalBufferProto& BufferAssignmentProto::_internal_logical_buffers(int index) const {
  return _impl_.logical_buffers_.Get(index);
}
inline const ::xla::LogicalBufferProto& BufferAssignmentProto::logical_buffers(int index) const {
  // @@protoc_insertion_point(field_get:xla.BufferAssignmentProto.logical_buffers)
  return _internal_logical_buffers(index);
}
inline ::xla::LogicalBufferProto* BufferAssignmentProto::_internal_add_logical_buffers() {
  return _impl_.logical_buffers_.Add();
}
inline ::xla::LogicalBufferProto* BufferAssignmentProto::add_logical_buffers() {
  ::xla::LogicalBufferProto* _add = _internal_add_logical_buffers();
  // @@protoc_insertion_point(field_add:xla.BufferAssignmentProto.logical_buffers)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LogicalBufferProto >&
BufferAssignmentProto::logical_buffers() const {
  // @@protoc_insertion_point(field_list:xla.BufferAssignmentProto.logical_buffers)
  return _impl_.logical_buffers_;
}

// repeated .xla.BufferAssignmentProto.BufferAlias buffer_aliases = 2;
inline int BufferAssignmentProto::_internal_buffer_aliases_size() const {
  return _impl_.buffer_aliases_.size();
}
inline int BufferAssignmentProto::buffer_aliases_size() const {
  return _internal_buffer_aliases_size();
}
inline void BufferAssignmentProto::clear_buffer_aliases() {
  _impl_.buffer_aliases_.Clear();
}
inline ::xla::BufferAssignmentProto_BufferAlias* BufferAssignmentProto::mutable_buffer_aliases(int index) {
  // @@protoc_insertion_point(field_mutable:xla.BufferAssignmentProto.buffer_aliases)
  return _impl_.buffer_aliases_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::BufferAssignmentProto_BufferAlias >*
BufferAssignmentProto::mutable_buffer_aliases() {
  // @@protoc_insertion_point(field_mutable_list:xla.BufferAssignmentProto.buffer_aliases)
  return &_impl_.buffer_aliases_;
}
inline const ::xla::BufferAssignmentProto_BufferAlias& BufferAssignmentProto::_internal_buffer_aliases(int index) const {
  return _impl_.buffer_aliases_.Get(index);
}
inline const ::xla::BufferAssignmentProto_BufferAlias& BufferAssignmentProto::buffer_aliases(int index) const {
  // @@protoc_insertion_point(field_get:xla.BufferAssignmentProto.buffer_aliases)
  return _internal_buffer_aliases(index);
}
inline ::xla::BufferAssignmentProto_BufferAlias* BufferAssignmentProto::_internal_add_buffer_aliases() {
  return _impl_.buffer_aliases_.Add();
}
inline ::xla::BufferAssignmentProto_BufferAlias* BufferAssignmentProto::add_buffer_aliases() {
  ::xla::BufferAssignmentProto_BufferAlias* _add = _internal_add_buffer_aliases();
  // @@protoc_insertion_point(field_add:xla.BufferAssignmentProto.buffer_aliases)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::BufferAssignmentProto_BufferAlias >&
BufferAssignmentProto::buffer_aliases() const {
  // @@protoc_insertion_point(field_list:xla.BufferAssignmentProto.buffer_aliases)
  return _impl_.buffer_aliases_;
}

// repeated .xla.BufferAllocationProto buffer_allocations = 3;
inline int BufferAssignmentProto::_internal_buffer_allocations_size() const {
  return _impl_.buffer_allocations_.size();
}
inline int BufferAssignmentProto::buffer_allocations_size() const {
  return _internal_buffer_allocations_size();
}
inline void BufferAssignmentProto::clear_buffer_allocations() {
  _impl_.buffer_allocations_.Clear();
}
inline ::xla::BufferAllocationProto* BufferAssignmentProto::mutable_buffer_allocations(int index) {
  // @@protoc_insertion_point(field_mutable:xla.BufferAssignmentProto.buffer_allocations)
  return _impl_.buffer_allocations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::BufferAllocationProto >*
BufferAssignmentProto::mutable_buffer_allocations() {
  // @@protoc_insertion_point(field_mutable_list:xla.BufferAssignmentProto.buffer_allocations)
  return &_impl_.buffer_allocations_;
}
inline const ::xla::BufferAllocationProto& BufferAssignmentProto::_internal_buffer_allocations(int index) const {
  return _impl_.buffer_allocations_.Get(index);
}
inline const ::xla::BufferAllocationProto& BufferAssignmentProto::buffer_allocations(int index) const {
  // @@protoc_insertion_point(field_get:xla.BufferAssignmentProto.buffer_allocations)
  return _internal_buffer_allocations(index);
}
inline ::xla::BufferAllocationProto* BufferAssignmentProto::_internal_add_buffer_allocations() {
  return _impl_.buffer_allocations_.Add();
}
inline ::xla::BufferAllocationProto* BufferAssignmentProto::add_buffer_allocations() {
  ::xla::BufferAllocationProto* _add = _internal_add_buffer_allocations();
  // @@protoc_insertion_point(field_add:xla.BufferAssignmentProto.buffer_allocations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::BufferAllocationProto >&
BufferAssignmentProto::buffer_allocations() const {
  // @@protoc_insertion_point(field_list:xla.BufferAssignmentProto.buffer_allocations)
  return _impl_.buffer_allocations_;
}

// repeated .xla.HeapSimulatorTrace heap_simulator_traces = 4;
inline int BufferAssignmentProto::_internal_heap_simulator_traces_size() const {
  return _impl_.heap_simulator_traces_.size();
}
inline int BufferAssignmentProto::heap_simulator_traces_size() const {
  return _internal_heap_simulator_traces_size();
}
inline void BufferAssignmentProto::clear_heap_simulator_traces() {
  _impl_.heap_simulator_traces_.Clear();
}
inline ::xla::HeapSimulatorTrace* BufferAssignmentProto::mutable_heap_simulator_traces(int index) {
  // @@protoc_insertion_point(field_mutable:xla.BufferAssignmentProto.heap_simulator_traces)
  return _impl_.heap_simulator_traces_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HeapSimulatorTrace >*
BufferAssignmentProto::mutable_heap_simulator_traces() {
  // @@protoc_insertion_point(field_mutable_list:xla.BufferAssignmentProto.heap_simulator_traces)
  return &_impl_.heap_simulator_traces_;
}
inline const ::xla::HeapSimulatorTrace& BufferAssignmentProto::_internal_heap_simulator_traces(int index) const {
  return _impl_.heap_simulator_traces_.Get(index);
}
inline const ::xla::HeapSimulatorTrace& BufferAssignmentProto::heap_simulator_traces(int index) const {
  // @@protoc_insertion_point(field_get:xla.BufferAssignmentProto.heap_simulator_traces)
  return _internal_heap_simulator_traces(index);
}
inline ::xla::HeapSimulatorTrace* BufferAssignmentProto::_internal_add_heap_simulator_traces() {
  return _impl_.heap_simulator_traces_.Add();
}
inline ::xla::HeapSimulatorTrace* BufferAssignmentProto::add_heap_simulator_traces() {
  ::xla::HeapSimulatorTrace* _add = _internal_add_heap_simulator_traces();
  // @@protoc_insertion_point(field_add:xla.BufferAssignmentProto.heap_simulator_traces)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HeapSimulatorTrace >&
BufferAssignmentProto::heap_simulator_traces() const {
  // @@protoc_insertion_point(field_list:xla.BufferAssignmentProto.heap_simulator_traces)
  return _impl_.heap_simulator_traces_;
}

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

// HloProto

// .xla.HloModuleProto hlo_module = 1;
inline bool HloProto::_internal_has_hlo_module() const {
  return this != internal_default_instance() && _impl_.hlo_module_ != nullptr;
}
inline bool HloProto::has_hlo_module() const {
  return _internal_has_hlo_module();
}
inline void HloProto::clear_hlo_module() {
  if (GetArenaForAllocation() == nullptr && _impl_.hlo_module_ != nullptr) {
    delete _impl_.hlo_module_;
  }
  _impl_.hlo_module_ = nullptr;
}
inline const ::xla::HloModuleProto& HloProto::_internal_hlo_module() const {
  const ::xla::HloModuleProto* p = _impl_.hlo_module_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::HloModuleProto&>(
      ::xla::_HloModuleProto_default_instance_);
}
inline const ::xla::HloModuleProto& HloProto::hlo_module() const {
  // @@protoc_insertion_point(field_get:xla.HloProto.hlo_module)
  return _internal_hlo_module();
}
inline void HloProto::unsafe_arena_set_allocated_hlo_module(
    ::xla::HloModuleProto* hlo_module) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hlo_module_);
  }
  _impl_.hlo_module_ = hlo_module;
  if (hlo_module) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloProto.hlo_module)
}
inline ::xla::HloModuleProto* HloProto::release_hlo_module() {
  
  ::xla::HloModuleProto* temp = _impl_.hlo_module_;
  _impl_.hlo_module_ = 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 ::xla::HloModuleProto* HloProto::unsafe_arena_release_hlo_module() {
  // @@protoc_insertion_point(field_release:xla.HloProto.hlo_module)
  
  ::xla::HloModuleProto* temp = _impl_.hlo_module_;
  _impl_.hlo_module_ = nullptr;
  return temp;
}
inline ::xla::HloModuleProto* HloProto::_internal_mutable_hlo_module() {
  
  if (_impl_.hlo_module_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::HloModuleProto>(GetArenaForAllocation());
    _impl_.hlo_module_ = p;
  }
  return _impl_.hlo_module_;
}
inline ::xla::HloModuleProto* HloProto::mutable_hlo_module() {
  ::xla::HloModuleProto* _msg = _internal_mutable_hlo_module();
  // @@protoc_insertion_point(field_mutable:xla.HloProto.hlo_module)
  return _msg;
}
inline void HloProto::set_allocated_hlo_module(::xla::HloModuleProto* hlo_module) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.hlo_module_;
  }
  if (hlo_module) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hlo_module);
    if (message_arena != submessage_arena) {
      hlo_module = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hlo_module, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.hlo_module_ = hlo_module;
  // @@protoc_insertion_point(field_set_allocated:xla.HloProto.hlo_module)
}

// .xla.BufferAssignmentProto buffer_assignment = 3;
inline bool HloProto::_internal_has_buffer_assignment() const {
  return this != internal_default_instance() && _impl_.buffer_assignment_ != nullptr;
}
inline bool HloProto::has_buffer_assignment() const {
  return _internal_has_buffer_assignment();
}
inline void HloProto::clear_buffer_assignment() {
  if (GetArenaForAllocation() == nullptr && _impl_.buffer_assignment_ != nullptr) {
    delete _impl_.buffer_assignment_;
  }
  _impl_.buffer_assignment_ = nullptr;
}
inline const ::xla::BufferAssignmentProto& HloProto::_internal_buffer_assignment() const {
  const ::xla::BufferAssignmentProto* p = _impl_.buffer_assignment_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::BufferAssignmentProto&>(
      ::xla::_BufferAssignmentProto_default_instance_);
}
inline const ::xla::BufferAssignmentProto& HloProto::buffer_assignment() const {
  // @@protoc_insertion_point(field_get:xla.HloProto.buffer_assignment)
  return _internal_buffer_assignment();
}
inline void HloProto::unsafe_arena_set_allocated_buffer_assignment(
    ::xla::BufferAssignmentProto* buffer_assignment) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.buffer_assignment_);
  }
  _impl_.buffer_assignment_ = buffer_assignment;
  if (buffer_assignment) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloProto.buffer_assignment)
}
inline ::xla::BufferAssignmentProto* HloProto::release_buffer_assignment() {
  
  ::xla::BufferAssignmentProto* temp = _impl_.buffer_assignment_;
  _impl_.buffer_assignment_ = 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 ::xla::BufferAssignmentProto* HloProto::unsafe_arena_release_buffer_assignment() {
  // @@protoc_insertion_point(field_release:xla.HloProto.buffer_assignment)
  
  ::xla::BufferAssignmentProto* temp = _impl_.buffer_assignment_;
  _impl_.buffer_assignment_ = nullptr;
  return temp;
}
inline ::xla::BufferAssignmentProto* HloProto::_internal_mutable_buffer_assignment() {
  
  if (_impl_.buffer_assignment_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::BufferAssignmentProto>(GetArenaForAllocation());
    _impl_.buffer_assignment_ = p;
  }
  return _impl_.buffer_assignment_;
}
inline ::xla::BufferAssignmentProto* HloProto::mutable_buffer_assignment() {
  ::xla::BufferAssignmentProto* _msg = _internal_mutable_buffer_assignment();
  // @@protoc_insertion_point(field_mutable:xla.HloProto.buffer_assignment)
  return _msg;
}
inline void HloProto::set_allocated_buffer_assignment(::xla::BufferAssignmentProto* buffer_assignment) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.buffer_assignment_;
  }
  if (buffer_assignment) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(buffer_assignment);
    if (message_arena != submessage_arena) {
      buffer_assignment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, buffer_assignment, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.buffer_assignment_ = buffer_assignment;
  // @@protoc_insertion_point(field_set_allocated:xla.HloProto.buffer_assignment)
}

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

// HloSnapshot

// .xla.HloProto hlo = 1;
inline bool HloSnapshot::_internal_has_hlo() const {
  return this != internal_default_instance() && _impl_.hlo_ != nullptr;
}
inline bool HloSnapshot::has_hlo() const {
  return _internal_has_hlo();
}
inline void HloSnapshot::clear_hlo() {
  if (GetArenaForAllocation() == nullptr && _impl_.hlo_ != nullptr) {
    delete _impl_.hlo_;
  }
  _impl_.hlo_ = nullptr;
}
inline const ::xla::HloProto& HloSnapshot::_internal_hlo() const {
  const ::xla::HloProto* p = _impl_.hlo_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::HloProto&>(
      ::xla::_HloProto_default_instance_);
}
inline const ::xla::HloProto& HloSnapshot::hlo() const {
  // @@protoc_insertion_point(field_get:xla.HloSnapshot.hlo)
  return _internal_hlo();
}
inline void HloSnapshot::unsafe_arena_set_allocated_hlo(
    ::xla::HloProto* hlo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hlo_);
  }
  _impl_.hlo_ = hlo;
  if (hlo) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloSnapshot.hlo)
}
inline ::xla::HloProto* HloSnapshot::release_hlo() {
  
  ::xla::HloProto* temp = _impl_.hlo_;
  _impl_.hlo_ = 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 ::xla::HloProto* HloSnapshot::unsafe_arena_release_hlo() {
  // @@protoc_insertion_point(field_release:xla.HloSnapshot.hlo)
  
  ::xla::HloProto* temp = _impl_.hlo_;
  _impl_.hlo_ = nullptr;
  return temp;
}
inline ::xla::HloProto* HloSnapshot::_internal_mutable_hlo() {
  
  if (_impl_.hlo_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::HloProto>(GetArenaForAllocation());
    _impl_.hlo_ = p;
  }
  return _impl_.hlo_;
}
inline ::xla::HloProto* HloSnapshot::mutable_hlo() {
  ::xla::HloProto* _msg = _internal_mutable_hlo();
  // @@protoc_insertion_point(field_mutable:xla.HloSnapshot.hlo)
  return _msg;
}
inline void HloSnapshot::set_allocated_hlo(::xla::HloProto* hlo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.hlo_;
  }
  if (hlo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hlo);
    if (message_arena != submessage_arena) {
      hlo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hlo, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.hlo_ = hlo;
  // @@protoc_insertion_point(field_set_allocated:xla.HloSnapshot.hlo)
}

// repeated .xla.LiteralProto arguments = 2;
inline int HloSnapshot::_internal_arguments_size() const {
  return _impl_.arguments_.size();
}
inline int HloSnapshot::arguments_size() const {
  return _internal_arguments_size();
}
inline ::xla::LiteralProto* HloSnapshot::mutable_arguments(int index) {
  // @@protoc_insertion_point(field_mutable:xla.HloSnapshot.arguments)
  return _impl_.arguments_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LiteralProto >*
HloSnapshot::mutable_arguments() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloSnapshot.arguments)
  return &_impl_.arguments_;
}
inline const ::xla::LiteralProto& HloSnapshot::_internal_arguments(int index) const {
  return _impl_.arguments_.Get(index);
}
inline const ::xla::LiteralProto& HloSnapshot::arguments(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloSnapshot.arguments)
  return _internal_arguments(index);
}
inline ::xla::LiteralProto* HloSnapshot::_internal_add_arguments() {
  return _impl_.arguments_.Add();
}
inline ::xla::LiteralProto* HloSnapshot::add_arguments() {
  ::xla::LiteralProto* _add = _internal_add_arguments();
  // @@protoc_insertion_point(field_add:xla.HloSnapshot.arguments)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::LiteralProto >&
HloSnapshot::arguments() const {
  // @@protoc_insertion_point(field_list:xla.HloSnapshot.arguments)
  return _impl_.arguments_;
}

// .xla.LiteralProto result = 3;
inline bool HloSnapshot::_internal_has_result() const {
  return this != internal_default_instance() && _impl_.result_ != nullptr;
}
inline bool HloSnapshot::has_result() const {
  return _internal_has_result();
}
inline const ::xla::LiteralProto& HloSnapshot::_internal_result() const {
  const ::xla::LiteralProto* p = _impl_.result_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::LiteralProto&>(
      ::xla::_LiteralProto_default_instance_);
}
inline const ::xla::LiteralProto& HloSnapshot::result() const {
  // @@protoc_insertion_point(field_get:xla.HloSnapshot.result)
  return _internal_result();
}
inline void HloSnapshot::unsafe_arena_set_allocated_result(
    ::xla::LiteralProto* result) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.result_);
  }
  _impl_.result_ = result;
  if (result) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloSnapshot.result)
}
inline ::xla::LiteralProto* HloSnapshot::release_result() {
  
  ::xla::LiteralProto* temp = _impl_.result_;
  _impl_.result_ = 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 ::xla::LiteralProto* HloSnapshot::unsafe_arena_release_result() {
  // @@protoc_insertion_point(field_release:xla.HloSnapshot.result)
  
  ::xla::LiteralProto* temp = _impl_.result_;
  _impl_.result_ = nullptr;
  return temp;
}
inline ::xla::LiteralProto* HloSnapshot::_internal_mutable_result() {
  
  if (_impl_.result_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::LiteralProto>(GetArenaForAllocation());
    _impl_.result_ = p;
  }
  return _impl_.result_;
}
inline ::xla::LiteralProto* HloSnapshot::mutable_result() {
  ::xla::LiteralProto* _msg = _internal_mutable_result();
  // @@protoc_insertion_point(field_mutable:xla.HloSnapshot.result)
  return _msg;
}
inline void HloSnapshot::set_allocated_result(::xla::LiteralProto* result) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.result_);
  }
  if (result) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(result));
    if (message_arena != submessage_arena) {
      result = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, result, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.result_ = result;
  // @@protoc_insertion_point(field_set_allocated:xla.HloSnapshot.result)
}

// string execution_platform = 4;
inline void HloSnapshot::clear_execution_platform() {
  _impl_.execution_platform_.ClearToEmpty();
}
inline const std::string& HloSnapshot::execution_platform() const {
  // @@protoc_insertion_point(field_get:xla.HloSnapshot.execution_platform)
  return _internal_execution_platform();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloSnapshot::set_execution_platform(ArgT0&& arg0, ArgT... args) {
 
 _impl_.execution_platform_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloSnapshot.execution_platform)
}
inline std::string* HloSnapshot::mutable_execution_platform() {
  std::string* _s = _internal_mutable_execution_platform();
  // @@protoc_insertion_point(field_mutable:xla.HloSnapshot.execution_platform)
  return _s;
}
inline const std::string& HloSnapshot::_internal_execution_platform() const {
  return _impl_.execution_platform_.Get();
}
inline void HloSnapshot::_internal_set_execution_platform(const std::string& value) {
  
  _impl_.execution_platform_.Set(value, GetArenaForAllocation());
}
inline std::string* HloSnapshot::_internal_mutable_execution_platform() {
  
  return _impl_.execution_platform_.Mutable(GetArenaForAllocation());
}
inline std::string* HloSnapshot::release_execution_platform() {
  // @@protoc_insertion_point(field_release:xla.HloSnapshot.execution_platform)
  return _impl_.execution_platform_.Release();
}
inline void HloSnapshot::set_allocated_execution_platform(std::string* execution_platform) {
  if (execution_platform != nullptr) {
    
  } else {
    
  }
  _impl_.execution_platform_.SetAllocated(execution_platform, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.execution_platform_.IsDefault()) {
    _impl_.execution_platform_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloSnapshot.execution_platform)
}

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

// HloModuleMetadataProto

// int64 canonical_module_id = 1;
inline void HloModuleMetadataProto::clear_canonical_module_id() {
  _impl_.canonical_module_id_ = int64_t{0};
}
inline int64_t HloModuleMetadataProto::_internal_canonical_module_id() const {
  return _impl_.canonical_module_id_;
}
inline int64_t HloModuleMetadataProto::canonical_module_id() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleMetadataProto.canonical_module_id)
  return _internal_canonical_module_id();
}
inline void HloModuleMetadataProto::_internal_set_canonical_module_id(int64_t value) {
  
  _impl_.canonical_module_id_ = value;
}
inline void HloModuleMetadataProto::set_canonical_module_id(int64_t value) {
  _internal_set_canonical_module_id(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleMetadataProto.canonical_module_id)
}

// string module_group_name = 2;
inline void HloModuleMetadataProto::clear_module_group_name() {
  _impl_.module_group_name_.ClearToEmpty();
}
inline const std::string& HloModuleMetadataProto::module_group_name() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleMetadataProto.module_group_name)
  return _internal_module_group_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloModuleMetadataProto::set_module_group_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.module_group_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloModuleMetadataProto.module_group_name)
}
inline std::string* HloModuleMetadataProto::mutable_module_group_name() {
  std::string* _s = _internal_mutable_module_group_name();
  // @@protoc_insertion_point(field_mutable:xla.HloModuleMetadataProto.module_group_name)
  return _s;
}
inline const std::string& HloModuleMetadataProto::_internal_module_group_name() const {
  return _impl_.module_group_name_.Get();
}
inline void HloModuleMetadataProto::_internal_set_module_group_name(const std::string& value) {
  
  _impl_.module_group_name_.Set(value, GetArenaForAllocation());
}
inline std::string* HloModuleMetadataProto::_internal_mutable_module_group_name() {
  
  return _impl_.module_group_name_.Mutable(GetArenaForAllocation());
}
inline std::string* HloModuleMetadataProto::release_module_group_name() {
  // @@protoc_insertion_point(field_release:xla.HloModuleMetadataProto.module_group_name)
  return _impl_.module_group_name_.Release();
}
inline void HloModuleMetadataProto::set_allocated_module_group_name(std::string* module_group_name) {
  if (module_group_name != nullptr) {
    
  } else {
    
  }
  _impl_.module_group_name_.SetAllocated(module_group_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.module_group_name_.IsDefault()) {
    _impl_.module_group_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloModuleMetadataProto.module_group_name)
}

// int64 original_module_id = 3;
inline void HloModuleMetadataProto::clear_original_module_id() {
  _impl_.original_module_id_ = int64_t{0};
}
inline int64_t HloModuleMetadataProto::_internal_original_module_id() const {
  return _impl_.original_module_id_;
}
inline int64_t HloModuleMetadataProto::original_module_id() const {
  // @@protoc_insertion_point(field_get:xla.HloModuleMetadataProto.original_module_id)
  return _internal_original_module_id();
}
inline void HloModuleMetadataProto::_internal_set_original_module_id(int64_t value) {
  
  _impl_.original_module_id_ = value;
}
inline void HloModuleMetadataProto::set_original_module_id(int64_t value) {
  _internal_set_original_module_id(value);
  // @@protoc_insertion_point(field_set:xla.HloModuleMetadataProto.original_module_id)
}

// repeated int64 partitioned_module_ids = 4;
inline int HloModuleMetadataProto::_internal_partitioned_module_ids_size() const {
  return _impl_.partitioned_module_ids_.size();
}
inline int HloModuleMetadataProto::partitioned_module_ids_size() const {
  return _internal_partitioned_module_ids_size();
}
inline void HloModuleMetadataProto::clear_partitioned_module_ids() {
  _impl_.partitioned_module_ids_.Clear();
}
inline int64_t HloModuleMetadataProto::_internal_partitioned_module_ids(int index) const {
  return _impl_.partitioned_module_ids_.Get(index);
}
inline int64_t HloModuleMetadataProto::partitioned_module_ids(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloModuleMetadataProto.partitioned_module_ids)
  return _internal_partitioned_module_ids(index);
}
inline void HloModuleMetadataProto::set_partitioned_module_ids(int index, int64_t value) {
  _impl_.partitioned_module_ids_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloModuleMetadataProto.partitioned_module_ids)
}
inline void HloModuleMetadataProto::_internal_add_partitioned_module_ids(int64_t value) {
  _impl_.partitioned_module_ids_.Add(value);
}
inline void HloModuleMetadataProto::add_partitioned_module_ids(int64_t value) {
  _internal_add_partitioned_module_ids(value);
  // @@protoc_insertion_point(field_add:xla.HloModuleMetadataProto.partitioned_module_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloModuleMetadataProto::_internal_partitioned_module_ids() const {
  return _impl_.partitioned_module_ids_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloModuleMetadataProto::partitioned_module_ids() const {
  // @@protoc_insertion_point(field_list:xla.HloModuleMetadataProto.partitioned_module_ids)
  return _internal_partitioned_module_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloModuleMetadataProto::_internal_mutable_partitioned_module_ids() {
  return &_impl_.partitioned_module_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloModuleMetadataProto::mutable_partitioned_module_ids() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleMetadataProto.partitioned_module_ids)
  return _internal_mutable_partitioned_module_ids();
}

// repeated .xla.HloPassMetadata pass_metadata = 5;
inline int HloModuleMetadataProto::_internal_pass_metadata_size() const {
  return _impl_.pass_metadata_.size();
}
inline int HloModuleMetadataProto::pass_metadata_size() const {
  return _internal_pass_metadata_size();
}
inline void HloModuleMetadataProto::clear_pass_metadata() {
  _impl_.pass_metadata_.Clear();
}
inline ::xla::HloPassMetadata* HloModuleMetadataProto::mutable_pass_metadata(int index) {
  // @@protoc_insertion_point(field_mutable:xla.HloModuleMetadataProto.pass_metadata)
  return _impl_.pass_metadata_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloPassMetadata >*
HloModuleMetadataProto::mutable_pass_metadata() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloModuleMetadataProto.pass_metadata)
  return &_impl_.pass_metadata_;
}
inline const ::xla::HloPassMetadata& HloModuleMetadataProto::_internal_pass_metadata(int index) const {
  return _impl_.pass_metadata_.Get(index);
}
inline const ::xla::HloPassMetadata& HloModuleMetadataProto::pass_metadata(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloModuleMetadataProto.pass_metadata)
  return _internal_pass_metadata(index);
}
inline ::xla::HloPassMetadata* HloModuleMetadataProto::_internal_add_pass_metadata() {
  return _impl_.pass_metadata_.Add();
}
inline ::xla::HloPassMetadata* HloModuleMetadataProto::add_pass_metadata() {
  ::xla::HloPassMetadata* _add = _internal_add_pass_metadata();
  // @@protoc_insertion_point(field_add:xla.HloModuleMetadataProto.pass_metadata)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloPassMetadata >&
HloModuleMetadataProto::pass_metadata() const {
  // @@protoc_insertion_point(field_list:xla.HloModuleMetadataProto.pass_metadata)
  return _impl_.pass_metadata_;
}

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

// HloPassMetadata

// int64 pass_id = 1;
inline void HloPassMetadata::clear_pass_id() {
  _impl_.pass_id_ = int64_t{0};
}
inline int64_t HloPassMetadata::_internal_pass_id() const {
  return _impl_.pass_id_;
}
inline int64_t HloPassMetadata::pass_id() const {
  // @@protoc_insertion_point(field_get:xla.HloPassMetadata.pass_id)
  return _internal_pass_id();
}
inline void HloPassMetadata::_internal_set_pass_id(int64_t value) {
  
  _impl_.pass_id_ = value;
}
inline void HloPassMetadata::set_pass_id(int64_t value) {
  _internal_set_pass_id(value);
  // @@protoc_insertion_point(field_set:xla.HloPassMetadata.pass_id)
}

// string pass_name = 2;
inline void HloPassMetadata::clear_pass_name() {
  _impl_.pass_name_.ClearToEmpty();
}
inline const std::string& HloPassMetadata::pass_name() const {
  // @@protoc_insertion_point(field_get:xla.HloPassMetadata.pass_name)
  return _internal_pass_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloPassMetadata::set_pass_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.pass_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloPassMetadata.pass_name)
}
inline std::string* HloPassMetadata::mutable_pass_name() {
  std::string* _s = _internal_mutable_pass_name();
  // @@protoc_insertion_point(field_mutable:xla.HloPassMetadata.pass_name)
  return _s;
}
inline const std::string& HloPassMetadata::_internal_pass_name() const {
  return _impl_.pass_name_.Get();
}
inline void HloPassMetadata::_internal_set_pass_name(const std::string& value) {
  
  _impl_.pass_name_.Set(value, GetArenaForAllocation());
}
inline std::string* HloPassMetadata::_internal_mutable_pass_name() {
  
  return _impl_.pass_name_.Mutable(GetArenaForAllocation());
}
inline std::string* HloPassMetadata::release_pass_name() {
  // @@protoc_insertion_point(field_release:xla.HloPassMetadata.pass_name)
  return _impl_.pass_name_.Release();
}
inline void HloPassMetadata::set_allocated_pass_name(std::string* pass_name) {
  if (pass_name != nullptr) {
    
  } else {
    
  }
  _impl_.pass_name_.SetAllocated(pass_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pass_name_.IsDefault()) {
    _impl_.pass_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloPassMetadata.pass_name)
}

// string pipeline_name = 3;
inline void HloPassMetadata::clear_pipeline_name() {
  _impl_.pipeline_name_.ClearToEmpty();
}
inline const std::string& HloPassMetadata::pipeline_name() const {
  // @@protoc_insertion_point(field_get:xla.HloPassMetadata.pipeline_name)
  return _internal_pipeline_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HloPassMetadata::set_pipeline_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.pipeline_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.HloPassMetadata.pipeline_name)
}
inline std::string* HloPassMetadata::mutable_pipeline_name() {
  std::string* _s = _internal_mutable_pipeline_name();
  // @@protoc_insertion_point(field_mutable:xla.HloPassMetadata.pipeline_name)
  return _s;
}
inline const std::string& HloPassMetadata::_internal_pipeline_name() const {
  return _impl_.pipeline_name_.Get();
}
inline void HloPassMetadata::_internal_set_pipeline_name(const std::string& value) {
  
  _impl_.pipeline_name_.Set(value, GetArenaForAllocation());
}
inline std::string* HloPassMetadata::_internal_mutable_pipeline_name() {
  
  return _impl_.pipeline_name_.Mutable(GetArenaForAllocation());
}
inline std::string* HloPassMetadata::release_pipeline_name() {
  // @@protoc_insertion_point(field_release:xla.HloPassMetadata.pipeline_name)
  return _impl_.pipeline_name_.Release();
}
inline void HloPassMetadata::set_allocated_pipeline_name(std::string* pipeline_name) {
  if (pipeline_name != nullptr) {
    
  } else {
    
  }
  _impl_.pipeline_name_.SetAllocated(pipeline_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pipeline_name_.IsDefault()) {
    _impl_.pipeline_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.HloPassMetadata.pipeline_name)
}

// repeated string dump_filenames = 4;
inline int HloPassMetadata::_internal_dump_filenames_size() const {
  return _impl_.dump_filenames_.size();
}
inline int HloPassMetadata::dump_filenames_size() const {
  return _internal_dump_filenames_size();
}
inline void HloPassMetadata::clear_dump_filenames() {
  _impl_.dump_filenames_.Clear();
}
inline std::string* HloPassMetadata::add_dump_filenames() {
  std::string* _s = _internal_add_dump_filenames();
  // @@protoc_insertion_point(field_add_mutable:xla.HloPassMetadata.dump_filenames)
  return _s;
}
inline const std::string& HloPassMetadata::_internal_dump_filenames(int index) const {
  return _impl_.dump_filenames_.Get(index);
}
inline const std::string& HloPassMetadata::dump_filenames(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloPassMetadata.dump_filenames)
  return _internal_dump_filenames(index);
}
inline std::string* HloPassMetadata::mutable_dump_filenames(int index) {
  // @@protoc_insertion_point(field_mutable:xla.HloPassMetadata.dump_filenames)
  return _impl_.dump_filenames_.Mutable(index);
}
inline void HloPassMetadata::set_dump_filenames(int index, const std::string& value) {
  _impl_.dump_filenames_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:xla.HloPassMetadata.dump_filenames)
}
inline void HloPassMetadata::set_dump_filenames(int index, std::string&& value) {
  _impl_.dump_filenames_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:xla.HloPassMetadata.dump_filenames)
}
inline void HloPassMetadata::set_dump_filenames(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.dump_filenames_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:xla.HloPassMetadata.dump_filenames)
}
inline void HloPassMetadata::set_dump_filenames(int index, const char* value, size_t size) {
  _impl_.dump_filenames_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:xla.HloPassMetadata.dump_filenames)
}
inline std::string* HloPassMetadata::_internal_add_dump_filenames() {
  return _impl_.dump_filenames_.Add();
}
inline void HloPassMetadata::add_dump_filenames(const std::string& value) {
  _impl_.dump_filenames_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:xla.HloPassMetadata.dump_filenames)
}
inline void HloPassMetadata::add_dump_filenames(std::string&& value) {
  _impl_.dump_filenames_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:xla.HloPassMetadata.dump_filenames)
}
inline void HloPassMetadata::add_dump_filenames(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.dump_filenames_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:xla.HloPassMetadata.dump_filenames)
}
inline void HloPassMetadata::add_dump_filenames(const char* value, size_t size) {
  _impl_.dump_filenames_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:xla.HloPassMetadata.dump_filenames)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
HloPassMetadata::dump_filenames() const {
  // @@protoc_insertion_point(field_list:xla.HloPassMetadata.dump_filenames)
  return _impl_.dump_filenames_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
HloPassMetadata::mutable_dump_filenames() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloPassMetadata.dump_filenames)
  return &_impl_.dump_filenames_;
}

// bool module_changed = 5;
inline void HloPassMetadata::clear_module_changed() {
  _impl_.module_changed_ = false;
}
inline bool HloPassMetadata::_internal_module_changed() const {
  return _impl_.module_changed_;
}
inline bool HloPassMetadata::module_changed() const {
  // @@protoc_insertion_point(field_get:xla.HloPassMetadata.module_changed)
  return _internal_module_changed();
}
inline void HloPassMetadata::_internal_set_module_changed(bool value) {
  
  _impl_.module_changed_ = value;
}
inline void HloPassMetadata::set_module_changed(bool value) {
  _internal_set_module_changed(value);
  // @@protoc_insertion_point(field_set:xla.HloPassMetadata.module_changed)
}

// int64 module_id = 6;
inline void HloPassMetadata::clear_module_id() {
  _impl_.module_id_ = int64_t{0};
}
inline int64_t HloPassMetadata::_internal_module_id() const {
  return _impl_.module_id_;
}
inline int64_t HloPassMetadata::module_id() const {
  // @@protoc_insertion_point(field_get:xla.HloPassMetadata.module_id)
  return _internal_module_id();
}
inline void HloPassMetadata::_internal_set_module_id(int64_t value) {
  
  _impl_.module_id_ = value;
}
inline void HloPassMetadata::set_module_id(int64_t value) {
  _internal_set_module_id(value);
  // @@protoc_insertion_point(field_set:xla.HloPassMetadata.module_id)
}

// repeated int64 module_group_module_ids = 7;
inline int HloPassMetadata::_internal_module_group_module_ids_size() const {
  return _impl_.module_group_module_ids_.size();
}
inline int HloPassMetadata::module_group_module_ids_size() const {
  return _internal_module_group_module_ids_size();
}
inline void HloPassMetadata::clear_module_group_module_ids() {
  _impl_.module_group_module_ids_.Clear();
}
inline int64_t HloPassMetadata::_internal_module_group_module_ids(int index) const {
  return _impl_.module_group_module_ids_.Get(index);
}
inline int64_t HloPassMetadata::module_group_module_ids(int index) const {
  // @@protoc_insertion_point(field_get:xla.HloPassMetadata.module_group_module_ids)
  return _internal_module_group_module_ids(index);
}
inline void HloPassMetadata::set_module_group_module_ids(int index, int64_t value) {
  _impl_.module_group_module_ids_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.HloPassMetadata.module_group_module_ids)
}
inline void HloPassMetadata::_internal_add_module_group_module_ids(int64_t value) {
  _impl_.module_group_module_ids_.Add(value);
}
inline void HloPassMetadata::add_module_group_module_ids(int64_t value) {
  _internal_add_module_group_module_ids(value);
  // @@protoc_insertion_point(field_add:xla.HloPassMetadata.module_group_module_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloPassMetadata::_internal_module_group_module_ids() const {
  return _impl_.module_group_module_ids_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
HloPassMetadata::module_group_module_ids() const {
  // @@protoc_insertion_point(field_list:xla.HloPassMetadata.module_group_module_ids)
  return _internal_module_group_module_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloPassMetadata::_internal_mutable_module_group_module_ids() {
  return &_impl_.module_group_module_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
HloPassMetadata::mutable_module_group_module_ids() {
  // @@protoc_insertion_point(field_mutable_list:xla.HloPassMetadata.module_group_module_ids)
  return _internal_mutable_module_group_module_ids();
}

// int64 start_timestamp_usec = 8;
inline void HloPassMetadata::clear_start_timestamp_usec() {
  _impl_.start_timestamp_usec_ = int64_t{0};
}
inline int64_t HloPassMetadata::_internal_start_timestamp_usec() const {
  return _impl_.start_timestamp_usec_;
}
inline int64_t HloPassMetadata::start_timestamp_usec() const {
  // @@protoc_insertion_point(field_get:xla.HloPassMetadata.start_timestamp_usec)
  return _internal_start_timestamp_usec();
}
inline void HloPassMetadata::_internal_set_start_timestamp_usec(int64_t value) {
  
  _impl_.start_timestamp_usec_ = value;
}
inline void HloPassMetadata::set_start_timestamp_usec(int64_t value) {
  _internal_set_start_timestamp_usec(value);
  // @@protoc_insertion_point(field_set:xla.HloPassMetadata.start_timestamp_usec)
}

// int64 end_timestamp_usec = 9;
inline void HloPassMetadata::clear_end_timestamp_usec() {
  _impl_.end_timestamp_usec_ = int64_t{0};
}
inline int64_t HloPassMetadata::_internal_end_timestamp_usec() const {
  return _impl_.end_timestamp_usec_;
}
inline int64_t HloPassMetadata::end_timestamp_usec() const {
  // @@protoc_insertion_point(field_get:xla.HloPassMetadata.end_timestamp_usec)
  return _internal_end_timestamp_usec();
}
inline void HloPassMetadata::_internal_set_end_timestamp_usec(int64_t value) {
  
  _impl_.end_timestamp_usec_ = value;
}
inline void HloPassMetadata::set_end_timestamp_usec(int64_t value) {
  _internal_set_end_timestamp_usec(value);
  // @@protoc_insertion_point(field_set:xla.HloPassMetadata.end_timestamp_usec)
}

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

// EntryFunctionAttributes_ShapeIndex

// repeated int64 indices = 1;
inline int EntryFunctionAttributes_ShapeIndex::_internal_indices_size() const {
  return _impl_.indices_.size();
}
inline int EntryFunctionAttributes_ShapeIndex::indices_size() const {
  return _internal_indices_size();
}
inline void EntryFunctionAttributes_ShapeIndex::clear_indices() {
  _impl_.indices_.Clear();
}
inline int64_t EntryFunctionAttributes_ShapeIndex::_internal_indices(int index) const {
  return _impl_.indices_.Get(index);
}
inline int64_t EntryFunctionAttributes_ShapeIndex::indices(int index) const {
  // @@protoc_insertion_point(field_get:xla.EntryFunctionAttributes.ShapeIndex.indices)
  return _internal_indices(index);
}
inline void EntryFunctionAttributes_ShapeIndex::set_indices(int index, int64_t value) {
  _impl_.indices_.Set(index, value);
  // @@protoc_insertion_point(field_set:xla.EntryFunctionAttributes.ShapeIndex.indices)
}
inline void EntryFunctionAttributes_ShapeIndex::_internal_add_indices(int64_t value) {
  _impl_.indices_.Add(value);
}
inline void EntryFunctionAttributes_ShapeIndex::add_indices(int64_t value) {
  _internal_add_indices(value);
  // @@protoc_insertion_point(field_add:xla.EntryFunctionAttributes.ShapeIndex.indices)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
EntryFunctionAttributes_ShapeIndex::_internal_indices() const {
  return _impl_.indices_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
EntryFunctionAttributes_ShapeIndex::indices() const {
  // @@protoc_insertion_point(field_list:xla.EntryFunctionAttributes.ShapeIndex.indices)
  return _internal_indices();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
EntryFunctionAttributes_ShapeIndex::_internal_mutable_indices() {
  return &_impl_.indices_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
EntryFunctionAttributes_ShapeIndex::mutable_indices() {
  // @@protoc_insertion_point(field_mutable_list:xla.EntryFunctionAttributes.ShapeIndex.indices)
  return _internal_mutable_indices();
}

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

// EntryFunctionAttributes_BufferParameterAttributes

// int64 lmhlo_params = 1;
inline void EntryFunctionAttributes_BufferParameterAttributes::clear_lmhlo_params() {
  _impl_.lmhlo_params_ = int64_t{0};
}
inline int64_t EntryFunctionAttributes_BufferParameterAttributes::_internal_lmhlo_params() const {
  return _impl_.lmhlo_params_;
}
inline int64_t EntryFunctionAttributes_BufferParameterAttributes::lmhlo_params() const {
  // @@protoc_insertion_point(field_get:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_params)
  return _internal_lmhlo_params();
}
inline void EntryFunctionAttributes_BufferParameterAttributes::_internal_set_lmhlo_params(int64_t value) {
  
  _impl_.lmhlo_params_ = value;
}
inline void EntryFunctionAttributes_BufferParameterAttributes::set_lmhlo_params(int64_t value) {
  _internal_set_lmhlo_params(value);
  // @@protoc_insertion_point(field_set:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_params)
}

// bool lmhlo_params_present = 6;
inline void EntryFunctionAttributes_BufferParameterAttributes::clear_lmhlo_params_present() {
  _impl_.lmhlo_params_present_ = false;
}
inline bool EntryFunctionAttributes_BufferParameterAttributes::_internal_lmhlo_params_present() const {
  return _impl_.lmhlo_params_present_;
}
inline bool EntryFunctionAttributes_BufferParameterAttributes::lmhlo_params_present() const {
  // @@protoc_insertion_point(field_get:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_params_present)
  return _internal_lmhlo_params_present();
}
inline void EntryFunctionAttributes_BufferParameterAttributes::_internal_set_lmhlo_params_present(bool value) {
  
  _impl_.lmhlo_params_present_ = value;
}
inline void EntryFunctionAttributes_BufferParameterAttributes::set_lmhlo_params_present(bool value) {
  _internal_set_lmhlo_params_present(value);
  // @@protoc_insertion_point(field_set:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_params_present)
}

// .xla.EntryFunctionAttributes.ShapeIndex lmhlo_param_shape_index = 2;
inline bool EntryFunctionAttributes_BufferParameterAttributes::_internal_has_lmhlo_param_shape_index() const {
  return this != internal_default_instance() && _impl_.lmhlo_param_shape_index_ != nullptr;
}
inline bool EntryFunctionAttributes_BufferParameterAttributes::has_lmhlo_param_shape_index() const {
  return _internal_has_lmhlo_param_shape_index();
}
inline void EntryFunctionAttributes_BufferParameterAttributes::clear_lmhlo_param_shape_index() {
  if (GetArenaForAllocation() == nullptr && _impl_.lmhlo_param_shape_index_ != nullptr) {
    delete _impl_.lmhlo_param_shape_index_;
  }
  _impl_.lmhlo_param_shape_index_ = nullptr;
}
inline const ::xla::EntryFunctionAttributes_ShapeIndex& EntryFunctionAttributes_BufferParameterAttributes::_internal_lmhlo_param_shape_index() const {
  const ::xla::EntryFunctionAttributes_ShapeIndex* p = _impl_.lmhlo_param_shape_index_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::EntryFunctionAttributes_ShapeIndex&>(
      ::xla::_EntryFunctionAttributes_ShapeIndex_default_instance_);
}
inline const ::xla::EntryFunctionAttributes_ShapeIndex& EntryFunctionAttributes_BufferParameterAttributes::lmhlo_param_shape_index() const {
  // @@protoc_insertion_point(field_get:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_param_shape_index)
  return _internal_lmhlo_param_shape_index();
}
inline void EntryFunctionAttributes_BufferParameterAttributes::unsafe_arena_set_allocated_lmhlo_param_shape_index(
    ::xla::EntryFunctionAttributes_ShapeIndex* lmhlo_param_shape_index) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.lmhlo_param_shape_index_);
  }
  _impl_.lmhlo_param_shape_index_ = lmhlo_param_shape_index;
  if (lmhlo_param_shape_index) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_param_shape_index)
}
inline ::xla::EntryFunctionAttributes_ShapeIndex* EntryFunctionAttributes_BufferParameterAttributes::release_lmhlo_param_shape_index() {
  
  ::xla::EntryFunctionAttributes_ShapeIndex* temp = _impl_.lmhlo_param_shape_index_;
  _impl_.lmhlo_param_shape_index_ = 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 ::xla::EntryFunctionAttributes_ShapeIndex* EntryFunctionAttributes_BufferParameterAttributes::unsafe_arena_release_lmhlo_param_shape_index() {
  // @@protoc_insertion_point(field_release:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_param_shape_index)
  
  ::xla::EntryFunctionAttributes_ShapeIndex* temp = _impl_.lmhlo_param_shape_index_;
  _impl_.lmhlo_param_shape_index_ = nullptr;
  return temp;
}
inline ::xla::EntryFunctionAttributes_ShapeIndex* EntryFunctionAttributes_BufferParameterAttributes::_internal_mutable_lmhlo_param_shape_index() {
  
  if (_impl_.lmhlo_param_shape_index_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::EntryFunctionAttributes_ShapeIndex>(GetArenaForAllocation());
    _impl_.lmhlo_param_shape_index_ = p;
  }
  return _impl_.lmhlo_param_shape_index_;
}
inline ::xla::EntryFunctionAttributes_ShapeIndex* EntryFunctionAttributes_BufferParameterAttributes::mutable_lmhlo_param_shape_index() {
  ::xla::EntryFunctionAttributes_ShapeIndex* _msg = _internal_mutable_lmhlo_param_shape_index();
  // @@protoc_insertion_point(field_mutable:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_param_shape_index)
  return _msg;
}
inline void EntryFunctionAttributes_BufferParameterAttributes::set_allocated_lmhlo_param_shape_index(::xla::EntryFunctionAttributes_ShapeIndex* lmhlo_param_shape_index) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.lmhlo_param_shape_index_;
  }
  if (lmhlo_param_shape_index) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(lmhlo_param_shape_index);
    if (message_arena != submessage_arena) {
      lmhlo_param_shape_index = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, lmhlo_param_shape_index, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.lmhlo_param_shape_index_ = lmhlo_param_shape_index;
  // @@protoc_insertion_point(field_set_allocated:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_param_shape_index)
}

// string lmhlo_constant_name = 3;
inline void EntryFunctionAttributes_BufferParameterAttributes::clear_lmhlo_constant_name() {
  _impl_.lmhlo_constant_name_.ClearToEmpty();
}
inline const std::string& EntryFunctionAttributes_BufferParameterAttributes::lmhlo_constant_name() const {
  // @@protoc_insertion_point(field_get:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_constant_name)
  return _internal_lmhlo_constant_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EntryFunctionAttributes_BufferParameterAttributes::set_lmhlo_constant_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.lmhlo_constant_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_constant_name)
}
inline std::string* EntryFunctionAttributes_BufferParameterAttributes::mutable_lmhlo_constant_name() {
  std::string* _s = _internal_mutable_lmhlo_constant_name();
  // @@protoc_insertion_point(field_mutable:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_constant_name)
  return _s;
}
inline const std::string& EntryFunctionAttributes_BufferParameterAttributes::_internal_lmhlo_constant_name() const {
  return _impl_.lmhlo_constant_name_.Get();
}
inline void EntryFunctionAttributes_BufferParameterAttributes::_internal_set_lmhlo_constant_name(const std::string& value) {
  
  _impl_.lmhlo_constant_name_.Set(value, GetArenaForAllocation());
}
inline std::string* EntryFunctionAttributes_BufferParameterAttributes::_internal_mutable_lmhlo_constant_name() {
  
  return _impl_.lmhlo_constant_name_.Mutable(GetArenaForAllocation());
}
inline std::string* EntryFunctionAttributes_BufferParameterAttributes::release_lmhlo_constant_name() {
  // @@protoc_insertion_point(field_release:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_constant_name)
  return _impl_.lmhlo_constant_name_.Release();
}
inline void EntryFunctionAttributes_BufferParameterAttributes::set_allocated_lmhlo_constant_name(std::string* lmhlo_constant_name) {
  if (lmhlo_constant_name != nullptr) {
    
  } else {
    
  }
  _impl_.lmhlo_constant_name_.SetAllocated(lmhlo_constant_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.lmhlo_constant_name_.IsDefault()) {
    _impl_.lmhlo_constant_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_constant_name)
}

// bool lmhlo_must_alias = 4;
inline void EntryFunctionAttributes_BufferParameterAttributes::clear_lmhlo_must_alias() {
  _impl_.lmhlo_must_alias_ = false;
}
inline bool EntryFunctionAttributes_BufferParameterAttributes::_internal_lmhlo_must_alias() const {
  return _impl_.lmhlo_must_alias_;
}
inline bool EntryFunctionAttributes_BufferParameterAttributes::lmhlo_must_alias() const {
  // @@protoc_insertion_point(field_get:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_must_alias)
  return _internal_lmhlo_must_alias();
}
inline void EntryFunctionAttributes_BufferParameterAttributes::_internal_set_lmhlo_must_alias(bool value) {
  
  _impl_.lmhlo_must_alias_ = value;
}
inline void EntryFunctionAttributes_BufferParameterAttributes::set_lmhlo_must_alias(bool value) {
  _internal_set_lmhlo_must_alias(value);
  // @@protoc_insertion_point(field_set:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_must_alias)
}

// .xla.EntryFunctionAttributes.ShapeIndex lmhlo_output_index = 5;
inline bool EntryFunctionAttributes_BufferParameterAttributes::_internal_has_lmhlo_output_index() const {
  return this != internal_default_instance() && _impl_.lmhlo_output_index_ != nullptr;
}
inline bool EntryFunctionAttributes_BufferParameterAttributes::has_lmhlo_output_index() const {
  return _internal_has_lmhlo_output_index();
}
inline void EntryFunctionAttributes_BufferParameterAttributes::clear_lmhlo_output_index() {
  if (GetArenaForAllocation() == nullptr && _impl_.lmhlo_output_index_ != nullptr) {
    delete _impl_.lmhlo_output_index_;
  }
  _impl_.lmhlo_output_index_ = nullptr;
}
inline const ::xla::EntryFunctionAttributes_ShapeIndex& EntryFunctionAttributes_BufferParameterAttributes::_internal_lmhlo_output_index() const {
  const ::xla::EntryFunctionAttributes_ShapeIndex* p = _impl_.lmhlo_output_index_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::EntryFunctionAttributes_ShapeIndex&>(
      ::xla::_EntryFunctionAttributes_ShapeIndex_default_instance_);
}
inline const ::xla::EntryFunctionAttributes_ShapeIndex& EntryFunctionAttributes_BufferParameterAttributes::lmhlo_output_index() const {
  // @@protoc_insertion_point(field_get:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_output_index)
  return _internal_lmhlo_output_index();
}
inline void EntryFunctionAttributes_BufferParameterAttributes::unsafe_arena_set_allocated_lmhlo_output_index(
    ::xla::EntryFunctionAttributes_ShapeIndex* lmhlo_output_index) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.lmhlo_output_index_);
  }
  _impl_.lmhlo_output_index_ = lmhlo_output_index;
  if (lmhlo_output_index) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_output_index)
}
inline ::xla::EntryFunctionAttributes_ShapeIndex* EntryFunctionAttributes_BufferParameterAttributes::release_lmhlo_output_index() {
  
  ::xla::EntryFunctionAttributes_ShapeIndex* temp = _impl_.lmhlo_output_index_;
  _impl_.lmhlo_output_index_ = 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 ::xla::EntryFunctionAttributes_ShapeIndex* EntryFunctionAttributes_BufferParameterAttributes::unsafe_arena_release_lmhlo_output_index() {
  // @@protoc_insertion_point(field_release:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_output_index)
  
  ::xla::EntryFunctionAttributes_ShapeIndex* temp = _impl_.lmhlo_output_index_;
  _impl_.lmhlo_output_index_ = nullptr;
  return temp;
}
inline ::xla::EntryFunctionAttributes_ShapeIndex* EntryFunctionAttributes_BufferParameterAttributes::_internal_mutable_lmhlo_output_index() {
  
  if (_impl_.lmhlo_output_index_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::EntryFunctionAttributes_ShapeIndex>(GetArenaForAllocation());
    _impl_.lmhlo_output_index_ = p;
  }
  return _impl_.lmhlo_output_index_;
}
inline ::xla::EntryFunctionAttributes_ShapeIndex* EntryFunctionAttributes_BufferParameterAttributes::mutable_lmhlo_output_index() {
  ::xla::EntryFunctionAttributes_ShapeIndex* _msg = _internal_mutable_lmhlo_output_index();
  // @@protoc_insertion_point(field_mutable:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_output_index)
  return _msg;
}
inline void EntryFunctionAttributes_BufferParameterAttributes::set_allocated_lmhlo_output_index(::xla::EntryFunctionAttributes_ShapeIndex* lmhlo_output_index) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.lmhlo_output_index_;
  }
  if (lmhlo_output_index) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(lmhlo_output_index);
    if (message_arena != submessage_arena) {
      lmhlo_output_index = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, lmhlo_output_index, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.lmhlo_output_index_ = lmhlo_output_index;
  // @@protoc_insertion_point(field_set_allocated:xla.EntryFunctionAttributes.BufferParameterAttributes.lmhlo_output_index)
}

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

// EntryFunctionAttributes

// repeated .xla.EntryFunctionAttributes.BufferParameterAttributes buffers = 1;
inline int EntryFunctionAttributes::_internal_buffers_size() const {
  return _impl_.buffers_.size();
}
inline int EntryFunctionAttributes::buffers_size() const {
  return _internal_buffers_size();
}
inline void EntryFunctionAttributes::clear_buffers() {
  _impl_.buffers_.Clear();
}
inline ::xla::EntryFunctionAttributes_BufferParameterAttributes* EntryFunctionAttributes::mutable_buffers(int index) {
  // @@protoc_insertion_point(field_mutable:xla.EntryFunctionAttributes.buffers)
  return _impl_.buffers_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::EntryFunctionAttributes_BufferParameterAttributes >*
EntryFunctionAttributes::mutable_buffers() {
  // @@protoc_insertion_point(field_mutable_list:xla.EntryFunctionAttributes.buffers)
  return &_impl_.buffers_;
}
inline const ::xla::EntryFunctionAttributes_BufferParameterAttributes& EntryFunctionAttributes::_internal_buffers(int index) const {
  return _impl_.buffers_.Get(index);
}
inline const ::xla::EntryFunctionAttributes_BufferParameterAttributes& EntryFunctionAttributes::buffers(int index) const {
  // @@protoc_insertion_point(field_get:xla.EntryFunctionAttributes.buffers)
  return _internal_buffers(index);
}
inline ::xla::EntryFunctionAttributes_BufferParameterAttributes* EntryFunctionAttributes::_internal_add_buffers() {
  return _impl_.buffers_.Add();
}
inline ::xla::EntryFunctionAttributes_BufferParameterAttributes* EntryFunctionAttributes::add_buffers() {
  ::xla::EntryFunctionAttributes_BufferParameterAttributes* _add = _internal_add_buffers();
  // @@protoc_insertion_point(field_add:xla.EntryFunctionAttributes.buffers)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::EntryFunctionAttributes_BufferParameterAttributes >&
EntryFunctionAttributes::buffers() const {
  // @@protoc_insertion_point(field_list:xla.EntryFunctionAttributes.buffers)
  return _impl_.buffers_;
}

// string result_xla_shape = 2;
inline void EntryFunctionAttributes::clear_result_xla_shape() {
  _impl_.result_xla_shape_.ClearToEmpty();
}
inline const std::string& EntryFunctionAttributes::result_xla_shape() const {
  // @@protoc_insertion_point(field_get:xla.EntryFunctionAttributes.result_xla_shape)
  return _internal_result_xla_shape();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EntryFunctionAttributes::set_result_xla_shape(ArgT0&& arg0, ArgT... args) {
 
 _impl_.result_xla_shape_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.EntryFunctionAttributes.result_xla_shape)
}
inline std::string* EntryFunctionAttributes::mutable_result_xla_shape() {
  std::string* _s = _internal_mutable_result_xla_shape();
  // @@protoc_insertion_point(field_mutable:xla.EntryFunctionAttributes.result_xla_shape)
  return _s;
}
inline const std::string& EntryFunctionAttributes::_internal_result_xla_shape() const {
  return _impl_.result_xla_shape_.Get();
}
inline void EntryFunctionAttributes::_internal_set_result_xla_shape(const std::string& value) {
  
  _impl_.result_xla_shape_.Set(value, GetArenaForAllocation());
}
inline std::string* EntryFunctionAttributes::_internal_mutable_result_xla_shape() {
  
  return _impl_.result_xla_shape_.Mutable(GetArenaForAllocation());
}
inline std::string* EntryFunctionAttributes::release_result_xla_shape() {
  // @@protoc_insertion_point(field_release:xla.EntryFunctionAttributes.result_xla_shape)
  return _impl_.result_xla_shape_.Release();
}
inline void EntryFunctionAttributes::set_allocated_result_xla_shape(std::string* result_xla_shape) {
  if (result_xla_shape != nullptr) {
    
  } else {
    
  }
  _impl_.result_xla_shape_.SetAllocated(result_xla_shape, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.result_xla_shape_.IsDefault()) {
    _impl_.result_xla_shape_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.EntryFunctionAttributes.result_xla_shape)
}

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

// XlaRuntimeExecutableProto

// .xla.HloModuleProto hlo_module_proto = 1;
inline bool XlaRuntimeExecutableProto::_internal_has_hlo_module_proto() const {
  return this != internal_default_instance() && _impl_.hlo_module_proto_ != nullptr;
}
inline bool XlaRuntimeExecutableProto::has_hlo_module_proto() const {
  return _internal_has_hlo_module_proto();
}
inline void XlaRuntimeExecutableProto::clear_hlo_module_proto() {
  if (GetArenaForAllocation() == nullptr && _impl_.hlo_module_proto_ != nullptr) {
    delete _impl_.hlo_module_proto_;
  }
  _impl_.hlo_module_proto_ = nullptr;
}
inline const ::xla::HloModuleProto& XlaRuntimeExecutableProto::_internal_hlo_module_proto() const {
  const ::xla::HloModuleProto* p = _impl_.hlo_module_proto_;
  return p != nullptr ? *p : reinterpret_cast<const ::xla::HloModuleProto&>(
      ::xla::_HloModuleProto_default_instance_);
}
inline const ::xla::HloModuleProto& XlaRuntimeExecutableProto::hlo_module_proto() const {
  // @@protoc_insertion_point(field_get:xla.XlaRuntimeExecutableProto.hlo_module_proto)
  return _internal_hlo_module_proto();
}
inline void XlaRuntimeExecutableProto::unsafe_arena_set_allocated_hlo_module_proto(
    ::xla::HloModuleProto* hlo_module_proto) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hlo_module_proto_);
  }
  _impl_.hlo_module_proto_ = hlo_module_proto;
  if (hlo_module_proto) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.XlaRuntimeExecutableProto.hlo_module_proto)
}
inline ::xla::HloModuleProto* XlaRuntimeExecutableProto::release_hlo_module_proto() {
  
  ::xla::HloModuleProto* temp = _impl_.hlo_module_proto_;
  _impl_.hlo_module_proto_ = 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 ::xla::HloModuleProto* XlaRuntimeExecutableProto::unsafe_arena_release_hlo_module_proto() {
  // @@protoc_insertion_point(field_release:xla.XlaRuntimeExecutableProto.hlo_module_proto)
  
  ::xla::HloModuleProto* temp = _impl_.hlo_module_proto_;
  _impl_.hlo_module_proto_ = nullptr;
  return temp;
}
inline ::xla::HloModuleProto* XlaRuntimeExecutableProto::_internal_mutable_hlo_module_proto() {
  
  if (_impl_.hlo_module_proto_ == nullptr) {
    auto* p = CreateMaybeMessage<::xla::HloModuleProto>(GetArenaForAllocation());
    _impl_.hlo_module_proto_ = p;
  }
  return _impl_.hlo_module_proto_;
}
inline ::xla::HloModuleProto* XlaRuntimeExecutableProto::mutable_hlo_module_proto() {
  ::xla::HloModuleProto* _msg = _internal_mutable_hlo_module_proto();
  // @@protoc_insertion_point(field_mutable:xla.XlaRuntimeExecutableProto.hlo_module_proto)
  return _msg;
}
inline void XlaRuntimeExecutableProto::set_allocated_hlo_module_proto(::xla::HloModuleProto* hlo_module_proto) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.hlo_module_proto_;
  }
  if (hlo_module_proto) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hlo_module_proto);
    if (message_arena != submessage_arena) {
      hlo_module_proto = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hlo_module_proto, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.hlo_module_proto_ = hlo_module_proto;
  // @@protoc_insertion_point(field_set_allocated:xla.XlaRuntimeExecutableProto.hlo_module_proto)
}

// bytes obj_file = 3;
inline void XlaRuntimeExecutableProto::clear_obj_file() {
  _impl_.obj_file_.ClearToEmpty();
}
inline const std::string& XlaRuntimeExecutableProto::obj_file() const {
  // @@protoc_insertion_point(field_get:xla.XlaRuntimeExecutableProto.obj_file)
  return _internal_obj_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void XlaRuntimeExecutableProto::set_obj_file(ArgT0&& arg0, ArgT... args) {
 
 _impl_.obj_file_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.XlaRuntimeExecutableProto.obj_file)
}
inline std::string* XlaRuntimeExecutableProto::mutable_obj_file() {
  std::string* _s = _internal_mutable_obj_file();
  // @@protoc_insertion_point(field_mutable:xla.XlaRuntimeExecutableProto.obj_file)
  return _s;
}
inline const std::string& XlaRuntimeExecutableProto::_internal_obj_file() const {
  return _impl_.obj_file_.Get();
}
inline void XlaRuntimeExecutableProto::_internal_set_obj_file(const std::string& value) {
  
  _impl_.obj_file_.Set(value, GetArenaForAllocation());
}
inline std::string* XlaRuntimeExecutableProto::_internal_mutable_obj_file() {
  
  return _impl_.obj_file_.Mutable(GetArenaForAllocation());
}
inline std::string* XlaRuntimeExecutableProto::release_obj_file() {
  // @@protoc_insertion_point(field_release:xla.XlaRuntimeExecutableProto.obj_file)
  return _impl_.obj_file_.Release();
}
inline void XlaRuntimeExecutableProto::set_allocated_obj_file(std::string* obj_file) {
  if (obj_file != nullptr) {
    
  } else {
    
  }
  _impl_.obj_file_.SetAllocated(obj_file, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.obj_file_.IsDefault()) {
    _impl_.obj_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.XlaRuntimeExecutableProto.obj_file)
}

// string mlir_module = 4;
inline void XlaRuntimeExecutableProto::clear_mlir_module() {
  _impl_.mlir_module_.ClearToEmpty();
}
inline const std::string& XlaRuntimeExecutableProto::mlir_module() const {
  // @@protoc_insertion_point(field_get:xla.XlaRuntimeExecutableProto.mlir_module)
  return _internal_mlir_module();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void XlaRuntimeExecutableProto::set_mlir_module(ArgT0&& arg0, ArgT... args) {
 
 _impl_.mlir_module_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:xla.XlaRuntimeExecutableProto.mlir_module)
}
inline std::string* XlaRuntimeExecutableProto::mutable_mlir_module() {
  std::string* _s = _internal_mutable_mlir_module();
  // @@protoc_insertion_point(field_mutable:xla.XlaRuntimeExecutableProto.mlir_module)
  return _s;
}
inline const std::string& XlaRuntimeExecutableProto::_internal_mlir_module() const {
  return _impl_.mlir_module_.Get();
}
inline void XlaRuntimeExecutableProto::_internal_set_mlir_module(const std::string& value) {
  
  _impl_.mlir_module_.Set(value, GetArenaForAllocation());
}
inline std::string* XlaRuntimeExecutableProto::_internal_mutable_mlir_module() {
  
  return _impl_.mlir_module_.Mutable(GetArenaForAllocation());
}
inline std::string* XlaRuntimeExecutableProto::release_mlir_module() {
  // @@protoc_insertion_point(field_release:xla.XlaRuntimeExecutableProto.mlir_module)
  return _impl_.mlir_module_.Release();
}
inline void XlaRuntimeExecutableProto::set_allocated_mlir_module(std::string* mlir_module) {
  if (mlir_module != nullptr) {
    
  } else {
    
  }
  _impl_.mlir_module_.SetAllocated(mlir_module, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mlir_module_.IsDefault()) {
    _impl_.mlir_module_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:xla.XlaRuntimeExecutableProto.mlir_module)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace xla

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::xla::HloModuleProto_ProfileType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::xla::HloModuleProto_ProfileType>() {
  return ::xla::HloModuleProto_ProfileType_descriptor();
}
template <> struct is_proto_enum< ::xla::HeapSimulatorTrace_Event_Kind> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::xla::HeapSimulatorTrace_Event_Kind>() {
  return ::xla::HeapSimulatorTrace_Event_Kind_descriptor();
}
template <> struct is_proto_enum< ::xla::CustomCallSchedule> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::xla::CustomCallSchedule>() {
  return ::xla::CustomCallSchedule_descriptor();
}
template <> struct is_proto_enum< ::xla::CustomCallApiVersion> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::xla::CustomCallApiVersion>() {
  return ::xla::CustomCallApiVersion_descriptor();
}
template <> struct is_proto_enum< ::xla::Kind> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::xla::Kind>() {
  return ::xla::Kind_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcompiler_2fxla_2fservice_2fhlo_2eproto
